mario/config-pacs-docker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
1c1d9c4474bde5e83523e4135c0f9ed0bcbf8d71
config-pacs-docker/nv/html/nv-nopdf/styles/packages/silentcicero_jszip.js
mario 1c1d9c4474 init
2025-02-26 14:49:25 +07:00

9500 lines
1.1 MiB
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//////////////////////////////////////////////////////////////////////////
// //
// This is a generated file. You can view the original //
// source in your browser if your browser supports source maps. //
// Source maps are supported by all recent versions of Chrome, Safari, //
// and Firefox, and by Internet Explorer 11. //
// //
//////////////////////////////////////////////////////////////////////////
(function () {
/* Imports */
var Meteor = Package.meteor.Meteor;
var global = Package.meteor.global;
var meteorEnv = Package.meteor.meteorEnv;
/* Package-scope variables */
var JSZip;
(function(){
//////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/silentcicero_jszip/packages/silentcicero_jszip.js //
// //
//////////////////////////////////////////////////////////////////////////////////////////
//
(function () {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/silentcicero:jszip/lib/jszip.js //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
/*! // 1
// 2
JSZip - A Javascript class for generating and reading zip files // 3
<http://stuartk.com/jszip> // 4
// 5
(c) 2009-2014 Stuart Knightley <stuart [at] stuartk.com> // 6
Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/master/LICENSE.markdown. // 7
// 8
JSZip uses the library pako released under the MIT license : // 9
https://github.com/nodeca/pako/blob/master/LICENSE // 10
*/ // 11
!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.JSZip=e()}}(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);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.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(_dereq_,module,exports){
'use strict'; // 13
// private property // 14
var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; // 15
// 16
// 17
// public method for encoding // 18
exports.encode = function(input, utf8) { // 19
var output = ""; // 20
var chr1, chr2, chr3, enc1, enc2, enc3, enc4; // 21
var i = 0; // 22
// 23
while (i < input.length) { // 24
// 25
chr1 = input.charCodeAt(i++); // 26
chr2 = input.charCodeAt(i++); // 27
chr3 = input.charCodeAt(i++); // 28
// 29
enc1 = chr1 >> 2; // 30
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4); // 31
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6); // 32
enc4 = chr3 & 63; // 33
// 34
if (isNaN(chr2)) { // 35
enc3 = enc4 = 64; // 36
} // 37
else if (isNaN(chr3)) { // 38
enc4 = 64; // 39
} // 40
// 41
output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4); // 42
// 43
} // 44
// 45
return output; // 46
}; // 47
// 48
// public method for decoding // 49
exports.decode = function(input, utf8) { // 50
var output = ""; // 51
var chr1, chr2, chr3; // 52
var enc1, enc2, enc3, enc4; // 53
var i = 0; // 54
// 55
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, ""); // 56
// 57
while (i < input.length) { // 58
// 59
enc1 = _keyStr.indexOf(input.charAt(i++)); // 60
enc2 = _keyStr.indexOf(input.charAt(i++)); // 61
enc3 = _keyStr.indexOf(input.charAt(i++)); // 62
enc4 = _keyStr.indexOf(input.charAt(i++)); // 63
// 64
chr1 = (enc1 << 2) | (enc2 >> 4); // 65
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2); // 66
chr3 = ((enc3 & 3) << 6) | enc4; // 67
// 68
output = output + String.fromCharCode(chr1); // 69
// 70
if (enc3 != 64) { // 71
output = output + String.fromCharCode(chr2); // 72
} // 73
if (enc4 != 64) { // 74
output = output + String.fromCharCode(chr3); // 75
} // 76
// 77
} // 78
// 79
return output; // 80
// 81
}; // 82
// 83
},{}],2:[function(_dereq_,module,exports){ // 84
'use strict'; // 85
function CompressedObject() { // 86
this.compressedSize = 0; // 87
this.uncompressedSize = 0; // 88
this.crc32 = 0; // 89
this.compressionMethod = null; // 90
this.compressedContent = null; // 91
} // 92
// 93
CompressedObject.prototype = { // 94
/** // 95
* Return the decompressed content in an unspecified format. // 96
* The format will depend on the decompressor. // 97
* @return {Object} the decompressed content. // 98
*/ // 99
getContent: function() { // 100
return null; // see implementation // 101
}, // 102
/** // 103
* Return the compressed content in an unspecified format. // 104
* The format will depend on the compressed conten source. // 105
* @return {Object} the compressed content. // 106
*/ // 107
getCompressedContent: function() { // 108
return null; // see implementation // 109
} // 110
}; // 111
module.exports = CompressedObject; // 112
// 113
},{}],3:[function(_dereq_,module,exports){ // 114
'use strict'; // 115
exports.STORE = { // 116
magic: "\x00\x00", // 117
compress: function(content, compressionOptions) { // 118
return content; // no compression // 119
}, // 120
uncompress: function(content) { // 121
return content; // no compression // 122
}, // 123
compressInputType: null, // 124
uncompressInputType: null // 125
}; // 126
exports.DEFLATE = _dereq_('./flate'); // 127
// 128
},{"./flate":8}],4:[function(_dereq_,module,exports){ // 129
'use strict'; // 130
// 131
var utils = _dereq_('./utils'); // 132
// 133
var table = [ // 134
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, // 135
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, // 136
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, // 137
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, // 138
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, // 139
0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, // 140
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, // 141
0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, // 142
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, // 143
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, // 144
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, // 145
0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, // 146
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, // 147
0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, // 148
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, // 149
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, // 150
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, // 151
0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, // 152
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, // 153
0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, // 154
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, // 155
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, // 156
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, // 157
0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, // 158
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, // 159
0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, // 160
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, // 161
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, // 162
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, // 163
0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, // 164
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, // 165
0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, // 166
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, // 167
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, // 168
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, // 169
0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, // 170
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, // 171
0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, // 172
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, // 173
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, // 174
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, // 175
0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, // 176
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, // 177
0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, // 178
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, // 179
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, // 180
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, // 181
0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, // 182
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, // 183
0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, // 184
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, // 185
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, // 186
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, // 187
0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, // 188
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, // 189
0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, // 190
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, // 191
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, // 192
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, // 193
0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, // 194
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, // 195
0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, // 196
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, // 197
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D // 198
]; // 199
// 200
/** // 201
* // 202
* Javascript crc32 // 203
* http://www.webtoolkit.info/ // 204
* // 205
*/ // 206
module.exports = function crc32(input, crc) { // 207
if (typeof input === "undefined" || !input.length) { // 208
return 0; // 209
} // 210
// 211
var isArray = utils.getTypeOf(input) !== "string"; // 212
// 213
if (typeof(crc) == "undefined") { // 214
crc = 0; // 215
} // 216
var x = 0; // 217
var y = 0; // 218
var b = 0; // 219
// 220
crc = crc ^ (-1); // 221
for (var i = 0, iTop = input.length; i < iTop; i++) { // 222
b = isArray ? input[i] : input.charCodeAt(i); // 223
y = (crc ^ b) & 0xFF; // 224
x = table[y]; // 225
crc = (crc >>> 8) ^ x; // 226
} // 227
// 228
return crc ^ (-1); // 229
}; // 230
// vim: set shiftwidth=4 softtabstop=4: // 231
// 232
},{"./utils":21}],5:[function(_dereq_,module,exports){ // 233
'use strict'; // 234
var utils = _dereq_('./utils'); // 235
// 236
function DataReader(data) { // 237
this.data = null; // type : see implementation // 238
this.length = 0; // 239
this.index = 0; // 240
} // 241
DataReader.prototype = { // 242
/** // 243
* Check that the offset will not go too far. // 244
* @param {string} offset the additional offset to check. // 245
* @throws {Error} an Error if the offset is out of bounds. // 246
*/ // 247
checkOffset: function(offset) { // 248
this.checkIndex(this.index + offset); // 249
}, // 250
/** // 251
* Check that the specifed index will not be too far. // 252
* @param {string} newIndex the index to check. // 253
* @throws {Error} an Error if the index is out of bounds. // 254
*/ // 255
checkIndex: function(newIndex) { // 256
if (this.length < newIndex || newIndex < 0) { // 257
throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
} // 259
}, // 260
/** // 261
* Change the index. // 262
* @param {number} newIndex The new index. // 263
* @throws {Error} if the new index is out of the data. // 264
*/ // 265
setIndex: function(newIndex) { // 266
this.checkIndex(newIndex); // 267
this.index = newIndex; // 268
}, // 269
/** // 270
* Skip the next n bytes. // 271
* @param {number} n the number of bytes to skip. // 272
* @throws {Error} if the new index is out of the data. // 273
*/ // 274
skip: function(n) { // 275
this.setIndex(this.index + n); // 276
}, // 277
/** // 278
* Get the byte at the specified index. // 279
* @param {number} i the index to use. // 280
* @return {number} a byte. // 281
*/ // 282
byteAt: function(i) { // 283
// see implementations // 284
}, // 285
/** // 286
* Get the next number with a given byte size. // 287
* @param {number} size the number of bytes to read. // 288
* @return {number} the corresponding number. // 289
*/ // 290
readInt: function(size) { // 291
var result = 0, // 292
i; // 293
this.checkOffset(size); // 294
for (i = this.index + size - 1; i >= this.index; i--) { // 295
result = (result << 8) + this.byteAt(i); // 296
} // 297
this.index += size; // 298
return result; // 299
}, // 300
/** // 301
* Get the next string with a given byte size. // 302
* @param {number} size the number of bytes to read. // 303
* @return {string} the corresponding string. // 304
*/ // 305
readString: function(size) { // 306
return utils.transformTo("string", this.readData(size)); // 307
}, // 308
/** // 309
* Get raw data without conversion, <size> bytes. // 310
* @param {number} size the number of bytes to read. // 311
* @return {Object} the raw data, implementation specific. // 312
*/ // 313
readData: function(size) { // 314
// see implementations // 315
}, // 316
/** // 317
* Find the last occurence of a zip signature (4 bytes). // 318
* @param {string} sig the signature to find. // 319
* @return {number} the index of the last occurence, -1 if not found. // 320
*/ // 321
lastIndexOfSignature: function(sig) { // 322
// see implementations // 323
}, // 324
/** // 325
* Get the next date. // 326
* @return {Date} the date. // 327
*/ // 328
readDate: function() { // 329
var dostime = this.readInt(4); // 330
return new Date( // 331
((dostime >> 25) & 0x7f) + 1980, // year // 332
((dostime >> 21) & 0x0f) - 1, // month // 333
(dostime >> 16) & 0x1f, // day // 334
(dostime >> 11) & 0x1f, // hour // 335
(dostime >> 5) & 0x3f, // minute // 336
(dostime & 0x1f) << 1); // second // 337
} // 338
}; // 339
module.exports = DataReader; // 340
// 341
},{"./utils":21}],6:[function(_dereq_,module,exports){ // 342
'use strict'; // 343
exports.base64 = false; // 344
exports.binary = false; // 345
exports.dir = false; // 346
exports.createFolders = false; // 347
exports.date = null; // 348
exports.compression = null; // 349
exports.compressionOptions = null; // 350
exports.comment = null; // 351
exports.unixPermissions = null; // 352
exports.dosPermissions = null; // 353
// 354
},{}],7:[function(_dereq_,module,exports){ // 355
'use strict'; // 356
var utils = _dereq_('./utils'); // 357
// 358
/** // 359
* @deprecated // 360
* This function will be removed in a future version without replacement. // 361
*/ // 362
exports.string2binary = function(str) { // 363
return utils.string2binary(str); // 364
}; // 365
// 366
/** // 367
* @deprecated // 368
* This function will be removed in a future version without replacement. // 369
*/ // 370
exports.string2Uint8Array = function(str) { // 371
return utils.transformTo("uint8array", str); // 372
}; // 373
// 374
/** // 375
* @deprecated // 376
* This function will be removed in a future version without replacement. // 377
*/ // 378
exports.uint8Array2String = function(array) { // 379
return utils.transformTo("string", array); // 380
}; // 381
// 382
/** // 383
* @deprecated // 384
* This function will be removed in a future version without replacement. // 385
*/ // 386
exports.string2Blob = function(str) { // 387
var buffer = utils.transformTo("arraybuffer", str); // 388
return utils.arrayBuffer2Blob(buffer); // 389
}; // 390
// 391
/** // 392
* @deprecated // 393
* This function will be removed in a future version without replacement. // 394
*/ // 395
exports.arrayBuffer2Blob = function(buffer) { // 396
return utils.arrayBuffer2Blob(buffer); // 397
}; // 398
// 399
/** // 400
* @deprecated // 401
* This function will be removed in a future version without replacement. // 402
*/ // 403
exports.transformTo = function(outputType, input) { // 404
return utils.transformTo(outputType, input); // 405
}; // 406
// 407
/** // 408
* @deprecated // 409
* This function will be removed in a future version without replacement. // 410
*/ // 411
exports.getTypeOf = function(input) { // 412
return utils.getTypeOf(input); // 413
}; // 414
// 415
/** // 416
* @deprecated // 417
* This function will be removed in a future version without replacement. // 418
*/ // 419
exports.checkSupport = function(type) { // 420
return utils.checkSupport(type); // 421
}; // 422
// 423
/** // 424
* @deprecated // 425
* This value will be removed in a future version without replacement. // 426
*/ // 427
exports.MAX_VALUE_16BITS = utils.MAX_VALUE_16BITS; // 428
// 429
/** // 430
* @deprecated // 431
* This value will be removed in a future version without replacement. // 432
*/ // 433
exports.MAX_VALUE_32BITS = utils.MAX_VALUE_32BITS; // 434
// 435
// 436
/** // 437
* @deprecated // 438
* This function will be removed in a future version without replacement. // 439
*/ // 440
exports.pretty = function(str) { // 441
return utils.pretty(str); // 442
}; // 443
// 444
/** // 445
* @deprecated // 446
* This function will be removed in a future version without replacement. // 447
*/ // 448
exports.findCompression = function(compressionMethod) { // 449
return utils.findCompression(compressionMethod); // 450
}; // 451
// 452
/** // 453
* @deprecated // 454
* This function will be removed in a future version without replacement. // 455
*/ // 456
exports.isRegExp = function (object) { // 457
return utils.isRegExp(object); // 458
}; // 459
// 460
// 461
},{"./utils":21}],8:[function(_dereq_,module,exports){ // 462
'use strict'; // 463
var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
// 465
var pako = _dereq_("pako"); // 466
exports.uncompressInputType = USE_TYPEDARRAY ? "uint8array" : "array"; // 467
exports.compressInputType = USE_TYPEDARRAY ? "uint8array" : "array"; // 468
// 469
exports.magic = "\x08\x00"; // 470
exports.compress = function(input, compressionOptions) { // 471
return pako.deflateRaw(input, { // 472
level : compressionOptions.level || -1 // default compression // 473
}); // 474
}; // 475
exports.uncompress = function(input) { // 476
return pako.inflateRaw(input); // 477
}; // 478
// 479
},{"pako":24}],9:[function(_dereq_,module,exports){ // 480
'use strict'; // 481
// 482
var base64 = _dereq_('./base64'); // 483
// 484
/** // 485
Usage: // 486
zip = new JSZip(); // 487
zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing"); // 488
zip.folder("images").file("smile.gif", base64Data, {base64: true}); // 489
zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")}); // 490
zip.remove("tempfile"); // 491
// 492
base64zip = zip.generate(); // 493
// 494
**/ // 495
// 496
/** // 497
* Representation a of zip file in js // 498
* @constructor // 499
* @param {String=|ArrayBuffer=|Uint8Array=} data the data to load, if any (optional). // 500
* @param {Object=} options the options for creating this objects (optional). // 501
*/ // 502
function JSZip(data, options) { // 503
// if this constructor is used without `new`, it adds `new` before itself: // 504
if(!(this instanceof JSZip)) return new JSZip(data, options); // 505
// 506
// object containing the files : // 507
// { // 508
// "folder/" : {...}, // 509
// "folder/data.txt" : {...} // 510
// } // 511
this.files = {}; // 512
// 513
this.comment = null; // 514
// 515
// Where we are in the hierarchy // 516
this.root = ""; // 517
if (data) { // 518
this.load(data, options); // 519
} // 520
this.clone = function() { // 521
var newObj = new JSZip(); // 522
for (var i in this) { // 523
if (typeof this[i] !== "function") { // 524
newObj[i] = this[i]; // 525
} // 526
} // 527
return newObj; // 528
}; // 529
} // 530
JSZip.prototype = _dereq_('./object'); // 531
JSZip.prototype.load = _dereq_('./load'); // 532
JSZip.support = _dereq_('./support'); // 533
JSZip.defaults = _dereq_('./defaults'); // 534
// 535
/** // 536
* @deprecated // 537
* This namespace will be removed in a future version without replacement. // 538
*/ // 539
JSZip.utils = _dereq_('./deprecatedPublicUtils'); // 540
// 541
JSZip.base64 = { // 542
/** // 543
* @deprecated // 544
* This method will be removed in a future version without replacement. // 545
*/ // 546
encode : function(input) { // 547
return base64.encode(input); // 548
}, // 549
/** // 550
* @deprecated // 551
* This method will be removed in a future version without replacement. // 552
*/ // 553
decode : function(input) { // 554
return base64.decode(input); // 555
} // 556
}; // 557
JSZip.compressions = _dereq_('./compressions'); // 558
module.exports = JSZip; // 559
// 560
},{"./base64":1,"./compressions":3,"./defaults":6,"./deprecatedPublicUtils":7,"./load":10,"./object":13,"./support":17}],10:[function(_dereq_,module,exports){
'use strict'; // 562
var base64 = _dereq_('./base64'); // 563
var ZipEntries = _dereq_('./zipEntries'); // 564
module.exports = function(data, options) { // 565
var files, zipEntries, i, input; // 566
options = options || {}; // 567
if (options.base64) { // 568
data = base64.decode(data); // 569
} // 570
// 571
zipEntries = new ZipEntries(data, options); // 572
files = zipEntries.files; // 573
for (i = 0; i < files.length; i++) { // 574
input = files[i]; // 575
this.file(input.fileName, input.decompressed, { // 576
binary: true, // 577
optimizedBinaryString: true, // 578
date: input.date, // 579
dir: input.dir, // 580
comment : input.fileComment.length ? input.fileComment : null, // 581
unixPermissions : input.unixPermissions, // 582
dosPermissions : input.dosPermissions, // 583
createFolders: options.createFolders // 584
}); // 585
} // 586
if (zipEntries.zipComment.length) { // 587
this.comment = zipEntries.zipComment; // 588
} // 589
// 590
return this; // 591
}; // 592
// 593
},{"./base64":1,"./zipEntries":22}],11:[function(_dereq_,module,exports){ // 594
(function (Buffer){ // 595
'use strict'; // 596
module.exports = function(data, encoding){ // 597
return new Buffer(data, encoding); // 598
}; // 599
module.exports.test = function(b){ // 600
return Buffer.isBuffer(b); // 601
}; // 602
// 603
}).call(this,(typeof Buffer !== "undefined" ? Buffer : undefined)) // 604
},{}],12:[function(_dereq_,module,exports){ // 605
'use strict'; // 606
var Uint8ArrayReader = _dereq_('./uint8ArrayReader'); // 607
// 608
function NodeBufferReader(data) { // 609
this.data = data; // 610
this.length = this.data.length; // 611
this.index = 0; // 612
} // 613
NodeBufferReader.prototype = new Uint8ArrayReader(); // 614
// 615
/** // 616
* @see DataReader.readData // 617
*/ // 618
NodeBufferReader.prototype.readData = function(size) { // 619
this.checkOffset(size); // 620
var result = this.data.slice(this.index, this.index + size); // 621
this.index += size; // 622
return result; // 623
}; // 624
module.exports = NodeBufferReader; // 625
// 626
},{"./uint8ArrayReader":18}],13:[function(_dereq_,module,exports){ // 627
'use strict'; // 628
var support = _dereq_('./support'); // 629
var utils = _dereq_('./utils'); // 630
var crc32 = _dereq_('./crc32'); // 631
var signature = _dereq_('./signature'); // 632
var defaults = _dereq_('./defaults'); // 633
var base64 = _dereq_('./base64'); // 634
var compressions = _dereq_('./compressions'); // 635
var CompressedObject = _dereq_('./compressedObject'); // 636
var nodeBuffer = _dereq_('./nodeBuffer'); // 637
var utf8 = _dereq_('./utf8'); // 638
var StringWriter = _dereq_('./stringWriter'); // 639
var Uint8ArrayWriter = _dereq_('./uint8ArrayWriter'); // 640
// 641
/** // 642
* Returns the raw data of a ZipObject, decompress the content if necessary. // 643
* @param {ZipObject} file the file to use. // 644
* @return {String|ArrayBuffer|Uint8Array|Buffer} the data. // 645
*/ // 646
var getRawData = function(file) { // 647
if (file._data instanceof CompressedObject) { // 648
file._data = file._data.getContent(); // 649
file.options.binary = true; // 650
file.options.base64 = false; // 651
// 652
if (utils.getTypeOf(file._data) === "uint8array") { // 653
var copy = file._data; // 654
// when reading an arraybuffer, the CompressedObject mechanism will keep it and subarray() a Uint8Array. // 655
// if we request a file in the same format, we might get the same Uint8Array or its ArrayBuffer (the original zip file).
file._data = new Uint8Array(copy.length); // 657
// with an empty Uint8Array, Opera fails with a "Offset larger than array size" // 658
if (copy.length !== 0) { // 659
file._data.set(copy, 0); // 660
} // 661
} // 662
} // 663
return file._data; // 664
}; // 665
// 666
/** // 667
* Returns the data of a ZipObject in a binary form. If the content is an unicode string, encode it. // 668
* @param {ZipObject} file the file to use. // 669
* @return {String|ArrayBuffer|Uint8Array|Buffer} the data. // 670
*/ // 671
var getBinaryData = function(file) { // 672
var result = getRawData(file), // 673
type = utils.getTypeOf(result); // 674
if (type === "string") { // 675
if (!file.options.binary) { // 676
// unicode text ! // 677
// unicode string => binary string is a painful process, check if we can avoid it. // 678
if (support.nodebuffer) { // 679
return nodeBuffer(result, "utf-8"); // 680
} // 681
} // 682
return file.asBinary(); // 683
} // 684
return result; // 685
}; // 686
// 687
/** // 688
* Transform this._data into a string. // 689
* @param {function} filter a function String -> String, applied if not null on the result. // 690
* @return {String} the string representing this._data. // 691
*/ // 692
var dataToString = function(asUTF8) { // 693
var result = getRawData(this); // 694
if (result === null || typeof result === "undefined") { // 695
return ""; // 696
} // 697
// if the data is a base64 string, we decode it before checking the encoding ! // 698
if (this.options.base64) { // 699
result = base64.decode(result); // 700
} // 701
if (asUTF8 && this.options.binary) { // 702
// JSZip.prototype.utf8decode supports arrays as input // 703
// skip to array => string step, utf8decode will do it. // 704
result = out.utf8decode(result); // 705
} // 706
else { // 707
// no utf8 transformation, do the array => string step. // 708
result = utils.transformTo("string", result); // 709
} // 710
// 711
if (!asUTF8 && !this.options.binary) { // 712
result = utils.transformTo("string", out.utf8encode(result)); // 713
} // 714
return result; // 715
}; // 716
/** // 717
* A simple object representing a file in the zip file. // 718
* @constructor // 719
* @param {string} name the name of the file // 720
* @param {String|ArrayBuffer|Uint8Array|Buffer} data the data // 721
* @param {Object} options the options of the file // 722
*/ // 723
var ZipObject = function(name, data, options) { // 724
this.name = name; // 725
this.dir = options.dir; // 726
this.date = options.date; // 727
this.comment = options.comment; // 728
this.unixPermissions = options.unixPermissions; // 729
this.dosPermissions = options.dosPermissions; // 730
// 731
this._data = data; // 732
this.options = options; // 733
// 734
/* // 735
* This object contains initial values for dir and date. // 736
* With them, we can check if the user changed the deprecated metadata in // 737
* `ZipObject#options` or not. // 738
*/ // 739
this._initialMetadata = { // 740
dir : options.dir, // 741
date : options.date // 742
}; // 743
}; // 744
// 745
ZipObject.prototype = { // 746
/** // 747
* Return the content as UTF8 string. // 748
* @return {string} the UTF8 string. // 749
*/ // 750
asText: function() { // 751
return dataToString.call(this, true); // 752
}, // 753
/** // 754
* Returns the binary content. // 755
* @return {string} the content as binary. // 756
*/ // 757
asBinary: function() { // 758
return dataToString.call(this, false); // 759
}, // 760
/** // 761
* Returns the content as a nodejs Buffer. // 762
* @return {Buffer} the content as a Buffer. // 763
*/ // 764
asNodeBuffer: function() { // 765
var result = getBinaryData(this); // 766
return utils.transformTo("nodebuffer", result); // 767
}, // 768
/** // 769
* Returns the content as an Uint8Array. // 770
* @return {Uint8Array} the content as an Uint8Array. // 771
*/ // 772
asUint8Array: function() { // 773
var result = getBinaryData(this); // 774
return utils.transformTo("uint8array", result); // 775
}, // 776
/** // 777
* Returns the content as an ArrayBuffer. // 778
* @return {ArrayBuffer} the content as an ArrayBufer. // 779
*/ // 780
asArrayBuffer: function() { // 781
return this.asUint8Array().buffer; // 782
} // 783
}; // 784
// 785
/** // 786
* Transform an integer into a string in hexadecimal. // 787
* @private // 788
* @param {number} dec the number to convert. // 789
* @param {number} bytes the number of bytes to generate. // 790
* @returns {string} the result. // 791
*/ // 792
var decToHex = function(dec, bytes) { // 793
var hex = "", // 794
i; // 795
for (i = 0; i < bytes; i++) { // 796
hex += String.fromCharCode(dec & 0xff); // 797
dec = dec >>> 8; // 798
} // 799
return hex; // 800
}; // 801
// 802
/** // 803
* Merge the objects passed as parameters into a new one. // 804
* @private // 805
* @param {...Object} var_args All objects to merge. // 806
* @return {Object} a new object with the data of the others. // 807
*/ // 808
var extend = function() { // 809
var result = {}, i, attr; // 810
for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers // 811
for (attr in arguments[i]) { // 812
if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") { // 813
result[attr] = arguments[i][attr]; // 814
} // 815
} // 816
} // 817
return result; // 818
}; // 819
// 820
/** // 821
* Transforms the (incomplete) options from the user into the complete // 822
* set of options to create a file. // 823
* @private // 824
* @param {Object} o the options from the user. // 825
* @return {Object} the complete set of options. // 826
*/ // 827
var prepareFileAttrs = function(o) { // 828
o = o || {}; // 829
if (o.base64 === true && (o.binary === null || o.binary === undefined)) { // 830
o.binary = true; // 831
} // 832
o = extend(o, defaults); // 833
o.date = o.date || new Date(); // 834
if (o.compression !== null) o.compression = o.compression.toUpperCase(); // 835
// 836
return o; // 837
}; // 838
// 839
/** // 840
* Add a file in the current folder. // 841
* @private // 842
* @param {string} name the name of the file // 843
* @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file // 844
* @param {Object} o the options of the file // 845
* @return {Object} the new file. // 846
*/ // 847
var fileAdd = function(name, data, o) { // 848
// be sure sub folders exist // 849
var dataType = utils.getTypeOf(data), // 850
parent; // 851
// 852
o = prepareFileAttrs(o); // 853
// 854
if (typeof o.unixPermissions === "string") { // 855
o.unixPermissions = parseInt(o.unixPermissions, 8); // 856
} // 857
// 858
// UNX_IFDIR 0040000 see zipinfo.c // 859
if (o.unixPermissions && (o.unixPermissions & 0x4000)) { // 860
o.dir = true; // 861
} // 862
// Bit 4 Directory // 863
if (o.dosPermissions && (o.dosPermissions & 0x0010)) { // 864
o.dir = true; // 865
} // 866
// 867
if (o.dir) { // 868
name = forceTrailingSlash(name); // 869
} // 870
// 871
if (o.createFolders && (parent = parentFolder(name))) { // 872
folderAdd.call(this, parent, true); // 873
} // 874
// 875
if (o.dir || data === null || typeof data === "undefined") { // 876
o.base64 = false; // 877
o.binary = false; // 878
data = null; // 879
dataType = null; // 880
} // 881
else if (dataType === "string") { // 882
if (o.binary && !o.base64) { // 883
// optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask // 884
if (o.optimizedBinaryString !== true) { // 885
// this is a string, not in a base64 format. // 886
// Be sure that this is a correct "binary string" // 887
data = utils.string2binary(data); // 888
} // 889
} // 890
} // 891
else { // arraybuffer, uint8array, ... // 892
o.base64 = false; // 893
o.binary = true; // 894
// 895
if (!dataType && !(data instanceof CompressedObject)) { // 896
throw new Error("The data of '" + name + "' is in an unsupported format !"); // 897
} // 898
// 899
// special case : it's way easier to work with Uint8Array than with ArrayBuffer // 900
if (dataType === "arraybuffer") { // 901
data = utils.transformTo("uint8array", data); // 902
} // 903
} // 904
// 905
var object = new ZipObject(name, data, o); // 906
this.files[name] = object; // 907
return object; // 908
}; // 909
// 910
/** // 911
* Find the parent folder of the path. // 912
* @private // 913
* @param {string} path the path to use // 914
* @return {string} the parent folder, or "" // 915
*/ // 916
var parentFolder = function (path) { // 917
if (path.slice(-1) == '/') { // 918
path = path.substring(0, path.length - 1); // 919
} // 920
var lastSlash = path.lastIndexOf('/'); // 921
return (lastSlash > 0) ? path.substring(0, lastSlash) : ""; // 922
}; // 923
// 924
// 925
/** // 926
* Returns the path with a slash at the end. // 927
* @private // 928
* @param {String} path the path to check. // 929
* @return {String} the path with a trailing slash. // 930
*/ // 931
var forceTrailingSlash = function(path) { // 932
// Check the name ends with a / // 933
if (path.slice(-1) != "/") { // 934
path += "/"; // IE doesn't like substr(-1) // 935
} // 936
return path; // 937
}; // 938
/** // 939
* Add a (sub) folder in the current folder. // 940
* @private // 941
* @param {string} name the folder's name // 942
* @param {boolean=} [createFolders] If true, automatically create sub // 943
* folders. Defaults to false. // 944
* @return {Object} the new folder. // 945
*/ // 946
var folderAdd = function(name, createFolders) { // 947
createFolders = (typeof createFolders !== 'undefined') ? createFolders : false; // 948
// 949
name = forceTrailingSlash(name); // 950
// 951
// Does this folder already exist? // 952
if (!this.files[name]) { // 953
fileAdd.call(this, name, null, { // 954
dir: true, // 955
createFolders: createFolders // 956
}); // 957
} // 958
return this.files[name]; // 959
}; // 960
// 961
/** // 962
* Generate a JSZip.CompressedObject for a given zipOject. // 963
* @param {ZipObject} file the object to read. // 964
* @param {JSZip.compression} compression the compression to use. // 965
* @param {Object} compressionOptions the options to use when compressing. // 966
* @return {JSZip.CompressedObject} the compressed result. // 967
*/ // 968
var generateCompressedObjectFrom = function(file, compression, compressionOptions) { // 969
var result = new CompressedObject(), // 970
content; // 971
// 972
// the data has not been decompressed, we might reuse things ! // 973
if (file._data instanceof CompressedObject) { // 974
result.uncompressedSize = file._data.uncompressedSize; // 975
result.crc32 = file._data.crc32; // 976
// 977
if (result.uncompressedSize === 0 || file.dir) { // 978
compression = compressions['STORE']; // 979
result.compressedContent = ""; // 980
result.crc32 = 0; // 981
} // 982
else if (file._data.compressionMethod === compression.magic) { // 983
result.compressedContent = file._data.getCompressedContent(); // 984
} // 985
else { // 986
content = file._data.getContent(); // 987
// need to decompress / recompress // 988
result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content), compressionOptions);
} // 990
} // 991
else { // 992
// have uncompressed data // 993
content = getBinaryData(file); // 994
if (!content || content.length === 0 || file.dir) { // 995
compression = compressions['STORE']; // 996
content = ""; // 997
} // 998
result.uncompressedSize = content.length; // 999
result.crc32 = crc32(content); // 1000
result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content), compressionOptions);
} // 1002
// 1003
result.compressedSize = result.compressedContent.length; // 1004
result.compressionMethod = compression.magic; // 1005
// 1006
return result; // 1007
}; // 1008
// 1009
// 1010
// 1011
// 1012
/** // 1013
* Generate the UNIX part of the external file attributes. // 1014
* @param {Object} unixPermissions the unix permissions or null. // 1015
* @param {Boolean} isDir true if the entry is a directory, false otherwise. // 1016
* @return {Number} a 32 bit integer. // 1017
* // 1018
* adapted from http://unix.stackexchange.com/questions/14705/the-zip-formats-external-file-attribute : // 1019
* // 1020
* TTTTsstrwxrwxrwx0000000000ADVSHR // 1021
* ^^^^____________________________ file type, see zipinfo.c (UNX_*) // 1022
* ^^^_________________________ setuid, setgid, sticky // 1023
* ^^^^^^^^^________________ permissions // 1024
* ^^^^^^^^^^______ not used ? // 1025
* ^^^^^^ DOS attribute bits : Archive, Directory, Volume label, System file, Hidden, Read only
*/ // 1027
var generateUnixExternalFileAttr = function (unixPermissions, isDir) { // 1028
// 1029
var result = unixPermissions; // 1030
if (!unixPermissions) { // 1031
// I can't use octal values in strict mode, hence the hexa. // 1032
// 040775 => 0x41fd // 1033
// 0100664 => 0x81b4 // 1034
result = isDir ? 0x41fd : 0x81b4; // 1035
} // 1036
// 1037
return (result & 0xFFFF) << 16; // 1038
}; // 1039
// 1040
/** // 1041
* Generate the DOS part of the external file attributes. // 1042
* @param {Object} dosPermissions the dos permissions or null. // 1043
* @param {Boolean} isDir true if the entry is a directory, false otherwise. // 1044
* @return {Number} a 32 bit integer. // 1045
* // 1046
* Bit 0 Read-Only // 1047
* Bit 1 Hidden // 1048
* Bit 2 System // 1049
* Bit 3 Volume Label // 1050
* Bit 4 Directory // 1051
* Bit 5 Archive // 1052
*/ // 1053
var generateDosExternalFileAttr = function (dosPermissions, isDir) { // 1054
// 1055
// the dir flag is already set for compatibility // 1056
// 1057
return (dosPermissions || 0) & 0x3F; // 1058
}; // 1059
// 1060
/** // 1061
* Generate the various parts used in the construction of the final zip file. // 1062
* @param {string} name the file name. // 1063
* @param {ZipObject} file the file content. // 1064
* @param {JSZip.CompressedObject} compressedObject the compressed object. // 1065
* @param {number} offset the current offset from the start of the zip file. // 1066
* @param {String} platform let's pretend we are this platform (change platform dependents fields) // 1067
* @return {object} the zip parts. // 1068
*/ // 1069
var generateZipParts = function(name, file, compressedObject, offset, platform) { // 1070
var data = compressedObject.compressedContent, // 1071
utfEncodedFileName = utils.transformTo("string", utf8.utf8encode(file.name)), // 1072
comment = file.comment || "", // 1073
utfEncodedComment = utils.transformTo("string", utf8.utf8encode(comment)), // 1074
useUTF8ForFileName = utfEncodedFileName.length !== file.name.length, // 1075
useUTF8ForComment = utfEncodedComment.length !== comment.length, // 1076
o = file.options, // 1077
dosTime, // 1078
dosDate, // 1079
extraFields = "", // 1080
unicodePathExtraField = "", // 1081
unicodeCommentExtraField = "", // 1082
dir, date; // 1083
// 1084
// 1085
// handle the deprecated options.dir // 1086
if (file._initialMetadata.dir !== file.dir) { // 1087
dir = file.dir; // 1088
} else { // 1089
dir = o.dir; // 1090
} // 1091
// 1092
// handle the deprecated options.date // 1093
if(file._initialMetadata.date !== file.date) { // 1094
date = file.date; // 1095
} else { // 1096
date = o.date; // 1097
} // 1098
// 1099
var extFileAttr = 0; // 1100
var versionMadeBy = 0; // 1101
if (dir) { // 1102
// dos or unix, we set the dos dir flag // 1103
extFileAttr |= 0x00010; // 1104
} // 1105
if(platform === "UNIX") { // 1106
versionMadeBy = 0x031E; // UNIX, version 3.0 // 1107
extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir); // 1108
} else { // DOS or other, fallback to DOS // 1109
versionMadeBy = 0x0014; // DOS, version 2.0 // 1110
extFileAttr |= generateDosExternalFileAttr(file.dosPermissions, dir); // 1111
} // 1112
// 1113
// date // 1114
// @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html // 1115
// @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html // 1116
// @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html // 1117
// 1118
dosTime = date.getHours(); // 1119
dosTime = dosTime << 6; // 1120
dosTime = dosTime | date.getMinutes(); // 1121
dosTime = dosTime << 5; // 1122
dosTime = dosTime | date.getSeconds() / 2; // 1123
// 1124
dosDate = date.getFullYear() - 1980; // 1125
dosDate = dosDate << 4; // 1126
dosDate = dosDate | (date.getMonth() + 1); // 1127
dosDate = dosDate << 5; // 1128
dosDate = dosDate | date.getDate(); // 1129
// 1130
if (useUTF8ForFileName) { // 1131
// set the unicode path extra field. unzip needs at least one extra // 1132
// field to correctly handle unicode path, so using the path is as good // 1133
// as any other information. This could improve the situation with // 1134
// other archive managers too. // 1135
// This field is usually used without the utf8 flag, with a non // 1136
// unicode path in the header (winrar, winzip). This helps (a bit) // 1137
// with the messy Windows' default compressed folders feature but // 1138
// breaks on p7zip which doesn't seek the unicode path extra field. // 1139
// So for now, UTF-8 everywhere ! // 1140
unicodePathExtraField = // 1141
// Version // 1142
decToHex(1, 1) + // 1143
// NameCRC32 // 1144
decToHex(crc32(utfEncodedFileName), 4) + // 1145
// UnicodeName // 1146
utfEncodedFileName; // 1147
// 1148
extraFields += // 1149
// Info-ZIP Unicode Path Extra Field // 1150
"\x75\x70" + // 1151
// size // 1152
decToHex(unicodePathExtraField.length, 2) + // 1153
// content // 1154
unicodePathExtraField; // 1155
} // 1156
// 1157
if(useUTF8ForComment) { // 1158
// 1159
unicodeCommentExtraField = // 1160
// Version // 1161
decToHex(1, 1) + // 1162
// CommentCRC32 // 1163
decToHex(this.crc32(utfEncodedComment), 4) + // 1164
// UnicodeName // 1165
utfEncodedComment; // 1166
// 1167
extraFields += // 1168
// Info-ZIP Unicode Path Extra Field // 1169
"\x75\x63" + // 1170
// size // 1171
decToHex(unicodeCommentExtraField.length, 2) + // 1172
// content // 1173
unicodeCommentExtraField; // 1174
} // 1175
// 1176
var header = ""; // 1177
// 1178
// version needed to extract // 1179
header += "\x0A\x00"; // 1180
// general purpose bit flag // 1181
// set bit 11 if utf8 // 1182
header += (useUTF8ForFileName || useUTF8ForComment) ? "\x00\x08" : "\x00\x00"; // 1183
// compression method // 1184
header += compressedObject.compressionMethod; // 1185
// last mod file time // 1186
header += decToHex(dosTime, 2); // 1187
// last mod file date // 1188
header += decToHex(dosDate, 2); // 1189
// crc-32 // 1190
header += decToHex(compressedObject.crc32, 4); // 1191
// compressed size // 1192
header += decToHex(compressedObject.compressedSize, 4); // 1193
// uncompressed size // 1194
header += decToHex(compressedObject.uncompressedSize, 4); // 1195
// file name length // 1196
header += decToHex(utfEncodedFileName.length, 2); // 1197
// extra field length // 1198
header += decToHex(extraFields.length, 2); // 1199
// 1200
// 1201
var fileRecord = signature.LOCAL_FILE_HEADER + header + utfEncodedFileName + extraFields; // 1202
// 1203
var dirRecord = signature.CENTRAL_FILE_HEADER + // 1204
// version made by (00: DOS) // 1205
decToHex(versionMadeBy, 2) + // 1206
// file header (common to file and central directory) // 1207
header + // 1208
// file comment length // 1209
decToHex(utfEncodedComment.length, 2) + // 1210
// disk number start // 1211
"\x00\x00" + // 1212
// internal file attributes TODO // 1213
"\x00\x00" + // 1214
// external file attributes // 1215
decToHex(extFileAttr, 4) + // 1216
// relative offset of local header // 1217
decToHex(offset, 4) + // 1218
// file name // 1219
utfEncodedFileName + // 1220
// extra field // 1221
extraFields + // 1222
// file comment // 1223
utfEncodedComment; // 1224
// 1225
return { // 1226
fileRecord: fileRecord, // 1227
dirRecord: dirRecord, // 1228
compressedObject: compressedObject // 1229
}; // 1230
}; // 1231
// 1232
// 1233
// return the actual prototype of JSZip // 1234
var out = { // 1235
/** // 1236
* Read an existing zip and merge the data in the current JSZip object. // 1237
* The implementation is in jszip-load.js, don't forget to include it. // 1238
* @param {String|ArrayBuffer|Uint8Array|Buffer} stream The stream to load // 1239
* @param {Object} options Options for loading the stream. // 1240
* options.base64 : is the stream in base64 ? default : false // 1241
* @return {JSZip} the current JSZip object // 1242
*/ // 1243
load: function(stream, options) { // 1244
throw new Error("Load method is not defined. Is the file jszip-load.js included ?"); // 1245
}, // 1246
// 1247
/** // 1248
* Filter nested files/folders with the specified function. // 1249
* @param {Function} search the predicate to use : // 1250
* function (relativePath, file) {...} // 1251
* It takes 2 arguments : the relative path and the file. // 1252
* @return {Array} An array of matching elements. // 1253
*/ // 1254
filter: function(search) { // 1255
var result = [], // 1256
filename, relativePath, file, fileClone; // 1257
for (filename in this.files) { // 1258
if (!this.files.hasOwnProperty(filename)) { // 1259
continue; // 1260
} // 1261
file = this.files[filename]; // 1262
// return a new object, don't let the user mess with our internal objects :) // 1263
fileClone = new ZipObject(file.name, file._data, extend(file.options)); // 1264
relativePath = filename.slice(this.root.length, filename.length); // 1265
if (filename.slice(0, this.root.length) === this.root && // the file is in the current root // 1266
search(relativePath, fileClone)) { // and the file matches the function // 1267
result.push(fileClone); // 1268
} // 1269
} // 1270
return result; // 1271
}, // 1272
// 1273
/** // 1274
* Add a file to the zip file, or search a file. // 1275
* @param {string|RegExp} name The name of the file to add (if data is defined), // 1276
* the name of the file to find (if no data) or a regex to match files. // 1277
* @param {String|ArrayBuffer|Uint8Array|Buffer} data The file data, either raw or base64 encoded // 1278
* @param {Object} o File options // 1279
* @return {JSZip|Object|Array} this JSZip object (when adding a file), // 1280
* a file (when searching by string) or an array of files (when searching by regex). // 1281
*/ // 1282
file: function(name, data, o) { // 1283
if (arguments.length === 1) { // 1284
if (utils.isRegExp(name)) { // 1285
var regexp = name; // 1286
return this.filter(function(relativePath, file) { // 1287
return !file.dir && regexp.test(relativePath); // 1288
}); // 1289
} // 1290
else { // text // 1291
return this.filter(function(relativePath, file) { // 1292
return !file.dir && relativePath === name; // 1293
})[0] || null; // 1294
} // 1295
} // 1296
else { // more than one argument : we have data ! // 1297
name = this.root + name; // 1298
fileAdd.call(this, name, data, o); // 1299
} // 1300
return this; // 1301
}, // 1302
// 1303
/** // 1304
* Add a directory to the zip file, or search. // 1305
* @param {String|RegExp} arg The name of the directory to add, or a regex to search folders. // 1306
* @return {JSZip} an object with the new directory as the root, or an array containing matching folders. // 1307
*/ // 1308
folder: function(arg) { // 1309
if (!arg) { // 1310
return this; // 1311
} // 1312
// 1313
if (utils.isRegExp(arg)) { // 1314
return this.filter(function(relativePath, file) { // 1315
return file.dir && arg.test(relativePath); // 1316
}); // 1317
} // 1318
// 1319
// else, name is a new folder // 1320
var name = this.root + arg; // 1321
var newFolder = folderAdd.call(this, name); // 1322
// 1323
// Allow chaining by returning a new object with this folder as the root // 1324
var ret = this.clone(); // 1325
ret.root = newFolder.name; // 1326
return ret; // 1327
}, // 1328
// 1329
/** // 1330
* Delete a file, or a directory and all sub-files, from the zip // 1331
* @param {string} name the name of the file to delete // 1332
* @return {JSZip} this JSZip object // 1333
*/ // 1334
remove: function(name) { // 1335
name = this.root + name; // 1336
var file = this.files[name]; // 1337
if (!file) { // 1338
// Look for any folders // 1339
if (name.slice(-1) != "/") { // 1340
name += "/"; // 1341
} // 1342
file = this.files[name]; // 1343
} // 1344
// 1345
if (file && !file.dir) { // 1346
// file // 1347
delete this.files[name]; // 1348
} else { // 1349
// maybe a folder, delete recursively // 1350
var kids = this.filter(function(relativePath, file) { // 1351
return file.name.slice(0, name.length) === name; // 1352
}); // 1353
for (var i = 0; i < kids.length; i++) { // 1354
delete this.files[kids[i].name]; // 1355
} // 1356
} // 1357
// 1358
return this; // 1359
}, // 1360
// 1361
/** // 1362
* Generate the complete zip file // 1363
* @param {Object} options the options to generate the zip file : // 1364
* - base64, (deprecated, use type instead) true to generate base64. // 1365
* - compression, "STORE" by default. // 1366
* - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob. // 1367
* @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file // 1368
*/ // 1369
generate: function(options) { // 1370
options = extend(options || {}, { // 1371
base64: true, // 1372
compression: "STORE", // 1373
compressionOptions : null, // 1374
type: "base64", // 1375
platform: "DOS", // 1376
comment: null, // 1377
mimeType: 'application/zip' // 1378
}); // 1379
// 1380
utils.checkSupport(options.type); // 1381
// 1382
// accept nodejs `process.platform` // 1383
if( // 1384
options.platform === 'darwin' || // 1385
options.platform === 'freebsd' || // 1386
options.platform === 'linux' || // 1387
options.platform === 'sunos' // 1388
) { // 1389
options.platform = "UNIX"; // 1390
} // 1391
if (options.platform === 'win32') { // 1392
options.platform = "DOS"; // 1393
} // 1394
// 1395
var zipData = [], // 1396
localDirLength = 0, // 1397
centralDirLength = 0, // 1398
writer, i, // 1399
utfEncodedComment = utils.transformTo("string", this.utf8encode(options.comment || this.comment || "")); // 1400
// 1401
// first, generate all the zip parts. // 1402
for (var name in this.files) { // 1403
if (!this.files.hasOwnProperty(name)) { // 1404
continue; // 1405
} // 1406
var file = this.files[name]; // 1407
// 1408
var compressionName = file.options.compression || options.compression.toUpperCase(); // 1409
var compression = compressions[compressionName]; // 1410
if (!compression) { // 1411
throw new Error(compressionName + " is not a valid compression method !"); // 1412
} // 1413
var compressionOptions = file.options.compressionOptions || options.compressionOptions || {}; // 1414
// 1415
var compressedObject = generateCompressedObjectFrom.call(this, file, compression, compressionOptions); // 1416
// 1417
var zipPart = generateZipParts.call(this, name, file, compressedObject, localDirLength, options.platform); // 1418
localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize; // 1419
centralDirLength += zipPart.dirRecord.length; // 1420
zipData.push(zipPart); // 1421
} // 1422
// 1423
var dirEnd = ""; // 1424
// 1425
// end of central dir signature // 1426
dirEnd = signature.CENTRAL_DIRECTORY_END + // 1427
// number of this disk // 1428
"\x00\x00" + // 1429
// number of the disk with the start of the central directory // 1430
"\x00\x00" + // 1431
// total number of entries in the central directory on this disk // 1432
decToHex(zipData.length, 2) + // 1433
// total number of entries in the central directory // 1434
decToHex(zipData.length, 2) + // 1435
// size of the central directory 4 bytes // 1436
decToHex(centralDirLength, 4) + // 1437
// offset of start of central directory with respect to the starting disk number // 1438
decToHex(localDirLength, 4) + // 1439
// .ZIP file comment length // 1440
decToHex(utfEncodedComment.length, 2) + // 1441
// .ZIP file comment // 1442
utfEncodedComment; // 1443
// 1444
// 1445
// we have all the parts (and the total length) // 1446
// time to create a writer ! // 1447
var typeName = options.type.toLowerCase(); // 1448
if(typeName==="uint8array"||typeName==="arraybuffer"||typeName==="blob"||typeName==="nodebuffer") { // 1449
writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length); // 1450
}else{ // 1451
writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length); // 1452
} // 1453
// 1454
for (i = 0; i < zipData.length; i++) { // 1455
writer.append(zipData[i].fileRecord); // 1456
writer.append(zipData[i].compressedObject.compressedContent); // 1457
} // 1458
for (i = 0; i < zipData.length; i++) { // 1459
writer.append(zipData[i].dirRecord); // 1460
} // 1461
// 1462
writer.append(dirEnd); // 1463
// 1464
var zip = writer.finalize(); // 1465
// 1466
// 1467
// 1468
switch(options.type.toLowerCase()) { // 1469
// case "zip is an Uint8Array" // 1470
case "uint8array" : // 1471
case "arraybuffer" : // 1472
case "nodebuffer" : // 1473
return utils.transformTo(options.type.toLowerCase(), zip); // 1474
case "blob" : // 1475
return utils.arrayBuffer2Blob(utils.transformTo("arraybuffer", zip), options.mimeType); // 1476
// case "zip is a string" // 1477
case "base64" : // 1478
return (options.base64) ? base64.encode(zip) : zip; // 1479
default : // case "string" : // 1480
return zip; // 1481
} // 1482
// 1483
}, // 1484
// 1485
/** // 1486
* @deprecated // 1487
* This method will be removed in a future version without replacement. // 1488
*/ // 1489
crc32: function (input, crc) { // 1490
return crc32(input, crc); // 1491
}, // 1492
// 1493
/** // 1494
* @deprecated // 1495
* This method will be removed in a future version without replacement. // 1496
*/ // 1497
utf8encode: function (string) { // 1498
return utils.transformTo("string", utf8.utf8encode(string)); // 1499
}, // 1500
// 1501
/** // 1502
* @deprecated // 1503
* This method will be removed in a future version without replacement. // 1504
*/ // 1505
utf8decode: function (input) { // 1506
return utf8.utf8decode(input); // 1507
} // 1508
}; // 1509
module.exports = out; // 1510
// 1511
},{"./base64":1,"./compressedObject":2,"./compressions":3,"./crc32":4,"./defaults":6,"./nodeBuffer":11,"./signature":14,"./stringWriter":16,"./support":17,"./uint8ArrayWriter":19,"./utf8":20,"./utils":21}],14:[function(_dereq_,module,exports){
'use strict'; // 1513
exports.LOCAL_FILE_HEADER = "PK\x03\x04"; // 1514
exports.CENTRAL_FILE_HEADER = "PK\x01\x02"; // 1515
exports.CENTRAL_DIRECTORY_END = "PK\x05\x06"; // 1516
exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07"; // 1517
exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06"; // 1518
exports.DATA_DESCRIPTOR = "PK\x07\x08"; // 1519
// 1520
},{}],15:[function(_dereq_,module,exports){ // 1521
'use strict'; // 1522
var DataReader = _dereq_('./dataReader'); // 1523
var utils = _dereq_('./utils'); // 1524
// 1525
function StringReader(data, optimizedBinaryString) { // 1526
this.data = data; // 1527
if (!optimizedBinaryString) { // 1528
this.data = utils.string2binary(this.data); // 1529
} // 1530
this.length = this.data.length; // 1531
this.index = 0; // 1532
} // 1533
StringReader.prototype = new DataReader(); // 1534
/** // 1535
* @see DataReader.byteAt // 1536
*/ // 1537
StringReader.prototype.byteAt = function(i) { // 1538
return this.data.charCodeAt(i); // 1539
}; // 1540
/** // 1541
* @see DataReader.lastIndexOfSignature // 1542
*/ // 1543
StringReader.prototype.lastIndexOfSignature = function(sig) { // 1544
return this.data.lastIndexOf(sig); // 1545
}; // 1546
/** // 1547
* @see DataReader.readData // 1548
*/ // 1549
StringReader.prototype.readData = function(size) { // 1550
this.checkOffset(size); // 1551
// this will work because the constructor applied the "& 0xff" mask. // 1552
var result = this.data.slice(this.index, this.index + size); // 1553
this.index += size; // 1554
return result; // 1555
}; // 1556
module.exports = StringReader; // 1557
// 1558
},{"./dataReader":5,"./utils":21}],16:[function(_dereq_,module,exports){ // 1559
'use strict'; // 1560
// 1561
var utils = _dereq_('./utils'); // 1562
// 1563
/** // 1564
* An object to write any content to a string. // 1565
* @constructor // 1566
*/ // 1567
var StringWriter = function() { // 1568
this.data = []; // 1569
}; // 1570
StringWriter.prototype = { // 1571
/** // 1572
* Append any content to the current string. // 1573
* @param {Object} input the content to add. // 1574
*/ // 1575
append: function(input) { // 1576
input = utils.transformTo("string", input); // 1577
this.data.push(input); // 1578
}, // 1579
/** // 1580
* Finalize the construction an return the result. // 1581
* @return {string} the generated string. // 1582
*/ // 1583
finalize: function() { // 1584
return this.data.join(""); // 1585
} // 1586
}; // 1587
// 1588
module.exports = StringWriter; // 1589
// 1590
},{"./utils":21}],17:[function(_dereq_,module,exports){ // 1591
(function (Buffer){ // 1592
'use strict'; // 1593
exports.base64 = true; // 1594
exports.array = true; // 1595
exports.string = true; // 1596
exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined"; // 1597
// contains true if JSZip can read/generate nodejs Buffer, false otherwise. // 1598
// Browserify will provide a Buffer implementation for browsers, which is // 1599
// an augmented Uint8Array (i.e., can be used as either Buffer or U8). // 1600
exports.nodebuffer = typeof Buffer !== "undefined"; // 1601
// contains true if JSZip can read/generate Uint8Array, false otherwise. // 1602
exports.uint8array = typeof Uint8Array !== "undefined"; // 1603
// 1604
if (typeof ArrayBuffer === "undefined") { // 1605
exports.blob = false; // 1606
} // 1607
else { // 1608
var buffer = new ArrayBuffer(0); // 1609
try { // 1610
exports.blob = new Blob([buffer], { // 1611
type: "application/zip" // 1612
}).size === 0; // 1613
} // 1614
catch (e) { // 1615
try { // 1616
var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
var builder = new Builder(); // 1618
builder.append(buffer); // 1619
exports.blob = builder.getBlob('application/zip').size === 0; // 1620
} // 1621
catch (e) { // 1622
exports.blob = false; // 1623
} // 1624
} // 1625
} // 1626
// 1627
}).call(this,(typeof Buffer !== "undefined" ? Buffer : undefined)) // 1628
},{}],18:[function(_dereq_,module,exports){ // 1629
'use strict'; // 1630
var DataReader = _dereq_('./dataReader'); // 1631
// 1632
function Uint8ArrayReader(data) { // 1633
if (data) { // 1634
this.data = data; // 1635
this.length = this.data.length; // 1636
this.index = 0; // 1637
} // 1638
} // 1639
Uint8ArrayReader.prototype = new DataReader(); // 1640
/** // 1641
* @see DataReader.byteAt // 1642
*/ // 1643
Uint8ArrayReader.prototype.byteAt = function(i) { // 1644
return this.data[i]; // 1645
}; // 1646
/** // 1647
* @see DataReader.lastIndexOfSignature // 1648
*/ // 1649
Uint8ArrayReader.prototype.lastIndexOfSignature = function(sig) { // 1650
var sig0 = sig.charCodeAt(0), // 1651
sig1 = sig.charCodeAt(1), // 1652
sig2 = sig.charCodeAt(2), // 1653
sig3 = sig.charCodeAt(3); // 1654
for (var i = this.length - 4; i >= 0; --i) { // 1655
if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
return i; // 1657
} // 1658
} // 1659
// 1660
return -1; // 1661
}; // 1662
/** // 1663
* @see DataReader.readData // 1664
*/ // 1665
Uint8ArrayReader.prototype.readData = function(size) { // 1666
this.checkOffset(size); // 1667
if(size === 0) { // 1668
// in IE10, when using subarray(idx, idx), we get the array [0x00] instead of []. // 1669
return new Uint8Array(0); // 1670
} // 1671
var result = this.data.subarray(this.index, this.index + size); // 1672
this.index += size; // 1673
return result; // 1674
}; // 1675
module.exports = Uint8ArrayReader; // 1676
// 1677
},{"./dataReader":5}],19:[function(_dereq_,module,exports){ // 1678
'use strict'; // 1679
// 1680
var utils = _dereq_('./utils'); // 1681
// 1682
/** // 1683
* An object to write any content to an Uint8Array. // 1684
* @constructor // 1685
* @param {number} length The length of the array. // 1686
*/ // 1687
var Uint8ArrayWriter = function(length) { // 1688
this.data = new Uint8Array(length); // 1689
this.index = 0; // 1690
}; // 1691
Uint8ArrayWriter.prototype = { // 1692
/** // 1693
* Append any content to the current array. // 1694
* @param {Object} input the content to add. // 1695
*/ // 1696
append: function(input) { // 1697
if (input.length !== 0) { // 1698
// with an empty Uint8Array, Opera fails with a "Offset larger than array size" // 1699
input = utils.transformTo("uint8array", input); // 1700
this.data.set(input, this.index); // 1701
this.index += input.length; // 1702
} // 1703
}, // 1704
/** // 1705
* Finalize the construction an return the result. // 1706
* @return {Uint8Array} the generated array. // 1707
*/ // 1708
finalize: function() { // 1709
return this.data; // 1710
} // 1711
}; // 1712
// 1713
module.exports = Uint8ArrayWriter; // 1714
// 1715
},{"./utils":21}],20:[function(_dereq_,module,exports){ // 1716
'use strict'; // 1717
// 1718
var utils = _dereq_('./utils'); // 1719
var support = _dereq_('./support'); // 1720
var nodeBuffer = _dereq_('./nodeBuffer'); // 1721
// 1722
/** // 1723
* The following functions come from pako, from pako/lib/utils/strings // 1724
* released under the MIT license, see pako https://github.com/nodeca/pako/ // 1725
*/ // 1726
// 1727
// Table with utf8 lengths (calculated by first byte of sequence) // 1728
// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS, // 1729
// because max possible codepoint is 0x10ffff // 1730
var _utf8len = new Array(256); // 1731
for (var i=0; i<256; i++) { // 1732
_utf8len[i] = (i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1); // 1733
} // 1734
_utf8len[254]=_utf8len[254]=1; // Invalid sequence start // 1735
// 1736
// convert string to array (typed, when possible) // 1737
var string2buf = function (str) { // 1738
var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0; // 1739
// 1740
// count binary size // 1741
for (m_pos = 0; m_pos < str_len; m_pos++) { // 1742
c = str.charCodeAt(m_pos); // 1743
if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) { // 1744
c2 = str.charCodeAt(m_pos+1); // 1745
if ((c2 & 0xfc00) === 0xdc00) { // 1746
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00); // 1747
m_pos++; // 1748
} // 1749
} // 1750
buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; // 1751
} // 1752
// 1753
// allocate buffer // 1754
if (support.uint8array) { // 1755
buf = new Uint8Array(buf_len); // 1756
} else { // 1757
buf = new Array(buf_len); // 1758
} // 1759
// 1760
// convert // 1761
for (i=0, m_pos = 0; i < buf_len; m_pos++) { // 1762
c = str.charCodeAt(m_pos); // 1763
if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) { // 1764
c2 = str.charCodeAt(m_pos+1); // 1765
if ((c2 & 0xfc00) === 0xdc00) { // 1766
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00); // 1767
m_pos++; // 1768
} // 1769
} // 1770
if (c < 0x80) { // 1771
/* one byte */ // 1772
buf[i++] = c; // 1773
} else if (c < 0x800) { // 1774
/* two bytes */ // 1775
buf[i++] = 0xC0 | (c >>> 6); // 1776
buf[i++] = 0x80 | (c & 0x3f); // 1777
} else if (c < 0x10000) { // 1778
/* three bytes */ // 1779
buf[i++] = 0xE0 | (c >>> 12); // 1780
buf[i++] = 0x80 | (c >>> 6 & 0x3f); // 1781
buf[i++] = 0x80 | (c & 0x3f); // 1782
} else { // 1783
/* four bytes */ // 1784
buf[i++] = 0xf0 | (c >>> 18); // 1785
buf[i++] = 0x80 | (c >>> 12 & 0x3f); // 1786
buf[i++] = 0x80 | (c >>> 6 & 0x3f); // 1787
buf[i++] = 0x80 | (c & 0x3f); // 1788
} // 1789
} // 1790
// 1791
return buf; // 1792
}; // 1793
// 1794
// Calculate max possible position in utf8 buffer, // 1795
// that will not break sequence. If that's not possible // 1796
// - (very small limits) return max size as is. // 1797
// // 1798
// buf[] - utf8 bytes array // 1799
// max - length limit (mandatory); // 1800
var utf8border = function(buf, max) { // 1801
var pos; // 1802
// 1803
max = max || buf.length; // 1804
if (max > buf.length) { max = buf.length; } // 1805
// 1806
// go back from last position, until start of sequence found // 1807
pos = max-1; // 1808
while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; } // 1809
// 1810
// Fuckup - very small and broken sequence, // 1811
// return max, because we should return something anyway. // 1812
if (pos < 0) { return max; } // 1813
// 1814
// If we came to start of buffer - that means vuffer is too small, // 1815
// return max too. // 1816
if (pos === 0) { return max; } // 1817
// 1818
return (pos + _utf8len[buf[pos]] > max) ? pos : max; // 1819
}; // 1820
// 1821
// convert array to string // 1822
var buf2string = function (buf) { // 1823
var str, i, out, c, c_len; // 1824
var len = buf.length; // 1825
// 1826
// Reserve max possible length (2 words per char) // 1827
// NB: by unknown reasons, Array is significantly faster for // 1828
// String.fromCharCode.apply than Uint16Array. // 1829
var utf16buf = new Array(len*2); // 1830
// 1831
for (out=0, i=0; i<len;) { // 1832
c = buf[i++]; // 1833
// quick process ascii // 1834
if (c < 0x80) { utf16buf[out++] = c; continue; } // 1835
// 1836
c_len = _utf8len[c]; // 1837
// skip 5 & 6 byte codes // 1838
if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; } // 1839
// 1840
// apply mask on first byte // 1841
c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07; // 1842
// join the rest // 1843
while (c_len > 1 && i < len) { // 1844
c = (c << 6) | (buf[i++] & 0x3f); // 1845
c_len--; // 1846
} // 1847
// 1848
// terminated by end of string? // 1849
if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; } // 1850
// 1851
if (c < 0x10000) { // 1852
utf16buf[out++] = c; // 1853
} else { // 1854
c -= 0x10000; // 1855
utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff); // 1856
utf16buf[out++] = 0xdc00 | (c & 0x3ff); // 1857
} // 1858
} // 1859
// 1860
// shrinkBuf(utf16buf, out) // 1861
if (utf16buf.length !== out) { // 1862
if(utf16buf.subarray) { // 1863
utf16buf = utf16buf.subarray(0, out); // 1864
} else { // 1865
utf16buf.length = out; // 1866
} // 1867
} // 1868
// 1869
// return String.fromCharCode.apply(null, utf16buf); // 1870
return utils.applyFromCharCode(utf16buf); // 1871
}; // 1872
// 1873
// 1874
// That's all for the pako functions. // 1875
// 1876
// 1877
/** // 1878
* Transform a javascript string into an array (typed if possible) of bytes, // 1879
* UTF-8 encoded. // 1880
* @param {String} str the string to encode // 1881
* @return {Array|Uint8Array|Buffer} the UTF-8 encoded string. // 1882
*/ // 1883
exports.utf8encode = function utf8encode(str) { // 1884
if (support.nodebuffer) { // 1885
return nodeBuffer(str, "utf-8"); // 1886
} // 1887
// 1888
return string2buf(str); // 1889
}; // 1890
// 1891
// 1892
/** // 1893
* Transform a bytes array (or a representation) representing an UTF-8 encoded // 1894
* string into a javascript string. // 1895
* @param {Array|Uint8Array|Buffer} buf the data de decode // 1896
* @return {String} the decoded string. // 1897
*/ // 1898
exports.utf8decode = function utf8decode(buf) { // 1899
if (support.nodebuffer) { // 1900
return utils.transformTo("nodebuffer", buf).toString("utf-8"); // 1901
} // 1902
// 1903
buf = utils.transformTo(support.uint8array ? "uint8array" : "array", buf); // 1904
// 1905
// return buf2string(buf); // 1906
// Chrome prefers to work with "small" chunks of data // 1907
// for the method buf2string. // 1908
// Firefox and Chrome has their own shortcut, IE doesn't seem to really care. // 1909
var result = [], k = 0, len = buf.length, chunk = 65536; // 1910
while (k < len) { // 1911
var nextBoundary = utf8border(buf, Math.min(k + chunk, len)); // 1912
if (support.uint8array) { // 1913
result.push(buf2string(buf.subarray(k, nextBoundary))); // 1914
} else { // 1915
result.push(buf2string(buf.slice(k, nextBoundary))); // 1916
} // 1917
k = nextBoundary; // 1918
} // 1919
return result.join(""); // 1920
// 1921
}; // 1922
// vim: set shiftwidth=4 softtabstop=4: // 1923
// 1924
},{"./nodeBuffer":11,"./support":17,"./utils":21}],21:[function(_dereq_,module,exports){ // 1925
'use strict'; // 1926
var support = _dereq_('./support'); // 1927
var compressions = _dereq_('./compressions'); // 1928
var nodeBuffer = _dereq_('./nodeBuffer'); // 1929
/** // 1930
* Convert a string to a "binary string" : a string containing only char codes between 0 and 255. // 1931
* @param {string} str the string to transform. // 1932
* @return {String} the binary string. // 1933
*/ // 1934
exports.string2binary = function(str) { // 1935
var result = ""; // 1936
for (var i = 0; i < str.length; i++) { // 1937
result += String.fromCharCode(str.charCodeAt(i) & 0xff); // 1938
} // 1939
return result; // 1940
}; // 1941
exports.arrayBuffer2Blob = function(buffer, mimeType) { // 1942
exports.checkSupport("blob"); // 1943
mimeType = mimeType || 'application/zip'; // 1944
// 1945
try { // 1946
// Blob constructor // 1947
return new Blob([buffer], { // 1948
type: mimeType // 1949
}); // 1950
} // 1951
catch (e) { // 1952
// 1953
try { // 1954
// deprecated, browser only, old way // 1955
var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
var builder = new Builder(); // 1957
builder.append(buffer); // 1958
return builder.getBlob(mimeType); // 1959
} // 1960
catch (e) { // 1961
// 1962
// well, fuck ?! // 1963
throw new Error("Bug : can't construct the Blob."); // 1964
} // 1965
} // 1966
// 1967
// 1968
}; // 1969
/** // 1970
* The identity function. // 1971
* @param {Object} input the input. // 1972
* @return {Object} the same input. // 1973
*/ // 1974
function identity(input) { // 1975
return input; // 1976
} // 1977
// 1978
/** // 1979
* Fill in an array with a string. // 1980
* @param {String} str the string to use. // 1981
* @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated). // 1982
* @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array. // 1983
*/ // 1984
function stringToArrayLike(str, array) { // 1985
for (var i = 0; i < str.length; ++i) { // 1986
array[i] = str.charCodeAt(i) & 0xFF; // 1987
} // 1988
return array; // 1989
} // 1990
// 1991
/** // 1992
* Transform an array-like object to a string. // 1993
* @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform. // 1994
* @return {String} the result. // 1995
*/ // 1996
function arrayLikeToString(array) { // 1997
// Performances notes : // 1998
// -------------------- // 1999
// String.fromCharCode.apply(null, array) is the fastest, see // 2000
// see http://jsperf.com/converting-a-uint8array-to-a-string/2 // 2001
// but the stack is limited (and we can get huge arrays !). // 2002
// // 2003
// result += String.fromCharCode(array[i]); generate too many strings ! // 2004
// // 2005
// This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2 // 2006
var chunk = 65536; // 2007
var result = [], // 2008
len = array.length, // 2009
type = exports.getTypeOf(array), // 2010
k = 0, // 2011
canUseApply = true; // 2012
try { // 2013
switch(type) { // 2014
case "uint8array": // 2015
String.fromCharCode.apply(null, new Uint8Array(0)); // 2016
break; // 2017
case "nodebuffer": // 2018
String.fromCharCode.apply(null, nodeBuffer(0)); // 2019
break; // 2020
} // 2021
} catch(e) { // 2022
canUseApply = false; // 2023
} // 2024
// 2025
// no apply : slow and painful algorithm // 2026
// default browser on android 4.* // 2027
if (!canUseApply) { // 2028
var resultStr = ""; // 2029
for(var i = 0; i < array.length;i++) { // 2030
resultStr += String.fromCharCode(array[i]); // 2031
} // 2032
return resultStr; // 2033
} // 2034
while (k < len && chunk > 1) { // 2035
try { // 2036
if (type === "array" || type === "nodebuffer") { // 2037
result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len)))); // 2038
} // 2039
else { // 2040
result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len)))); // 2041
} // 2042
k += chunk; // 2043
} // 2044
catch (e) { // 2045
chunk = Math.floor(chunk / 2); // 2046
} // 2047
} // 2048
return result.join(""); // 2049
} // 2050
// 2051
exports.applyFromCharCode = arrayLikeToString; // 2052
// 2053
// 2054
/** // 2055
* Copy the data from an array-like to an other array-like. // 2056
* @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array. // 2057
* @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated. // 2058
* @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array. // 2059
*/ // 2060
function arrayLikeToArrayLike(arrayFrom, arrayTo) { // 2061
for (var i = 0; i < arrayFrom.length; i++) { // 2062
arrayTo[i] = arrayFrom[i]; // 2063
} // 2064
return arrayTo; // 2065
} // 2066
// 2067
// a matrix containing functions to transform everything into everything. // 2068
var transform = {}; // 2069
// 2070
// string to ? // 2071
transform["string"] = { // 2072
"string": identity, // 2073
"array": function(input) { // 2074
return stringToArrayLike(input, new Array(input.length)); // 2075
}, // 2076
"arraybuffer": function(input) { // 2077
return transform["string"]["uint8array"](input).buffer; // 2078
}, // 2079
"uint8array": function(input) { // 2080
return stringToArrayLike(input, new Uint8Array(input.length)); // 2081
}, // 2082
"nodebuffer": function(input) { // 2083
return stringToArrayLike(input, nodeBuffer(input.length)); // 2084
} // 2085
}; // 2086
// 2087
// array to ? // 2088
transform["array"] = { // 2089
"string": arrayLikeToString, // 2090
"array": identity, // 2091
"arraybuffer": function(input) { // 2092
return (new Uint8Array(input)).buffer; // 2093
}, // 2094
"uint8array": function(input) { // 2095
return new Uint8Array(input); // 2096
}, // 2097
"nodebuffer": function(input) { // 2098
return nodeBuffer(input); // 2099
} // 2100
}; // 2101
// 2102
// arraybuffer to ? // 2103
transform["arraybuffer"] = { // 2104
"string": function(input) { // 2105
return arrayLikeToString(new Uint8Array(input)); // 2106
}, // 2107
"array": function(input) { // 2108
return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength)); // 2109
}, // 2110
"arraybuffer": identity, // 2111
"uint8array": function(input) { // 2112
return new Uint8Array(input); // 2113
}, // 2114
"nodebuffer": function(input) { // 2115
return nodeBuffer(new Uint8Array(input)); // 2116
} // 2117
}; // 2118
// 2119
// uint8array to ? // 2120
transform["uint8array"] = { // 2121
"string": arrayLikeToString, // 2122
"array": function(input) { // 2123
return arrayLikeToArrayLike(input, new Array(input.length)); // 2124
}, // 2125
"arraybuffer": function(input) { // 2126
return input.buffer; // 2127
}, // 2128
"uint8array": identity, // 2129
"nodebuffer": function(input) { // 2130
return nodeBuffer(input); // 2131
} // 2132
}; // 2133
// 2134
// nodebuffer to ? // 2135
transform["nodebuffer"] = { // 2136
"string": arrayLikeToString, // 2137
"array": function(input) { // 2138
return arrayLikeToArrayLike(input, new Array(input.length)); // 2139
}, // 2140
"arraybuffer": function(input) { // 2141
return transform["nodebuffer"]["uint8array"](input).buffer; // 2142
}, // 2143
"uint8array": function(input) { // 2144
return arrayLikeToArrayLike(input, new Uint8Array(input.length)); // 2145
}, // 2146
"nodebuffer": identity // 2147
}; // 2148
// 2149
/** // 2150
* Transform an input into any type. // 2151
* The supported output type are : string, array, uint8array, arraybuffer, nodebuffer. // 2152
* If no output type is specified, the unmodified input will be returned. // 2153
* @param {String} outputType the output type. // 2154
* @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert. // 2155
* @throws {Error} an Error if the browser doesn't support the requested output type. // 2156
*/ // 2157
exports.transformTo = function(outputType, input) { // 2158
if (!input) { // 2159
// undefined, null, etc // 2160
// an empty string won't harm. // 2161
input = ""; // 2162
} // 2163
if (!outputType) { // 2164
return input; // 2165
} // 2166
exports.checkSupport(outputType); // 2167
var inputType = exports.getTypeOf(input); // 2168
var result = transform[inputType][outputType](input); // 2169
return result; // 2170
}; // 2171
// 2172
/** // 2173
* Return the type of the input. // 2174
* The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer. // 2175
* @param {Object} input the input to identify. // 2176
* @return {String} the (lowercase) type of the input. // 2177
*/ // 2178
exports.getTypeOf = function(input) { // 2179
if (typeof input === "string") { // 2180
return "string"; // 2181
} // 2182
if (Object.prototype.toString.call(input) === "[object Array]") { // 2183
return "array"; // 2184
} // 2185
if (support.nodebuffer && nodeBuffer.test(input)) { // 2186
return "nodebuffer"; // 2187
} // 2188
if (support.uint8array && input instanceof Uint8Array) { // 2189
return "uint8array"; // 2190
} // 2191
if (support.arraybuffer && input instanceof ArrayBuffer) { // 2192
return "arraybuffer"; // 2193
} // 2194
}; // 2195
// 2196
/** // 2197
* Throw an exception if the type is not supported. // 2198
* @param {String} type the type to check. // 2199
* @throws {Error} an Error if the browser doesn't support the requested type. // 2200
*/ // 2201
exports.checkSupport = function(type) { // 2202
var supported = support[type.toLowerCase()]; // 2203
if (!supported) { // 2204
throw new Error(type + " is not supported by this browser"); // 2205
} // 2206
}; // 2207
exports.MAX_VALUE_16BITS = 65535; // 2208
exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1 // 2209
// 2210
/** // 2211
* Prettify a string read as binary. // 2212
* @param {string} str the string to prettify. // 2213
* @return {string} a pretty string. // 2214
*/ // 2215
exports.pretty = function(str) { // 2216
var res = '', // 2217
code, i; // 2218
for (i = 0; i < (str || "").length; i++) { // 2219
code = str.charCodeAt(i); // 2220
res += '\\x' + (code < 16 ? "0" : "") + code.toString(16).toUpperCase(); // 2221
} // 2222
return res; // 2223
}; // 2224
// 2225
/** // 2226
* Find a compression registered in JSZip. // 2227
* @param {string} compressionMethod the method magic to find. // 2228
* @return {Object|null} the JSZip compression object, null if none found. // 2229
*/ // 2230
exports.findCompression = function(compressionMethod) { // 2231
for (var method in compressions) { // 2232
if (!compressions.hasOwnProperty(method)) { // 2233
continue; // 2234
} // 2235
if (compressions[method].magic === compressionMethod) { // 2236
return compressions[method]; // 2237
} // 2238
} // 2239
return null; // 2240
}; // 2241
/** // 2242
* Cross-window, cross-Node-context regular expression detection // 2243
* @param {Object} object Anything // 2244
* @return {Boolean} true if the object is a regular expression, // 2245
* false otherwise // 2246
*/ // 2247
exports.isRegExp = function (object) { // 2248
return Object.prototype.toString.call(object) === "[object RegExp]"; // 2249
}; // 2250
// 2251
// 2252
},{"./compressions":3,"./nodeBuffer":11,"./support":17}],22:[function(_dereq_,module,exports){ // 2253
'use strict'; // 2254
var StringReader = _dereq_('./stringReader'); // 2255
var NodeBufferReader = _dereq_('./nodeBufferReader'); // 2256
var Uint8ArrayReader = _dereq_('./uint8ArrayReader'); // 2257
var utils = _dereq_('./utils'); // 2258
var sig = _dereq_('./signature'); // 2259
var ZipEntry = _dereq_('./zipEntry'); // 2260
var support = _dereq_('./support'); // 2261
var jszipProto = _dereq_('./object'); // 2262
// class ZipEntries {{{ // 2263
/** // 2264
* All the entries in the zip file. // 2265
* @constructor // 2266
* @param {String|ArrayBuffer|Uint8Array} data the binary stream to load. // 2267
* @param {Object} loadOptions Options for loading the stream. // 2268
*/ // 2269
function ZipEntries(data, loadOptions) { // 2270
this.files = []; // 2271
this.loadOptions = loadOptions; // 2272
if (data) { // 2273
this.load(data); // 2274
} // 2275
} // 2276
ZipEntries.prototype = { // 2277
/** // 2278
* Check that the reader is on the speficied signature. // 2279
* @param {string} expectedSignature the expected signature. // 2280
* @throws {Error} if it is an other signature. // 2281
*/ // 2282
checkSignature: function(expectedSignature) { // 2283
var signature = this.reader.readString(4); // 2284
if (signature !== expectedSignature) { // 2285
throw new Error("Corrupted zip or bug : unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
} // 2287
}, // 2288
/** // 2289
* Read the end of the central directory. // 2290
*/ // 2291
readBlockEndOfCentral: function() { // 2292
this.diskNumber = this.reader.readInt(2); // 2293
this.diskWithCentralDirStart = this.reader.readInt(2); // 2294
this.centralDirRecordsOnThisDisk = this.reader.readInt(2); // 2295
this.centralDirRecords = this.reader.readInt(2); // 2296
this.centralDirSize = this.reader.readInt(4); // 2297
this.centralDirOffset = this.reader.readInt(4); // 2298
// 2299
this.zipCommentLength = this.reader.readInt(2); // 2300
// warning : the encoding depends of the system locale // 2301
// On a linux machine with LANG=en_US.utf8, this field is utf8 encoded. // 2302
// On a windows machine, this field is encoded with the localized windows code page. // 2303
this.zipComment = this.reader.readString(this.zipCommentLength); // 2304
// To get consistent behavior with the generation part, we will assume that // 2305
// this is utf8 encoded. // 2306
this.zipComment = jszipProto.utf8decode(this.zipComment); // 2307
}, // 2308
/** // 2309
* Read the end of the Zip 64 central directory. // 2310
* Not merged with the method readEndOfCentral : // 2311
* The end of central can coexist with its Zip64 brother, // 2312
* I don't want to read the wrong number of bytes ! // 2313
*/ // 2314
readBlockZip64EndOfCentral: function() { // 2315
this.zip64EndOfCentralSize = this.reader.readInt(8); // 2316
this.versionMadeBy = this.reader.readString(2); // 2317
this.versionNeeded = this.reader.readInt(2); // 2318
this.diskNumber = this.reader.readInt(4); // 2319
this.diskWithCentralDirStart = this.reader.readInt(4); // 2320
this.centralDirRecordsOnThisDisk = this.reader.readInt(8); // 2321
this.centralDirRecords = this.reader.readInt(8); // 2322
this.centralDirSize = this.reader.readInt(8); // 2323
this.centralDirOffset = this.reader.readInt(8); // 2324
// 2325
this.zip64ExtensibleData = {}; // 2326
var extraDataSize = this.zip64EndOfCentralSize - 44, // 2327
index = 0, // 2328
extraFieldId, // 2329
extraFieldLength, // 2330
extraFieldValue; // 2331
while (index < extraDataSize) { // 2332
extraFieldId = this.reader.readInt(2); // 2333
extraFieldLength = this.reader.readInt(4); // 2334
extraFieldValue = this.reader.readString(extraFieldLength); // 2335
this.zip64ExtensibleData[extraFieldId] = { // 2336
id: extraFieldId, // 2337
length: extraFieldLength, // 2338
value: extraFieldValue // 2339
}; // 2340
} // 2341
}, // 2342
/** // 2343
* Read the end of the Zip 64 central directory locator. // 2344
*/ // 2345
readBlockZip64EndOfCentralLocator: function() { // 2346
this.diskWithZip64CentralDirStart = this.reader.readInt(4); // 2347
this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8); // 2348
this.disksCount = this.reader.readInt(4); // 2349
if (this.disksCount > 1) { // 2350
throw new Error("Multi-volumes zip are not supported"); // 2351
} // 2352
}, // 2353
/** // 2354
* Read the local files, based on the offset read in the central part. // 2355
*/ // 2356
readLocalFiles: function() { // 2357
var i, file; // 2358
for (i = 0; i < this.files.length; i++) { // 2359
file = this.files[i]; // 2360
this.reader.setIndex(file.localHeaderOffset); // 2361
this.checkSignature(sig.LOCAL_FILE_HEADER); // 2362
file.readLocalPart(this.reader); // 2363
file.handleUTF8(); // 2364
file.processAttributes(); // 2365
} // 2366
}, // 2367
/** // 2368
* Read the central directory. // 2369
*/ // 2370
readCentralDir: function() { // 2371
var file; // 2372
// 2373
this.reader.setIndex(this.centralDirOffset); // 2374
while (this.reader.readString(4) === sig.CENTRAL_FILE_HEADER) { // 2375
file = new ZipEntry({ // 2376
zip64: this.zip64 // 2377
}, this.loadOptions); // 2378
file.readCentralPart(this.reader); // 2379
this.files.push(file); // 2380
} // 2381
}, // 2382
/** // 2383
* Read the end of central directory. // 2384
*/ // 2385
readEndOfCentral: function() { // 2386
var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END); // 2387
if (offset === -1) { // 2388
// Check if the content is a truncated zip or complete garbage. // 2389
// A "LOCAL_FILE_HEADER" is not required at the beginning (auto // 2390
// extractible zip for example) but it can give a good hint. // 2391
// If an ajax request was used without responseType, we will also // 2392
// get unreadable data. // 2393
var isGarbage = true; // 2394
try { // 2395
this.reader.setIndex(0); // 2396
this.checkSignature(sig.LOCAL_FILE_HEADER); // 2397
isGarbage = false; // 2398
} catch (e) {} // 2399
// 2400
if (isGarbage) { // 2401
throw new Error("Can't find end of central directory : is this a zip file ? " + // 2402
"If it is, see http://stuk.github.io/jszip/documentation/howto/read_zip.html"); // 2403
} else { // 2404
throw new Error("Corrupted zip : can't find end of central directory"); // 2405
} // 2406
} // 2407
this.reader.setIndex(offset); // 2408
this.checkSignature(sig.CENTRAL_DIRECTORY_END); // 2409
this.readBlockEndOfCentral(); // 2410
// 2411
// 2412
/* extract from the zip spec : // 2413
4) If one of the fields in the end of central directory // 2414
record is too small to hold required data, the field // 2415
should be set to -1 (0xFFFF or 0xFFFFFFFF) and the // 2416
ZIP64 format record should be created. // 2417
5) The end of central directory record and the // 2418
Zip64 end of central directory locator record must // 2419
reside on the same disk when splitting or spanning // 2420
an archive. // 2421
*/ // 2422
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) {
this.zip64 = true; // 2424
// 2425
/* // 2426
Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from // 2427
the zip file can fit into a 32bits integer. This cannot be solved : Javascript represents // 2428
all numbers as 64-bit double precision IEEE 754 floating point numbers. // 2429
So, we have 53bits for integers and bitwise operations treat everything as 32bits. // 2430
see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators // 2431
and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5 // 2432
*/ // 2433
// 2434
// should look for a zip64 EOCD locator // 2435
offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR); // 2436
if (offset === -1) { // 2437
throw new Error("Corrupted zip : can't find the ZIP64 end of central directory locator"); // 2438
} // 2439
this.reader.setIndex(offset); // 2440
this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR); // 2441
this.readBlockZip64EndOfCentralLocator(); // 2442
// 2443
// now the zip64 EOCD record // 2444
this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir); // 2445
this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END); // 2446
this.readBlockZip64EndOfCentral(); // 2447
} // 2448
}, // 2449
prepareReader: function(data) { // 2450
var type = utils.getTypeOf(data); // 2451
if (type === "string" && !support.uint8array) { // 2452
this.reader = new StringReader(data, this.loadOptions.optimizedBinaryString); // 2453
} // 2454
else if (type === "nodebuffer") { // 2455
this.reader = new NodeBufferReader(data); // 2456
} // 2457
else { // 2458
this.reader = new Uint8ArrayReader(utils.transformTo("uint8array", data)); // 2459
} // 2460
}, // 2461
/** // 2462
* Read a zip file and create ZipEntries. // 2463
* @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file. // 2464
*/ // 2465
load: function(data) { // 2466
this.prepareReader(data); // 2467
this.readEndOfCentral(); // 2468
this.readCentralDir(); // 2469
this.readLocalFiles(); // 2470
} // 2471
}; // 2472
// }}} end of ZipEntries // 2473
module.exports = ZipEntries; // 2474
// 2475
},{"./nodeBufferReader":12,"./object":13,"./signature":14,"./stringReader":15,"./support":17,"./uint8ArrayReader":18,"./utils":21,"./zipEntry":23}],23:[function(_dereq_,module,exports){
'use strict'; // 2477
var StringReader = _dereq_('./stringReader'); // 2478
var utils = _dereq_('./utils'); // 2479
var CompressedObject = _dereq_('./compressedObject'); // 2480
var jszipProto = _dereq_('./object'); // 2481
// 2482
var MADE_BY_DOS = 0x00; // 2483
var MADE_BY_UNIX = 0x03; // 2484
// 2485
// class ZipEntry {{{ // 2486
/** // 2487
* An entry in the zip file. // 2488
* @constructor // 2489
* @param {Object} options Options of the current file. // 2490
* @param {Object} loadOptions Options for loading the stream. // 2491
*/ // 2492
function ZipEntry(options, loadOptions) { // 2493
this.options = options; // 2494
this.loadOptions = loadOptions; // 2495
} // 2496
ZipEntry.prototype = { // 2497
/** // 2498
* say if the file is encrypted. // 2499
* @return {boolean} true if the file is encrypted, false otherwise. // 2500
*/ // 2501
isEncrypted: function() { // 2502
// bit 1 is set // 2503
return (this.bitFlag & 0x0001) === 0x0001; // 2504
}, // 2505
/** // 2506
* say if the file has utf-8 filename/comment. // 2507
* @return {boolean} true if the filename/comment is in utf-8, false otherwise. // 2508
*/ // 2509
useUTF8: function() { // 2510
// bit 11 is set // 2511
return (this.bitFlag & 0x0800) === 0x0800; // 2512
}, // 2513
/** // 2514
* Prepare the function used to generate the compressed content from this ZipFile. // 2515
* @param {DataReader} reader the reader to use. // 2516
* @param {number} from the offset from where we should read the data. // 2517
* @param {number} length the length of the data to read. // 2518
* @return {Function} the callback to get the compressed content (the type depends of the DataReader class). // 2519
*/ // 2520
prepareCompressedContent: function(reader, from, length) { // 2521
return function() { // 2522
var previousIndex = reader.index; // 2523
reader.setIndex(from); // 2524
var compressedFileData = reader.readData(length); // 2525
reader.setIndex(previousIndex); // 2526
// 2527
return compressedFileData; // 2528
}; // 2529
}, // 2530
/** // 2531
* Prepare the function used to generate the uncompressed content from this ZipFile. // 2532
* @param {DataReader} reader the reader to use. // 2533
* @param {number} from the offset from where we should read the data. // 2534
* @param {number} length the length of the data to read. // 2535
* @param {JSZip.compression} compression the compression used on this file. // 2536
* @param {number} uncompressedSize the uncompressed size to expect. // 2537
* @return {Function} the callback to get the uncompressed content (the type depends of the DataReader class). // 2538
*/ // 2539
prepareContent: function(reader, from, length, compression, uncompressedSize) { // 2540
return function() { // 2541
// 2542
var compressedFileData = utils.transformTo(compression.uncompressInputType, this.getCompressedContent()); // 2543
var uncompressedFileData = compression.uncompress(compressedFileData); // 2544
// 2545
if (uncompressedFileData.length !== uncompressedSize) { // 2546
throw new Error("Bug : uncompressed data size mismatch"); // 2547
} // 2548
// 2549
return uncompressedFileData; // 2550
}; // 2551
}, // 2552
/** // 2553
* Read the local part of a zip file and add the info in this object. // 2554
* @param {DataReader} reader the reader to use. // 2555
*/ // 2556
readLocalPart: function(reader) { // 2557
var compression, localExtraFieldsLength; // 2558
// 2559
// we already know everything from the central dir ! // 2560
// If the central dir data are false, we are doomed. // 2561
// On the bright side, the local part is scary : zip64, data descriptors, both, etc. // 2562
// The less data we get here, the more reliable this should be. // 2563
// Let's skip the whole header and dash to the data ! // 2564
reader.skip(22); // 2565
// in some zip created on windows, the filename stored in the central dir contains \ instead of /. // 2566
// Strangely, the filename here is OK. // 2567
// I would love to treat these zip files as corrupted (see http://www.info-zip.org/FAQ.html#backslashes // 2568
// or APPNOTE#4.4.17.1, "All slashes MUST be forward slashes '/'") but there are a lot of bad zip generators...
// Search "unzip mismatching "local" filename continuing with "central" filename version" on // 2570
// the internet. // 2571
// // 2572
// I think I see the logic here : the central directory is used to display // 2573
// content and the local directory is used to extract the files. Mixing / and \
// may be used to display \ to windows users and use / when extracting the files. // 2575
// Unfortunately, this lead also to some issues : http://seclists.org/fulldisclosure/2009/Sep/394 // 2576
this.fileNameLength = reader.readInt(2); // 2577
localExtraFieldsLength = reader.readInt(2); // can't be sure this will be the same as the central dir // 2578
this.fileName = reader.readString(this.fileNameLength); // 2579
reader.skip(localExtraFieldsLength); // 2580
// 2581
if (this.compressedSize == -1 || this.uncompressedSize == -1) { // 2582
throw new Error("Bug or corrupted zip : didn't get enough informations from the central directory " + "(compressedSize == -1 || uncompressedSize == -1)");
} // 2584
// 2585
compression = utils.findCompression(this.compressionMethod); // 2586
if (compression === null) { // no compression found // 2587
throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + this.fileName + ")");
} // 2589
this.decompressed = new CompressedObject(); // 2590
this.decompressed.compressedSize = this.compressedSize; // 2591
this.decompressed.uncompressedSize = this.uncompressedSize; // 2592
this.decompressed.crc32 = this.crc32; // 2593
this.decompressed.compressionMethod = this.compressionMethod; // 2594
this.decompressed.getCompressedContent = this.prepareCompressedContent(reader, reader.index, this.compressedSize, compression);
this.decompressed.getContent = this.prepareContent(reader, reader.index, this.compressedSize, compression, this.uncompressedSize);
// 2597
// we need to compute the crc32... // 2598
if (this.loadOptions.checkCRC32) { // 2599
this.decompressed = utils.transformTo("string", this.decompressed.getContent()); // 2600
if (jszipProto.crc32(this.decompressed) !== this.crc32) { // 2601
throw new Error("Corrupted zip : CRC32 mismatch"); // 2602
} // 2603
} // 2604
}, // 2605
// 2606
/** // 2607
* Read the central part of a zip file and add the info in this object. // 2608
* @param {DataReader} reader the reader to use. // 2609
*/ // 2610
readCentralPart: function(reader) { // 2611
this.versionMadeBy = reader.readInt(2); // 2612
this.versionNeeded = reader.readInt(2); // 2613
this.bitFlag = reader.readInt(2); // 2614
this.compressionMethod = reader.readString(2); // 2615
this.date = reader.readDate(); // 2616
this.crc32 = reader.readInt(4); // 2617
this.compressedSize = reader.readInt(4); // 2618
this.uncompressedSize = reader.readInt(4); // 2619
this.fileNameLength = reader.readInt(2); // 2620
this.extraFieldsLength = reader.readInt(2); // 2621
this.fileCommentLength = reader.readInt(2); // 2622
this.diskNumberStart = reader.readInt(2); // 2623
this.internalFileAttributes = reader.readInt(2); // 2624
this.externalFileAttributes = reader.readInt(4); // 2625
this.localHeaderOffset = reader.readInt(4); // 2626
// 2627
if (this.isEncrypted()) { // 2628
throw new Error("Encrypted zip are not supported"); // 2629
} // 2630
// 2631
this.fileName = reader.readString(this.fileNameLength); // 2632
this.readExtraFields(reader); // 2633
this.parseZIP64ExtraField(reader); // 2634
this.fileComment = reader.readString(this.fileCommentLength); // 2635
}, // 2636
// 2637
/** // 2638
* Parse the external file attributes and get the unix/dos permissions. // 2639
*/ // 2640
processAttributes: function () { // 2641
this.unixPermissions = null; // 2642
this.dosPermissions = null; // 2643
var madeBy = this.versionMadeBy >> 8; // 2644
// 2645
// Check if we have the DOS directory flag set. // 2646
// We look for it in the DOS and UNIX permissions // 2647
// but some unknown platform could set it as a compatibility flag. // 2648
this.dir = this.externalFileAttributes & 0x0010 ? true : false; // 2649
// 2650
if(madeBy === MADE_BY_DOS) { // 2651
// first 6 bits (0 to 5) // 2652
this.dosPermissions = this.externalFileAttributes & 0x3F; // 2653
} // 2654
// 2655
if(madeBy === MADE_BY_UNIX) { // 2656
this.unixPermissions = (this.externalFileAttributes >> 16) & 0xFFFF; // 2657
// the octal permissions are in (this.unixPermissions & 0x01FF).toString(8); // 2658
} // 2659
// 2660
// fail safe : if the name ends with a / it probably means a folder // 2661
if (!this.dir && this.fileName.slice(-1) === '/') { // 2662
this.dir = true; // 2663
} // 2664
}, // 2665
// 2666
/** // 2667
* Parse the ZIP64 extra field and merge the info in the current ZipEntry. // 2668
* @param {DataReader} reader the reader to use. // 2669
*/ // 2670
parseZIP64ExtraField: function(reader) { // 2671
// 2672
if (!this.extraFields[0x0001]) { // 2673
return; // 2674
} // 2675
// 2676
// should be something, preparing the extra reader // 2677
var extraReader = new StringReader(this.extraFields[0x0001].value); // 2678
// 2679
// I really hope that these 64bits integer can fit in 32 bits integer, because js // 2680
// won't let us have more. // 2681
if (this.uncompressedSize === utils.MAX_VALUE_32BITS) { // 2682
this.uncompressedSize = extraReader.readInt(8); // 2683
} // 2684
if (this.compressedSize === utils.MAX_VALUE_32BITS) { // 2685
this.compressedSize = extraReader.readInt(8); // 2686
} // 2687
if (this.localHeaderOffset === utils.MAX_VALUE_32BITS) { // 2688
this.localHeaderOffset = extraReader.readInt(8); // 2689
} // 2690
if (this.diskNumberStart === utils.MAX_VALUE_32BITS) { // 2691
this.diskNumberStart = extraReader.readInt(4); // 2692
} // 2693
}, // 2694
/** // 2695
* Read the central part of a zip file and add the info in this object. // 2696
* @param {DataReader} reader the reader to use. // 2697
*/ // 2698
readExtraFields: function(reader) { // 2699
var start = reader.index, // 2700
extraFieldId, // 2701
extraFieldLength, // 2702
extraFieldValue; // 2703
// 2704
this.extraFields = this.extraFields || {}; // 2705
// 2706
while (reader.index < start + this.extraFieldsLength) { // 2707
extraFieldId = reader.readInt(2); // 2708
extraFieldLength = reader.readInt(2); // 2709
extraFieldValue = reader.readString(extraFieldLength); // 2710
// 2711
this.extraFields[extraFieldId] = { // 2712
id: extraFieldId, // 2713
length: extraFieldLength, // 2714
value: extraFieldValue // 2715
}; // 2716
} // 2717
}, // 2718
/** // 2719
* Apply an UTF8 transformation if needed. // 2720
*/ // 2721
handleUTF8: function() { // 2722
if (this.useUTF8()) { // 2723
this.fileName = jszipProto.utf8decode(this.fileName); // 2724
this.fileComment = jszipProto.utf8decode(this.fileComment); // 2725
} else { // 2726
var upath = this.findExtraFieldUnicodePath(); // 2727
if (upath !== null) { // 2728
this.fileName = upath; // 2729
} // 2730
var ucomment = this.findExtraFieldUnicodeComment(); // 2731
if (ucomment !== null) { // 2732
this.fileComment = ucomment; // 2733
} // 2734
} // 2735
}, // 2736
// 2737
/** // 2738
* Find the unicode path declared in the extra field, if any. // 2739
* @return {String} the unicode path, null otherwise. // 2740
*/ // 2741
findExtraFieldUnicodePath: function() { // 2742
var upathField = this.extraFields[0x7075]; // 2743
if (upathField) { // 2744
var extraReader = new StringReader(upathField.value); // 2745
// 2746
// wrong version // 2747
if (extraReader.readInt(1) !== 1) { // 2748
return null; // 2749
} // 2750
// 2751
// the crc of the filename changed, this field is out of date. // 2752
if (jszipProto.crc32(this.fileName) !== extraReader.readInt(4)) { // 2753
return null; // 2754
} // 2755
// 2756
return jszipProto.utf8decode(extraReader.readString(upathField.length - 5)); // 2757
} // 2758
return null; // 2759
}, // 2760
// 2761
/** // 2762
* Find the unicode comment declared in the extra field, if any. // 2763
* @return {String} the unicode comment, null otherwise. // 2764
*/ // 2765
findExtraFieldUnicodeComment: function() { // 2766
var ucommentField = this.extraFields[0x6375]; // 2767
if (ucommentField) { // 2768
var extraReader = new StringReader(ucommentField.value); // 2769
// 2770
// wrong version // 2771
if (extraReader.readInt(1) !== 1) { // 2772
return null; // 2773
} // 2774
// 2775
// the crc of the comment changed, this field is out of date. // 2776
if (jszipProto.crc32(this.fileComment) !== extraReader.readInt(4)) { // 2777
return null; // 2778
} // 2779
// 2780
return jszipProto.utf8decode(extraReader.readString(ucommentField.length - 5)); // 2781
} // 2782
return null; // 2783
} // 2784
}; // 2785
module.exports = ZipEntry; // 2786
// 2787
},{"./compressedObject":2,"./object":13,"./stringReader":15,"./utils":21}],24:[function(_dereq_,module,exports){ // 2788
// Top level file is just a mixin of submodules & constants // 2789
'use strict'; // 2790
// 2791
var assign = _dereq_('./lib/utils/common').assign; // 2792
// 2793
var deflate = _dereq_('./lib/deflate'); // 2794
var inflate = _dereq_('./lib/inflate'); // 2795
var constants = _dereq_('./lib/zlib/constants'); // 2796
// 2797
var pako = {}; // 2798
// 2799
assign(pako, deflate, inflate, constants); // 2800
// 2801
module.exports = pako; // 2802
},{"./lib/deflate":25,"./lib/inflate":26,"./lib/utils/common":27,"./lib/zlib/constants":30}],25:[function(_dereq_,module,exports){
'use strict'; // 2804
// 2805
// 2806
var zlib_deflate = _dereq_('./zlib/deflate.js'); // 2807
var utils = _dereq_('./utils/common'); // 2808
var strings = _dereq_('./utils/strings'); // 2809
var msg = _dereq_('./zlib/messages'); // 2810
var zstream = _dereq_('./zlib/zstream'); // 2811
// 2812
// 2813
/* Public constants ==========================================================*/ // 2814
/* ===========================================================================*/ // 2815
// 2816
var Z_NO_FLUSH = 0; // 2817
var Z_FINISH = 4; // 2818
// 2819
var Z_OK = 0; // 2820
var Z_STREAM_END = 1; // 2821
// 2822
var Z_DEFAULT_COMPRESSION = -1; // 2823
// 2824
var Z_DEFAULT_STRATEGY = 0; // 2825
// 2826
var Z_DEFLATED = 8; // 2827
// 2828
/* ===========================================================================*/ // 2829
// 2830
// 2831
/** // 2832
* class Deflate // 2833
* // 2834
* Generic JS-style wrapper for zlib calls. If you don't need // 2835
* streaming behaviour - use more simple functions: [[deflate]], // 2836
* [[deflateRaw]] and [[gzip]]. // 2837
**/ // 2838
// 2839
/* internal // 2840
* Deflate.chunks -> Array // 2841
* // 2842
* Chunks of output data, if [[Deflate#onData]] not overriden. // 2843
**/ // 2844
// 2845
/** // 2846
* Deflate.result -> Uint8Array|Array // 2847
* // 2848
* Compressed result, generated by default [[Deflate#onData]] // 2849
* and [[Deflate#onEnd]] handlers. Filled after you push last chunk // 2850
* (call [[Deflate#push]] with `Z_FINISH` / `true` param). // 2851
**/ // 2852
// 2853
/** // 2854
* Deflate.err -> Number // 2855
* // 2856
* Error code after deflate finished. 0 (Z_OK) on success. // 2857
* You will not need it in real life, because deflate errors // 2858
* are possible only on wrong options or bad `onData` / `onEnd` // 2859
* custom handlers. // 2860
**/ // 2861
// 2862
/** // 2863
* Deflate.msg -> String // 2864
* // 2865
* Error message, if [[Deflate.err]] != 0 // 2866
**/ // 2867
// 2868
// 2869
/** // 2870
* new Deflate(options) // 2871
* - options (Object): zlib deflate options. // 2872
* // 2873
* Creates new deflator instance with specified params. Throws exception // 2874
* on bad params. Supported options: // 2875
* // 2876
* - `level` // 2877
* - `windowBits` // 2878
* - `memLevel` // 2879
* - `strategy` // 2880
* // 2881
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) // 2882
* for more information on these. // 2883
* // 2884
* Additional options, for internal needs: // 2885
* // 2886
* - `chunkSize` - size of generated data chunks (16K by default) // 2887
* - `raw` (Boolean) - do raw deflate // 2888
* - `gzip` (Boolean) - create gzip wrapper // 2889
* - `to` (String) - if equal to 'string', then result will be "binary string" // 2890
* (each char code [0..255]) // 2891
* - `header` (Object) - custom header for gzip // 2892
* - `text` (Boolean) - true if compressed data believed to be text // 2893
* - `time` (Number) - modification time, unix timestamp // 2894
* - `os` (Number) - operation system code // 2895
* - `extra` (Array) - array of bytes with extra data (max 65536) // 2896
* - `name` (String) - file name (binary string) // 2897
* - `comment` (String) - comment (binary string) // 2898
* - `hcrc` (Boolean) - true if header crc should be added // 2899
* // 2900
* ##### Example: // 2901
* // 2902
* ```javascript // 2903
* var pako = require('pako') // 2904
* , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9]) // 2905
* , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]); // 2906
* // 2907
* var deflate = new pako.Deflate({ level: 3}); // 2908
* // 2909
* deflate.push(chunk1, false); // 2910
* deflate.push(chunk2, true); // true -> last chunk // 2911
* // 2912
* if (deflate.err) { throw new Error(deflate.err); } // 2913
* // 2914
* console.log(deflate.result); // 2915
* ``` // 2916
**/ // 2917
var Deflate = function(options) { // 2918
// 2919
this.options = utils.assign({ // 2920
level: Z_DEFAULT_COMPRESSION, // 2921
method: Z_DEFLATED, // 2922
chunkSize: 16384, // 2923
windowBits: 15, // 2924
memLevel: 8, // 2925
strategy: Z_DEFAULT_STRATEGY, // 2926
to: '' // 2927
}, options || {}); // 2928
// 2929
var opt = this.options; // 2930
// 2931
if (opt.raw && (opt.windowBits > 0)) { // 2932
opt.windowBits = -opt.windowBits; // 2933
} // 2934
// 2935
else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) { // 2936
opt.windowBits += 16; // 2937
} // 2938
// 2939
this.err = 0; // error code, if happens (0 = Z_OK) // 2940
this.msg = ''; // error message // 2941
this.ended = false; // used to avoid multiple onEnd() calls // 2942
this.chunks = []; // chunks of compressed data // 2943
// 2944
this.strm = new zstream(); // 2945
this.strm.avail_out = 0; // 2946
// 2947
var status = zlib_deflate.deflateInit2( // 2948
this.strm, // 2949
opt.level, // 2950
opt.method, // 2951
opt.windowBits, // 2952
opt.memLevel, // 2953
opt.strategy // 2954
); // 2955
// 2956
if (status !== Z_OK) { // 2957
throw new Error(msg[status]); // 2958
} // 2959
// 2960
if (opt.header) { // 2961
zlib_deflate.deflateSetHeader(this.strm, opt.header); // 2962
} // 2963
}; // 2964
// 2965
/** // 2966
* Deflate#push(data[, mode]) -> Boolean // 2967
* - data (Uint8Array|Array|String): input data. Strings will be converted to // 2968
* utf8 byte sequence. // 2969
* - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes. // 2970
* See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH. // 2971
* // 2972
* Sends input data to deflate pipe, generating [[Deflate#onData]] calls with // 2973
* new compressed chunks. Returns `true` on success. The last data block must have // 2974
* mode Z_FINISH (or `true`). That flush internal pending buffers and call // 2975
* [[Deflate#onEnd]]. // 2976
* // 2977
* On fail call [[Deflate#onEnd]] with error code and return false. // 2978
* // 2979
* We strongly recommend to use `Uint8Array` on input for best speed (output // 2980
* array format is detected automatically). Also, don't skip last param and always // 2981
* use the same type in your code (boolean or number). That will improve JS speed. // 2982
* // 2983
* For regular `Array`-s make sure all elements are [0..255]. // 2984
* // 2985
* ##### Example // 2986
* // 2987
* ```javascript // 2988
* push(chunk, false); // push one of data chunks // 2989
* ... // 2990
* push(chunk, true); // push last chunk // 2991
* ``` // 2992
**/ // 2993
Deflate.prototype.push = function(data, mode) { // 2994
var strm = this.strm; // 2995
var chunkSize = this.options.chunkSize; // 2996
var status, _mode; // 2997
// 2998
if (this.ended) { return false; } // 2999
// 3000
_mode = (mode === ~~mode) ? mode : ((mode === true) ? Z_FINISH : Z_NO_FLUSH); // 3001
// 3002
// Convert data if needed // 3003
if (typeof data === 'string') { // 3004
// If we need to compress text, change encoding to utf8. // 3005
strm.input = strings.string2buf(data); // 3006
} else { // 3007
strm.input = data; // 3008
} // 3009
// 3010
strm.next_in = 0; // 3011
strm.avail_in = strm.input.length; // 3012
// 3013
do { // 3014
if (strm.avail_out === 0) { // 3015
strm.output = new utils.Buf8(chunkSize); // 3016
strm.next_out = 0; // 3017
strm.avail_out = chunkSize; // 3018
} // 3019
status = zlib_deflate.deflate(strm, _mode); /* no bad return value */ // 3020
// 3021
if (status !== Z_STREAM_END && status !== Z_OK) { // 3022
this.onEnd(status); // 3023
this.ended = true; // 3024
return false; // 3025
} // 3026
if (strm.avail_out === 0 || (strm.avail_in === 0 && _mode === Z_FINISH)) { // 3027
if (this.options.to === 'string') { // 3028
this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out))); // 3029
} else { // 3030
this.onData(utils.shrinkBuf(strm.output, strm.next_out)); // 3031
} // 3032
} // 3033
} while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END); // 3034
// 3035
// Finalize on the last chunk. // 3036
if (_mode === Z_FINISH) { // 3037
status = zlib_deflate.deflateEnd(this.strm); // 3038
this.onEnd(status); // 3039
this.ended = true; // 3040
return status === Z_OK; // 3041
} // 3042
// 3043
return true; // 3044
}; // 3045
// 3046
// 3047
/** // 3048
* Deflate#onData(chunk) -> Void // 3049
* - chunk (Uint8Array|Array|String): ouput data. Type of array depends // 3050
* on js engine support. When string output requested, each chunk // 3051
* will be string. // 3052
* // 3053
* By default, stores data blocks in `chunks[]` property and glue // 3054
* those in `onEnd`. Override this handler, if you need another behaviour. // 3055
**/ // 3056
Deflate.prototype.onData = function(chunk) { // 3057
this.chunks.push(chunk); // 3058
}; // 3059
// 3060
// 3061
/** // 3062
* Deflate#onEnd(status) -> Void // 3063
* - status (Number): deflate status. 0 (Z_OK) on success, // 3064
* other if not. // 3065
* // 3066
* Called once after you tell deflate that input stream complete // 3067
* or error happenned. By default - join collected chunks, // 3068
* free memory and fill `results` / `err` properties. // 3069
**/ // 3070
Deflate.prototype.onEnd = function(status) { // 3071
// On success - join // 3072
if (status === Z_OK) { // 3073
if (this.options.to === 'string') { // 3074
this.result = this.chunks.join(''); // 3075
} else { // 3076
this.result = utils.flattenChunks(this.chunks); // 3077
} // 3078
} // 3079
this.chunks = []; // 3080
this.err = status; // 3081
this.msg = this.strm.msg; // 3082
}; // 3083
// 3084
// 3085
/** // 3086
* deflate(data[, options]) -> Uint8Array|Array|String // 3087
* - data (Uint8Array|Array|String): input data to compress. // 3088
* - options (Object): zlib deflate options. // 3089
* // 3090
* Compress `data` with deflate alrorythm and `options`. // 3091
* // 3092
* Supported options are: // 3093
* // 3094
* - level // 3095
* - windowBits // 3096
* - memLevel // 3097
* - strategy // 3098
* // 3099
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) // 3100
* for more information on these. // 3101
* // 3102
* Sugar (options): // 3103
* // 3104
* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify // 3105
* negative windowBits implicitly. // 3106
* - `to` (String) - if equal to 'string', then result will be "binary string" // 3107
* (each char code [0..255]) // 3108
* // 3109
* ##### Example: // 3110
* // 3111
* ```javascript // 3112
* var pako = require('pako') // 3113
* , data = Uint8Array([1,2,3,4,5,6,7,8,9]); // 3114
* // 3115
* console.log(pako.deflate(data)); // 3116
* ``` // 3117
**/ // 3118
function deflate(input, options) { // 3119
var deflator = new Deflate(options); // 3120
// 3121
deflator.push(input, true); // 3122
// 3123
// That will never happens, if you don't cheat with options :) // 3124
if (deflator.err) { throw deflator.msg; } // 3125
// 3126
return deflator.result; // 3127
} // 3128
// 3129
// 3130
/** // 3131
* deflateRaw(data[, options]) -> Uint8Array|Array|String // 3132
* - data (Uint8Array|Array|String): input data to compress. // 3133
* - options (Object): zlib deflate options. // 3134
* // 3135
* The same as [[deflate]], but creates raw data, without wrapper // 3136
* (header and adler32 crc). // 3137
**/ // 3138
function deflateRaw(input, options) { // 3139
options = options || {}; // 3140
options.raw = true; // 3141
return deflate(input, options); // 3142
} // 3143
// 3144
// 3145
/** // 3146
* gzip(data[, options]) -> Uint8Array|Array|String // 3147
* - data (Uint8Array|Array|String): input data to compress. // 3148
* - options (Object): zlib deflate options. // 3149
* // 3150
* The same as [[deflate]], but create gzip wrapper instead of // 3151
* deflate one. // 3152
**/ // 3153
function gzip(input, options) { // 3154
options = options || {}; // 3155
options.gzip = true; // 3156
return deflate(input, options); // 3157
} // 3158
// 3159
// 3160
exports.Deflate = Deflate; // 3161
exports.deflate = deflate; // 3162
exports.deflateRaw = deflateRaw; // 3163
exports.gzip = gzip; // 3164
},{"./utils/common":27,"./utils/strings":28,"./zlib/deflate.js":32,"./zlib/messages":37,"./zlib/zstream":39}],26:[function(_dereq_,module,exports){
'use strict'; // 3166
// 3167
// 3168
var zlib_inflate = _dereq_('./zlib/inflate.js'); // 3169
var utils = _dereq_('./utils/common'); // 3170
var strings = _dereq_('./utils/strings'); // 3171
var c = _dereq_('./zlib/constants'); // 3172
var msg = _dereq_('./zlib/messages'); // 3173
var zstream = _dereq_('./zlib/zstream'); // 3174
var gzheader = _dereq_('./zlib/gzheader'); // 3175
// 3176
// 3177
/** // 3178
* class Inflate // 3179
* // 3180
* Generic JS-style wrapper for zlib calls. If you don't need // 3181
* streaming behaviour - use more simple functions: [[inflate]] // 3182
* and [[inflateRaw]]. // 3183
**/ // 3184
// 3185
/* internal // 3186
* inflate.chunks -> Array // 3187
* // 3188
* Chunks of output data, if [[Inflate#onData]] not overriden. // 3189
**/ // 3190
// 3191
/** // 3192
* Inflate.result -> Uint8Array|Array|String // 3193
* // 3194
* Uncompressed result, generated by default [[Inflate#onData]] // 3195
* and [[Inflate#onEnd]] handlers. Filled after you push last chunk // 3196
* (call [[Inflate#push]] with `Z_FINISH` / `true` param). // 3197
**/ // 3198
// 3199
/** // 3200
* Inflate.err -> Number // 3201
* // 3202
* Error code after inflate finished. 0 (Z_OK) on success. // 3203
* Should be checked if broken data possible. // 3204
**/ // 3205
// 3206
/** // 3207
* Inflate.msg -> String // 3208
* // 3209
* Error message, if [[Inflate.err]] != 0 // 3210
**/ // 3211
// 3212
// 3213
/** // 3214
* new Inflate(options) // 3215
* - options (Object): zlib inflate options. // 3216
* // 3217
* Creates new inflator instance with specified params. Throws exception // 3218
* on bad params. Supported options: // 3219
* // 3220
* - `windowBits` // 3221
* // 3222
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) // 3223
* for more information on these. // 3224
* // 3225
* Additional options, for internal needs: // 3226
* // 3227
* - `chunkSize` - size of generated data chunks (16K by default) // 3228
* - `raw` (Boolean) - do raw inflate // 3229
* - `to` (String) - if equal to 'string', then result will be converted // 3230
* from utf8 to utf16 (javascript) string. When string output requested, // 3231
* chunk length can differ from `chunkSize`, depending on content. // 3232
* // 3233
* By default, when no options set, autodetect deflate/gzip data format via // 3234
* wrapper header. // 3235
* // 3236
* ##### Example: // 3237
* // 3238
* ```javascript // 3239
* var pako = require('pako') // 3240
* , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9]) // 3241
* , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]); // 3242
* // 3243
* var inflate = new pako.Inflate({ level: 3}); // 3244
* // 3245
* inflate.push(chunk1, false); // 3246
* inflate.push(chunk2, true); // true -> last chunk // 3247
* // 3248
* if (inflate.err) { throw new Error(inflate.err); } // 3249
* // 3250
* console.log(inflate.result); // 3251
* ``` // 3252
**/ // 3253
var Inflate = function(options) { // 3254
// 3255
this.options = utils.assign({ // 3256
chunkSize: 16384, // 3257
windowBits: 0, // 3258
to: '' // 3259
}, options || {}); // 3260
// 3261
var opt = this.options; // 3262
// 3263
// Force window size for `raw` data, if not set directly, // 3264
// because we have no header for autodetect. // 3265
if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) { // 3266
opt.windowBits = -opt.windowBits; // 3267
if (opt.windowBits === 0) { opt.windowBits = -15; } // 3268
} // 3269
// 3270
// If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate // 3271
if ((opt.windowBits >= 0) && (opt.windowBits < 16) && // 3272
!(options && options.windowBits)) { // 3273
opt.windowBits += 32; // 3274
} // 3275
// 3276
// Gzip header has no info about windows size, we can do autodetect only // 3277
// for deflate. So, if window size not set, force it to max when gzip possible // 3278
if ((opt.windowBits > 15) && (opt.windowBits < 48)) { // 3279
// bit 3 (16) -> gzipped data // 3280
// bit 4 (32) -> autodetect gzip/deflate // 3281
if ((opt.windowBits & 15) === 0) { // 3282
opt.windowBits |= 15; // 3283
} // 3284
} // 3285
// 3286
this.err = 0; // error code, if happens (0 = Z_OK) // 3287
this.msg = ''; // error message // 3288
this.ended = false; // used to avoid multiple onEnd() calls // 3289
this.chunks = []; // chunks of compressed data // 3290
// 3291
this.strm = new zstream(); // 3292
this.strm.avail_out = 0; // 3293
// 3294
var status = zlib_inflate.inflateInit2( // 3295
this.strm, // 3296
opt.windowBits // 3297
); // 3298
// 3299
if (status !== c.Z_OK) { // 3300
throw new Error(msg[status]); // 3301
} // 3302
// 3303
this.header = new gzheader(); // 3304
// 3305
zlib_inflate.inflateGetHeader(this.strm, this.header); // 3306
}; // 3307
// 3308
/** // 3309
* Inflate#push(data[, mode]) -> Boolean // 3310
* - data (Uint8Array|Array|String): input data // 3311
* - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes. // 3312
* See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH. // 3313
* // 3314
* Sends input data to inflate pipe, generating [[Inflate#onData]] calls with // 3315
* new output chunks. Returns `true` on success. The last data block must have // 3316
* mode Z_FINISH (or `true`). That flush internal pending buffers and call // 3317
* [[Inflate#onEnd]]. // 3318
* // 3319
* On fail call [[Inflate#onEnd]] with error code and return false. // 3320
* // 3321
* We strongly recommend to use `Uint8Array` on input for best speed (output // 3322
* format is detected automatically). Also, don't skip last param and always // 3323
* use the same type in your code (boolean or number). That will improve JS speed. // 3324
* // 3325
* For regular `Array`-s make sure all elements are [0..255]. // 3326
* // 3327
* ##### Example // 3328
* // 3329
* ```javascript // 3330
* push(chunk, false); // push one of data chunks // 3331
* ... // 3332
* push(chunk, true); // push last chunk // 3333
* ``` // 3334
**/ // 3335
Inflate.prototype.push = function(data, mode) { // 3336
var strm = this.strm; // 3337
var chunkSize = this.options.chunkSize; // 3338
var status, _mode; // 3339
var next_out_utf8, tail, utf8str; // 3340
// 3341
if (this.ended) { return false; } // 3342
_mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH); // 3343
// 3344
// Convert data if needed // 3345
if (typeof data === 'string') { // 3346
// Only binary strings can be decompressed on practice // 3347
strm.input = strings.binstring2buf(data); // 3348
} else { // 3349
strm.input = data; // 3350
} // 3351
// 3352
strm.next_in = 0; // 3353
strm.avail_in = strm.input.length; // 3354
// 3355
do { // 3356
if (strm.avail_out === 0) { // 3357
strm.output = new utils.Buf8(chunkSize); // 3358
strm.next_out = 0; // 3359
strm.avail_out = chunkSize; // 3360
} // 3361
// 3362
status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); /* no bad return value */ // 3363
// 3364
if (status !== c.Z_STREAM_END && status !== c.Z_OK) { // 3365
this.onEnd(status); // 3366
this.ended = true; // 3367
return false; // 3368
} // 3369
// 3370
if (strm.next_out) { // 3371
if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && _mode === c.Z_FINISH)) { // 3372
// 3373
if (this.options.to === 'string') { // 3374
// 3375
next_out_utf8 = strings.utf8border(strm.output, strm.next_out); // 3376
// 3377
tail = strm.next_out - next_out_utf8; // 3378
utf8str = strings.buf2string(strm.output, next_out_utf8); // 3379
// 3380
// move tail // 3381
strm.next_out = tail; // 3382
strm.avail_out = chunkSize - tail; // 3383
if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); } // 3384
// 3385
this.onData(utf8str); // 3386
// 3387
} else { // 3388
this.onData(utils.shrinkBuf(strm.output, strm.next_out)); // 3389
} // 3390
} // 3391
} // 3392
} while ((strm.avail_in > 0) && status !== c.Z_STREAM_END); // 3393
// 3394
if (status === c.Z_STREAM_END) { // 3395
_mode = c.Z_FINISH; // 3396
} // 3397
// Finalize on the last chunk. // 3398
if (_mode === c.Z_FINISH) { // 3399
status = zlib_inflate.inflateEnd(this.strm); // 3400
this.onEnd(status); // 3401
this.ended = true; // 3402
return status === c.Z_OK; // 3403
} // 3404
// 3405
return true; // 3406
}; // 3407
// 3408
// 3409
/** // 3410
* Inflate#onData(chunk) -> Void // 3411
* - chunk (Uint8Array|Array|String): ouput data. Type of array depends // 3412
* on js engine support. When string output requested, each chunk // 3413
* will be string. // 3414
* // 3415
* By default, stores data blocks in `chunks[]` property and glue // 3416
* those in `onEnd`. Override this handler, if you need another behaviour. // 3417
**/ // 3418
Inflate.prototype.onData = function(chunk) { // 3419
this.chunks.push(chunk); // 3420
}; // 3421
// 3422
// 3423
/** // 3424
* Inflate#onEnd(status) -> Void // 3425
* - status (Number): inflate status. 0 (Z_OK) on success, // 3426
* other if not. // 3427
* // 3428
* Called once after you tell inflate that input stream complete // 3429
* or error happenned. By default - join collected chunks, // 3430
* free memory and fill `results` / `err` properties. // 3431
**/ // 3432
Inflate.prototype.onEnd = function(status) { // 3433
// On success - join // 3434
if (status === c.Z_OK) { // 3435
if (this.options.to === 'string') { // 3436
// Glue & convert here, until we teach pako to send // 3437
// utf8 alligned strings to onData // 3438
this.result = this.chunks.join(''); // 3439
} else { // 3440
this.result = utils.flattenChunks(this.chunks); // 3441
} // 3442
} // 3443
this.chunks = []; // 3444
this.err = status; // 3445
this.msg = this.strm.msg; // 3446
}; // 3447
// 3448
// 3449
/** // 3450
* inflate(data[, options]) -> Uint8Array|Array|String // 3451
* - data (Uint8Array|Array|String): input data to decompress. // 3452
* - options (Object): zlib inflate options. // 3453
* // 3454
* Decompress `data` with inflate/ungzip and `options`. Autodetect // 3455
* format via wrapper header by default. That's why we don't provide // 3456
* separate `ungzip` method. // 3457
* // 3458
* Supported options are: // 3459
* // 3460
* - windowBits // 3461
* // 3462
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced) // 3463
* for more information. // 3464
* // 3465
* Sugar (options): // 3466
* // 3467
* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify // 3468
* negative windowBits implicitly. // 3469
* - `to` (String) - if equal to 'string', then result will be converted // 3470
* from utf8 to utf16 (javascript) string. When string output requested, // 3471
* chunk length can differ from `chunkSize`, depending on content. // 3472
* // 3473
* // 3474
* ##### Example: // 3475
* // 3476
* ```javascript // 3477
* var pako = require('pako') // 3478
* , input = pako.deflate([1,2,3,4,5,6,7,8,9]) // 3479
* , output; // 3480
* // 3481
* try { // 3482
* output = pako.inflate(input); // 3483
* } catch (err) // 3484
* console.log(err); // 3485
* } // 3486
* ``` // 3487
**/ // 3488
function inflate(input, options) { // 3489
var inflator = new Inflate(options); // 3490
// 3491
inflator.push(input, true); // 3492
// 3493
// That will never happens, if you don't cheat with options :) // 3494
if (inflator.err) { throw inflator.msg; } // 3495
// 3496
return inflator.result; // 3497
} // 3498
// 3499
// 3500
/** // 3501
* inflateRaw(data[, options]) -> Uint8Array|Array|String // 3502
* - data (Uint8Array|Array|String): input data to decompress. // 3503
* - options (Object): zlib inflate options. // 3504
* // 3505
* The same as [[inflate]], but creates raw data, without wrapper // 3506
* (header and adler32 crc). // 3507
**/ // 3508
function inflateRaw(input, options) { // 3509
options = options || {}; // 3510
options.raw = true; // 3511
return inflate(input, options); // 3512
} // 3513
// 3514
// 3515
/** // 3516
* ungzip(data[, options]) -> Uint8Array|Array|String // 3517
* - data (Uint8Array|Array|String): input data to decompress. // 3518
* - options (Object): zlib inflate options. // 3519
* // 3520
* Just shortcut to [[inflate]], because it autodetects format // 3521
* by header.content. Done for convenience. // 3522
**/ // 3523
// 3524
// 3525
exports.Inflate = Inflate; // 3526
exports.inflate = inflate; // 3527
exports.inflateRaw = inflateRaw; // 3528
exports.ungzip = inflate; // 3529
// 3530
},{"./utils/common":27,"./utils/strings":28,"./zlib/constants":30,"./zlib/gzheader":33,"./zlib/inflate.js":35,"./zlib/messages":37,"./zlib/zstream":39}],27:[function(_dereq_,module,exports){
'use strict'; // 3532
// 3533
// 3534
var TYPED_OK = (typeof Uint8Array !== 'undefined') && // 3535
(typeof Uint16Array !== 'undefined') && // 3536
(typeof Int32Array !== 'undefined'); // 3537
// 3538
// 3539
exports.assign = function (obj /*from1, from2, from3, ...*/) { // 3540
var sources = Array.prototype.slice.call(arguments, 1); // 3541
while (sources.length) { // 3542
var source = sources.shift(); // 3543
if (!source) { continue; } // 3544
// 3545
if (typeof(source) !== 'object') { // 3546
throw new TypeError(source + 'must be non-object'); // 3547
} // 3548
// 3549
for (var p in source) { // 3550
if (source.hasOwnProperty(p)) { // 3551
obj[p] = source[p]; // 3552
} // 3553
} // 3554
} // 3555
// 3556
return obj; // 3557
}; // 3558
// 3559
// 3560
// reduce buffer size, avoiding mem copy // 3561
exports.shrinkBuf = function (buf, size) { // 3562
if (buf.length === size) { return buf; } // 3563
if (buf.subarray) { return buf.subarray(0, size); } // 3564
buf.length = size; // 3565
return buf; // 3566
}; // 3567
// 3568
// 3569
var fnTyped = { // 3570
arraySet: function (dest, src, src_offs, len, dest_offs) { // 3571
if (src.subarray && dest.subarray) { // 3572
dest.set(src.subarray(src_offs, src_offs+len), dest_offs); // 3573
return; // 3574
} // 3575
// Fallback to ordinary array // 3576
for(var i=0; i<len; i++) { // 3577
dest[dest_offs + i] = src[src_offs + i]; // 3578
} // 3579
}, // 3580
// Join array of chunks to single array. // 3581
flattenChunks: function(chunks) { // 3582
var i, l, len, pos, chunk, result; // 3583
// 3584
// calculate data length // 3585
len = 0; // 3586
for (i=0, l=chunks.length; i<l; i++) { // 3587
len += chunks[i].length; // 3588
} // 3589
// 3590
// join chunks // 3591
result = new Uint8Array(len); // 3592
pos = 0; // 3593
for (i=0, l=chunks.length; i<l; i++) { // 3594
chunk = chunks[i]; // 3595
result.set(chunk, pos); // 3596
pos += chunk.length; // 3597
} // 3598
// 3599
return result; // 3600
} // 3601
}; // 3602
// 3603
var fnUntyped = { // 3604
arraySet: function (dest, src, src_offs, len, dest_offs) { // 3605
for(var i=0; i<len; i++) { // 3606
dest[dest_offs + i] = src[src_offs + i]; // 3607
} // 3608
}, // 3609
// Join array of chunks to single array. // 3610
flattenChunks: function(chunks) { // 3611
return [].concat.apply([], chunks); // 3612
} // 3613
}; // 3614
// 3615
// 3616
// Enable/Disable typed arrays use, for testing // 3617
// // 3618
exports.setTyped = function (on) { // 3619
if (on) { // 3620
exports.Buf8 = Uint8Array; // 3621
exports.Buf16 = Uint16Array; // 3622
exports.Buf32 = Int32Array; // 3623
exports.assign(exports, fnTyped); // 3624
} else { // 3625
exports.Buf8 = Array; // 3626
exports.Buf16 = Array; // 3627
exports.Buf32 = Array; // 3628
exports.assign(exports, fnUntyped); // 3629
} // 3630
}; // 3631
// 3632
exports.setTyped(TYPED_OK); // 3633
},{}],28:[function(_dereq_,module,exports){ // 3634
// String encode/decode helpers // 3635
'use strict'; // 3636
// 3637
// 3638
var utils = _dereq_('./common'); // 3639
// 3640
// 3641
// Quick check if we can use fast array to bin string conversion // 3642
// // 3643
// - apply(Array) can fail on Android 2.2 // 3644
// - apply(Uint8Array) can fail on iOS 5.1 Safary // 3645
// // 3646
var STR_APPLY_OK = true; // 3647
var STR_APPLY_UIA_OK = true; // 3648
// 3649
try { String.fromCharCode.apply(null, [0]); } catch(__) { STR_APPLY_OK = false; } // 3650
try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch(__) { STR_APPLY_UIA_OK = false; } // 3651
// 3652
// 3653
// Table with utf8 lengths (calculated by first byte of sequence) // 3654
// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS, // 3655
// because max possible codepoint is 0x10ffff // 3656
var _utf8len = new utils.Buf8(256); // 3657
for (var i=0; i<256; i++) { // 3658
_utf8len[i] = (i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1); // 3659
} // 3660
_utf8len[254]=_utf8len[254]=1; // Invalid sequence start // 3661
// 3662
// 3663
// convert string to array (typed, when possible) // 3664
exports.string2buf = function (str) { // 3665
var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0; // 3666
// 3667
// count binary size // 3668
for (m_pos = 0; m_pos < str_len; m_pos++) { // 3669
c = str.charCodeAt(m_pos); // 3670
if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) { // 3671
c2 = str.charCodeAt(m_pos+1); // 3672
if ((c2 & 0xfc00) === 0xdc00) { // 3673
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00); // 3674
m_pos++; // 3675
} // 3676
} // 3677
buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; // 3678
} // 3679
// 3680
// allocate buffer // 3681
buf = new utils.Buf8(buf_len); // 3682
// 3683
// convert // 3684
for (i=0, m_pos = 0; i < buf_len; m_pos++) { // 3685
c = str.charCodeAt(m_pos); // 3686
if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) { // 3687
c2 = str.charCodeAt(m_pos+1); // 3688
if ((c2 & 0xfc00) === 0xdc00) { // 3689
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00); // 3690
m_pos++; // 3691
} // 3692
} // 3693
if (c < 0x80) { // 3694
/* one byte */ // 3695
buf[i++] = c; // 3696
} else if (c < 0x800) { // 3697
/* two bytes */ // 3698
buf[i++] = 0xC0 | (c >>> 6); // 3699
buf[i++] = 0x80 | (c & 0x3f); // 3700
} else if (c < 0x10000) { // 3701
/* three bytes */ // 3702
buf[i++] = 0xE0 | (c >>> 12); // 3703
buf[i++] = 0x80 | (c >>> 6 & 0x3f); // 3704
buf[i++] = 0x80 | (c & 0x3f); // 3705
} else { // 3706
/* four bytes */ // 3707
buf[i++] = 0xf0 | (c >>> 18); // 3708
buf[i++] = 0x80 | (c >>> 12 & 0x3f); // 3709
buf[i++] = 0x80 | (c >>> 6 & 0x3f); // 3710
buf[i++] = 0x80 | (c & 0x3f); // 3711
} // 3712
} // 3713
// 3714
return buf; // 3715
}; // 3716
// 3717
// Helper (used in 2 places) // 3718
function buf2binstring(buf, len) { // 3719
// use fallback for big arrays to avoid stack overflow // 3720
if (len < 65537) { // 3721
if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) { // 3722
return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len)); // 3723
} // 3724
} // 3725
// 3726
var result = ''; // 3727
for(var i=0; i < len; i++) { // 3728
result += String.fromCharCode(buf[i]); // 3729
} // 3730
return result; // 3731
} // 3732
// 3733
// 3734
// Convert byte array to binary string // 3735
exports.buf2binstring = function(buf) { // 3736
return buf2binstring(buf, buf.length); // 3737
}; // 3738
// 3739
// 3740
// Convert binary string (typed, when possible) // 3741
exports.binstring2buf = function(str) { // 3742
var buf = new utils.Buf8(str.length); // 3743
for(var i=0, len=buf.length; i < len; i++) { // 3744
buf[i] = str.charCodeAt(i); // 3745
} // 3746
return buf; // 3747
}; // 3748
// 3749
// 3750
// convert array to string // 3751
exports.buf2string = function (buf, max) { // 3752
var i, out, c, c_len; // 3753
var len = max || buf.length; // 3754
// 3755
// Reserve max possible length (2 words per char) // 3756
// NB: by unknown reasons, Array is significantly faster for // 3757
// String.fromCharCode.apply than Uint16Array. // 3758
var utf16buf = new Array(len*2); // 3759
// 3760
for (out=0, i=0; i<len;) { // 3761
c = buf[i++]; // 3762
// quick process ascii // 3763
if (c < 0x80) { utf16buf[out++] = c; continue; } // 3764
// 3765
c_len = _utf8len[c]; // 3766
// skip 5 & 6 byte codes // 3767
if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; } // 3768
// 3769
// apply mask on first byte // 3770
c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07; // 3771
// join the rest // 3772
while (c_len > 1 && i < len) { // 3773
c = (c << 6) | (buf[i++] & 0x3f); // 3774
c_len--; // 3775
} // 3776
// 3777
// terminated by end of string? // 3778
if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; } // 3779
// 3780
if (c < 0x10000) { // 3781
utf16buf[out++] = c; // 3782
} else { // 3783
c -= 0x10000; // 3784
utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff); // 3785
utf16buf[out++] = 0xdc00 | (c & 0x3ff); // 3786
} // 3787
} // 3788
// 3789
return buf2binstring(utf16buf, out); // 3790
}; // 3791
// 3792
// 3793
// Calculate max possible position in utf8 buffer, // 3794
// that will not break sequence. If that's not possible // 3795
// - (very small limits) return max size as is. // 3796
// // 3797
// buf[] - utf8 bytes array // 3798
// max - length limit (mandatory); // 3799
exports.utf8border = function(buf, max) { // 3800
var pos; // 3801
// 3802
max = max || buf.length; // 3803
if (max > buf.length) { max = buf.length; } // 3804
// 3805
// go back from last position, until start of sequence found // 3806
pos = max-1; // 3807
while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; } // 3808
// 3809
// Fuckup - very small and broken sequence, // 3810
// return max, because we should return something anyway. // 3811
if (pos < 0) { return max; } // 3812
// 3813
// If we came to start of buffer - that means vuffer is too small, // 3814
// return max too. // 3815
if (pos === 0) { return max; } // 3816
// 3817
return (pos + _utf8len[buf[pos]] > max) ? pos : max; // 3818
}; // 3819
// 3820
},{"./common":27}],29:[function(_dereq_,module,exports){ // 3821
'use strict'; // 3822
// 3823
// Note: adler32 takes 12% for level 0 and 2% for level 6. // 3824
// It doesn't worth to make additional optimizationa as in original. // 3825
// Small size is preferable. // 3826
// 3827
function adler32(adler, buf, len, pos) { // 3828
var s1 = (adler & 0xffff) |0 // 3829
, s2 = ((adler >>> 16) & 0xffff) |0 // 3830
, n = 0; // 3831
// 3832
while (len !== 0) { // 3833
// Set limit ~ twice less than 5552, to keep // 3834
// s2 in 31-bits, because we force signed ints. // 3835
// in other case %= will fail. // 3836
n = len > 2000 ? 2000 : len; // 3837
len -= n; // 3838
// 3839
do { // 3840
s1 = (s1 + buf[pos++]) |0; // 3841
s2 = (s2 + s1) |0; // 3842
} while (--n); // 3843
// 3844
s1 %= 65521; // 3845
s2 %= 65521; // 3846
} // 3847
// 3848
return (s1 | (s2 << 16)) |0; // 3849
} // 3850
// 3851
// 3852
module.exports = adler32; // 3853
},{}],30:[function(_dereq_,module,exports){ // 3854
module.exports = { // 3855
// 3856
/* Allowed flush values; see deflate() and inflate() below for details */ // 3857
Z_NO_FLUSH: 0, // 3858
Z_PARTIAL_FLUSH: 1, // 3859
Z_SYNC_FLUSH: 2, // 3860
Z_FULL_FLUSH: 3, // 3861
Z_FINISH: 4, // 3862
Z_BLOCK: 5, // 3863
Z_TREES: 6, // 3864
// 3865
/* Return codes for the compression/decompression functions. Negative values // 3866
* are errors, positive values are used for special but normal events. // 3867
*/ // 3868
Z_OK: 0, // 3869
Z_STREAM_END: 1, // 3870
Z_NEED_DICT: 2, // 3871
Z_ERRNO: -1, // 3872
Z_STREAM_ERROR: -2, // 3873
Z_DATA_ERROR: -3, // 3874
//Z_MEM_ERROR: -4, // 3875
Z_BUF_ERROR: -5, // 3876
//Z_VERSION_ERROR: -6, // 3877
// 3878
/* compression levels */ // 3879
Z_NO_COMPRESSION: 0, // 3880
Z_BEST_SPEED: 1, // 3881
Z_BEST_COMPRESSION: 9, // 3882
Z_DEFAULT_COMPRESSION: -1, // 3883
// 3884
// 3885
Z_FILTERED: 1, // 3886
Z_HUFFMAN_ONLY: 2, // 3887
Z_RLE: 3, // 3888
Z_FIXED: 4, // 3889
Z_DEFAULT_STRATEGY: 0, // 3890
// 3891
/* Possible values of the data_type field (though see inflate()) */ // 3892
Z_BINARY: 0, // 3893
Z_TEXT: 1, // 3894
//Z_ASCII: 1, // = Z_TEXT (deprecated) // 3895
Z_UNKNOWN: 2, // 3896
// 3897
/* The deflate compression method */ // 3898
Z_DEFLATED: 8 // 3899
//Z_NULL: null // Use -1 or null inline, depending on var type // 3900
}; // 3901
},{}],31:[function(_dereq_,module,exports){ // 3902
'use strict'; // 3903
// 3904
// Note: we can't get significant speed boost here. // 3905
// So write code to minimize size - no pregenerated tables // 3906
// and array tools dependencies. // 3907
// 3908
// 3909
// Use ordinary array, since untyped makes no boost here // 3910
function makeTable() { // 3911
var c, table = []; // 3912
// 3913
for(var n =0; n < 256; n++){ // 3914
c = n; // 3915
for(var k =0; k < 8; k++){ // 3916
c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1)); // 3917
} // 3918
table[n] = c; // 3919
} // 3920
// 3921
return table; // 3922
} // 3923
// 3924
// Create table on load. Just 255 signed longs. Not a problem. // 3925
var crcTable = makeTable(); // 3926
// 3927
// 3928
function crc32(crc, buf, len, pos) { // 3929
var t = crcTable // 3930
, end = pos + len; // 3931
// 3932
crc = crc ^ (-1); // 3933
// 3934
for (var i = pos; i < end; i++ ) { // 3935
crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF]; // 3936
} // 3937
// 3938
return (crc ^ (-1)); // >>> 0; // 3939
} // 3940
// 3941
// 3942
module.exports = crc32; // 3943
},{}],32:[function(_dereq_,module,exports){ // 3944
'use strict'; // 3945
// 3946
var utils = _dereq_('../utils/common'); // 3947
var trees = _dereq_('./trees'); // 3948
var adler32 = _dereq_('./adler32'); // 3949
var crc32 = _dereq_('./crc32'); // 3950
var msg = _dereq_('./messages'); // 3951
// 3952
/* Public constants ==========================================================*/ // 3953
/* ===========================================================================*/ // 3954
// 3955
// 3956
/* Allowed flush values; see deflate() and inflate() below for details */ // 3957
var Z_NO_FLUSH = 0; // 3958
var Z_PARTIAL_FLUSH = 1; // 3959
//var Z_SYNC_FLUSH = 2; // 3960
var Z_FULL_FLUSH = 3; // 3961
var Z_FINISH = 4; // 3962
var Z_BLOCK = 5; // 3963
//var Z_TREES = 6; // 3964
// 3965
// 3966
/* Return codes for the compression/decompression functions. Negative values // 3967
* are errors, positive values are used for special but normal events. // 3968
*/ // 3969
var Z_OK = 0; // 3970
var Z_STREAM_END = 1; // 3971
//var Z_NEED_DICT = 2; // 3972
//var Z_ERRNO = -1; // 3973
var Z_STREAM_ERROR = -2; // 3974
var Z_DATA_ERROR = -3; // 3975
//var Z_MEM_ERROR = -4; // 3976
var Z_BUF_ERROR = -5; // 3977
//var Z_VERSION_ERROR = -6; // 3978
// 3979
// 3980
/* compression levels */ // 3981
//var Z_NO_COMPRESSION = 0; // 3982
//var Z_BEST_SPEED = 1; // 3983
//var Z_BEST_COMPRESSION = 9; // 3984
var Z_DEFAULT_COMPRESSION = -1; // 3985
// 3986
// 3987
var Z_FILTERED = 1; // 3988
var Z_HUFFMAN_ONLY = 2; // 3989
var Z_RLE = 3; // 3990
var Z_FIXED = 4; // 3991
var Z_DEFAULT_STRATEGY = 0; // 3992
// 3993
/* Possible values of the data_type field (though see inflate()) */ // 3994
//var Z_BINARY = 0; // 3995
//var Z_TEXT = 1; // 3996
//var Z_ASCII = 1; // = Z_TEXT // 3997
var Z_UNKNOWN = 2; // 3998
// 3999
// 4000
/* The deflate compression method */ // 4001
var Z_DEFLATED = 8; // 4002
// 4003
/*============================================================================*/ // 4004
// 4005
// 4006
var MAX_MEM_LEVEL = 9; // 4007
/* Maximum value for memLevel in deflateInit2 */ // 4008
var MAX_WBITS = 15; // 4009
/* 32K LZ77 window */ // 4010
var DEF_MEM_LEVEL = 8; // 4011
// 4012
// 4013
var LENGTH_CODES = 29; // 4014
/* number of length codes, not counting the special END_BLOCK code */ // 4015
var LITERALS = 256; // 4016
/* number of literal bytes 0..255 */ // 4017
var L_CODES = LITERALS + 1 + LENGTH_CODES; // 4018
/* number of Literal or Length codes, including the END_BLOCK code */ // 4019
var D_CODES = 30; // 4020
/* number of distance codes */ // 4021
var BL_CODES = 19; // 4022
/* number of codes used to transfer the bit lengths */ // 4023
var HEAP_SIZE = 2*L_CODES + 1; // 4024
/* maximum heap size */ // 4025
var MAX_BITS = 15; // 4026
/* All codes must not exceed MAX_BITS bits */ // 4027
// 4028
var MIN_MATCH = 3; // 4029
var MAX_MATCH = 258; // 4030
var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1); // 4031
// 4032
var PRESET_DICT = 0x20; // 4033
// 4034
var INIT_STATE = 42; // 4035
var EXTRA_STATE = 69; // 4036
var NAME_STATE = 73; // 4037
var COMMENT_STATE = 91; // 4038
var HCRC_STATE = 103; // 4039
var BUSY_STATE = 113; // 4040
var FINISH_STATE = 666; // 4041
// 4042
var BS_NEED_MORE = 1; /* block not completed, need more input or more output */ // 4043
var BS_BLOCK_DONE = 2; /* block flush performed */ // 4044
var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */ // 4045
var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */ // 4046
// 4047
var OS_CODE = 0x03; // Unix :) . Don't detect, use this default. // 4048
// 4049
function err(strm, errorCode) { // 4050
strm.msg = msg[errorCode]; // 4051
return errorCode; // 4052
} // 4053
// 4054
function rank(f) { // 4055
return ((f) << 1) - ((f) > 4 ? 9 : 0); // 4056
} // 4057
// 4058
function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } // 4059
// 4060
// 4061
/* ========================================================================= // 4062
* Flush as much pending output as possible. All deflate() output goes // 4063
* through this function so some applications may wish to modify it // 4064
* to avoid allocating a large strm->output buffer and copying into it. // 4065
* (See also read_buf()). // 4066
*/ // 4067
function flush_pending(strm) { // 4068
var s = strm.state; // 4069
// 4070
//_tr_flush_bits(s); // 4071
var len = s.pending; // 4072
if (len > strm.avail_out) { // 4073
len = strm.avail_out; // 4074
} // 4075
if (len === 0) { return; } // 4076
// 4077
utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); // 4078
strm.next_out += len; // 4079
s.pending_out += len; // 4080
strm.total_out += len; // 4081
strm.avail_out -= len; // 4082
s.pending -= len; // 4083
if (s.pending === 0) { // 4084
s.pending_out = 0; // 4085
} // 4086
} // 4087
// 4088
// 4089
function flush_block_only (s, last) { // 4090
trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last); // 4091
s.block_start = s.strstart; // 4092
flush_pending(s.strm); // 4093
} // 4094
// 4095
// 4096
function put_byte(s, b) { // 4097
s.pending_buf[s.pending++] = b; // 4098
} // 4099
// 4100
// 4101
/* ========================================================================= // 4102
* Put a short in the pending buffer. The 16-bit value is put in MSB order. // 4103
* IN assertion: the stream state is correct and there is enough room in // 4104
* pending_buf. // 4105
*/ // 4106
function putShortMSB(s, b) { // 4107
// put_byte(s, (Byte)(b >> 8)); // 4108
// put_byte(s, (Byte)(b & 0xff)); // 4109
s.pending_buf[s.pending++] = (b >>> 8) & 0xff; // 4110
s.pending_buf[s.pending++] = b & 0xff; // 4111
} // 4112
// 4113
// 4114
/* =========================================================================== // 4115
* Read a new buffer from the current input stream, update the adler32 // 4116
* and total number of bytes read. All deflate() input goes through // 4117
* this function so some applications may wish to modify it to avoid // 4118
* allocating a large strm->input buffer and copying from it. // 4119
* (See also flush_pending()). // 4120
*/ // 4121
function read_buf(strm, buf, start, size) { // 4122
var len = strm.avail_in; // 4123
// 4124
if (len > size) { len = size; } // 4125
if (len === 0) { return 0; } // 4126
// 4127
strm.avail_in -= len; // 4128
// 4129
utils.arraySet(buf, strm.input, strm.next_in, len, start); // 4130
if (strm.state.wrap === 1) { // 4131
strm.adler = adler32(strm.adler, buf, len, start); // 4132
} // 4133
// 4134
else if (strm.state.wrap === 2) { // 4135
strm.adler = crc32(strm.adler, buf, len, start); // 4136
} // 4137
// 4138
strm.next_in += len; // 4139
strm.total_in += len; // 4140
// 4141
return len; // 4142
} // 4143
// 4144
// 4145
/* =========================================================================== // 4146
* Set match_start to the longest match starting at the given string and // 4147
* return its length. Matches shorter or equal to prev_length are discarded, // 4148
* in which case the result is equal to prev_length and match_start is // 4149
* garbage. // 4150
* IN assertions: cur_match is the head of the hash chain for the current // 4151
* string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 // 4152
* OUT assertion: the match length is not greater than s->lookahead. // 4153
*/ // 4154
function longest_match(s, cur_match) { // 4155
var chain_length = s.max_chain_length; /* max hash chain length */ // 4156
var scan = s.strstart; /* current string */ // 4157
var match; /* matched string */ // 4158
var len; /* length of current match */ // 4159
var best_len = s.prev_length; /* best match length so far */ // 4160
var nice_match = s.nice_match; /* stop if match long enough */ // 4161
var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ? // 4162
s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/; // 4163
// 4164
var _win = s.window; // shortcut // 4165
// 4166
var wmask = s.w_mask; // 4167
var prev = s.prev; // 4168
// 4169
/* Stop when cur_match becomes <= limit. To simplify the code, // 4170
* we prevent matches with the string of window index 0. // 4171
*/ // 4172
// 4173
var strend = s.strstart + MAX_MATCH; // 4174
var scan_end1 = _win[scan + best_len - 1]; // 4175
var scan_end = _win[scan + best_len]; // 4176
// 4177
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. // 4178
* It is easy to get rid of this optimization if necessary. // 4179
*/ // 4180
// Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); // 4181
// 4182
/* Do not waste too much time if we already have a good match: */ // 4183
if (s.prev_length >= s.good_match) { // 4184
chain_length >>= 2; // 4185
} // 4186
/* Do not look for matches beyond the end of the input. This is necessary // 4187
* to make deflate deterministic. // 4188
*/ // 4189
if (nice_match > s.lookahead) { nice_match = s.lookahead; } // 4190
// 4191
// Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); // 4192
// 4193
do { // 4194
// Assert(cur_match < s->strstart, "no future"); // 4195
match = cur_match; // 4196
// 4197
/* Skip to next match if the match length cannot increase // 4198
* or if the match length is less than 2. Note that the checks below // 4199
* for insufficient lookahead only occur occasionally for performance // 4200
* reasons. Therefore uninitialized memory will be accessed, and // 4201
* conditional jumps will be made that depend on those values. // 4202
* However the length of the match is limited to the lookahead, so // 4203
* the output of deflate is not affected by the uninitialized values. // 4204
*/ // 4205
// 4206
if (_win[match + best_len] !== scan_end || // 4207
_win[match + best_len - 1] !== scan_end1 || // 4208
_win[match] !== _win[scan] || // 4209
_win[++match] !== _win[scan + 1]) { // 4210
continue; // 4211
} // 4212
// 4213
/* The check at best_len-1 can be removed because it will be made // 4214
* again later. (This heuristic is not always a win.) // 4215
* It is not necessary to compare scan[2] and match[2] since they // 4216
* are always equal when the other bytes match, given that // 4217
* the hash keys are equal and that HASH_BITS >= 8. // 4218
*/ // 4219
scan += 2; // 4220
match++; // 4221
// Assert(*scan == *match, "match[2]?"); // 4222
// 4223
/* We check for insufficient lookahead only every 8th comparison; // 4224
* the 256th check will be made at strstart+258. // 4225
*/ // 4226
do { // 4227
/*jshint noempty:false*/ // 4228
} while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && // 4229
_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && // 4230
_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && // 4231
_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && // 4232
scan < strend); // 4233
// 4234
// Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); // 4235
// 4236
len = MAX_MATCH - (strend - scan); // 4237
scan = strend - MAX_MATCH; // 4238
// 4239
if (len > best_len) { // 4240
s.match_start = cur_match; // 4241
best_len = len; // 4242
if (len >= nice_match) { // 4243
break; // 4244
} // 4245
scan_end1 = _win[scan + best_len - 1]; // 4246
scan_end = _win[scan + best_len]; // 4247
} // 4248
} while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); // 4249
// 4250
if (best_len <= s.lookahead) { // 4251
return best_len; // 4252
} // 4253
return s.lookahead; // 4254
} // 4255
// 4256
// 4257
/* =========================================================================== // 4258
* Fill the window when the lookahead becomes insufficient. // 4259
* Updates strstart and lookahead. // 4260
* // 4261
* IN assertion: lookahead < MIN_LOOKAHEAD // 4262
* OUT assertions: strstart <= window_size-MIN_LOOKAHEAD // 4263
* At least one byte has been read, or avail_in == 0; reads are // 4264
* performed for at least two bytes (required for the zip translate_eol // 4265
* option -- not supported here). // 4266
*/ // 4267
function fill_window(s) { // 4268
var _w_size = s.w_size; // 4269
var p, n, m, more, str; // 4270
// 4271
//Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); // 4272
// 4273
do { // 4274
more = s.window_size - s.lookahead - s.strstart; // 4275
// 4276
// JS ints have 32 bit, block below not needed // 4277
/* Deal with !@#$% 64K limit: */ // 4278
//if (sizeof(int) <= 2) { // 4279
// if (more == 0 && s->strstart == 0 && s->lookahead == 0) { // 4280
// more = wsize; // 4281
// // 4282
// } else if (more == (unsigned)(-1)) { // 4283
// /* Very unlikely, but possible on 16 bit machine if // 4284
// * strstart == 0 && lookahead == 1 (input done a byte at time) // 4285
// */ // 4286
// more--; // 4287
// } // 4288
//} // 4289
// 4290
// 4291
/* If the window is almost full and there is insufficient lookahead, // 4292
* move the upper half to the lower one to make room in the upper half. // 4293
*/ // 4294
if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { // 4295
// 4296
utils.arraySet(s.window, s.window, _w_size, _w_size, 0); // 4297
s.match_start -= _w_size; // 4298
s.strstart -= _w_size; // 4299
/* we now have strstart >= MAX_DIST */ // 4300
s.block_start -= _w_size; // 4301
// 4302
/* Slide the hash table (could be avoided with 32 bit values // 4303
at the expense of memory usage). We slide even when level == 0 // 4304
to keep the hash table consistent if we switch back to level > 0 // 4305
later. (Using level 0 permanently is not an optimal usage of // 4306
zlib, so we don't care about this pathological case.) // 4307
*/ // 4308
// 4309
n = s.hash_size; // 4310
p = n; // 4311
do { // 4312
m = s.head[--p]; // 4313
s.head[p] = (m >= _w_size ? m - _w_size : 0); // 4314
} while (--n); // 4315
// 4316
n = _w_size; // 4317
p = n; // 4318
do { // 4319
m = s.prev[--p]; // 4320
s.prev[p] = (m >= _w_size ? m - _w_size : 0); // 4321
/* If n is not on any hash chain, prev[n] is garbage but // 4322
* its value will never be used. // 4323
*/ // 4324
} while (--n); // 4325
// 4326
more += _w_size; // 4327
} // 4328
if (s.strm.avail_in === 0) { // 4329
break; // 4330
} // 4331
// 4332
/* If there was no sliding: // 4333
* strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && // 4334
* more == window_size - lookahead - strstart // 4335
* => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) // 4336
* => more >= window_size - 2*WSIZE + 2 // 4337
* In the BIG_MEM or MMAP case (not yet supported), // 4338
* window_size == input_size + MIN_LOOKAHEAD && // 4339
* strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. // 4340
* Otherwise, window_size == 2*WSIZE so more >= 2. // 4341
* If there was sliding, more >= WSIZE. So in all cases, more >= 2. // 4342
*/ // 4343
//Assert(more >= 2, "more < 2"); // 4344
n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); // 4345
s.lookahead += n; // 4346
// 4347
/* Initialize the hash value now that we have some input: */ // 4348
if (s.lookahead + s.insert >= MIN_MATCH) { // 4349
str = s.strstart - s.insert; // 4350
s.ins_h = s.window[str]; // 4351
// 4352
/* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */ // 4353
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask; // 4354
//#if MIN_MATCH != 3 // 4355
// Call update_hash() MIN_MATCH-3 more times // 4356
//#endif // 4357
while (s.insert) { // 4358
/* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ // 4359
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH-1]) & s.hash_mask; // 4360
// 4361
s.prev[str & s.w_mask] = s.head[s.ins_h]; // 4362
s.head[s.ins_h] = str; // 4363
str++; // 4364
s.insert--; // 4365
if (s.lookahead + s.insert < MIN_MATCH) { // 4366
break; // 4367
} // 4368
} // 4369
} // 4370
/* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, // 4371
* but this is not important since only literal bytes will be emitted. // 4372
*/ // 4373
// 4374
} while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); // 4375
// 4376
/* If the WIN_INIT bytes after the end of the current data have never been // 4377
* written, then zero those bytes in order to avoid memory check reports of // 4378
* the use of uninitialized (or uninitialised as Julian writes) bytes by // 4379
* the longest match routines. Update the high water mark for the next // 4380
* time through here. WIN_INIT is set to MAX_MATCH since the longest match // 4381
* routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. // 4382
*/ // 4383
// if (s.high_water < s.window_size) { // 4384
// var curr = s.strstart + s.lookahead; // 4385
// var init = 0; // 4386
// // 4387
// if (s.high_water < curr) { // 4388
// /* Previous high water mark below current data -- zero WIN_INIT // 4389
// * bytes or up to end of window, whichever is less. // 4390
// */ // 4391
// init = s.window_size - curr; // 4392
// if (init > WIN_INIT) // 4393
// init = WIN_INIT; // 4394
// zmemzero(s->window + curr, (unsigned)init); // 4395
// s->high_water = curr + init; // 4396
// } // 4397
// else if (s->high_water < (ulg)curr + WIN_INIT) { // 4398
// /* High water mark at or above current data, but below current data // 4399
// * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up // 4400
// * to end of window, whichever is less. // 4401
// */ // 4402
// init = (ulg)curr + WIN_INIT - s->high_water; // 4403
// if (init > s->window_size - s->high_water) // 4404
// init = s->window_size - s->high_water; // 4405
// zmemzero(s->window + s->high_water, (unsigned)init); // 4406
// s->high_water += init; // 4407
// } // 4408
// } // 4409
// // 4410
// Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, // 4411
// "not enough room for search"); // 4412
} // 4413
// 4414
/* =========================================================================== // 4415
* Copy without compression as much as possible from the input stream, return // 4416
* the current block state. // 4417
* This function does not insert new strings in the dictionary since // 4418
* uncompressible data is probably not useful. This function is used // 4419
* only for the level=0 compression option. // 4420
* NOTE: this function should be optimized to avoid extra copying from // 4421
* window to pending_buf. // 4422
*/ // 4423
function deflate_stored(s, flush) { // 4424
/* Stored blocks are limited to 0xffff bytes, pending_buf is limited // 4425
* to pending_buf_size, and each stored block has a 5 byte header: // 4426
*/ // 4427
var max_block_size = 0xffff; // 4428
// 4429
if (max_block_size > s.pending_buf_size - 5) { // 4430
max_block_size = s.pending_buf_size - 5; // 4431
} // 4432
// 4433
/* Copy as much as possible from input to output: */ // 4434
for (;;) { // 4435
/* Fill the window as much as possible: */ // 4436
if (s.lookahead <= 1) { // 4437
// 4438
//Assert(s->strstart < s->w_size+MAX_DIST(s) || // 4439
// s->block_start >= (long)s->w_size, "slide too late"); // 4440
// if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) || // 4441
// s.block_start >= s.w_size)) { // 4442
// throw new Error("slide too late"); // 4443
// } // 4444
// 4445
fill_window(s); // 4446
if (s.lookahead === 0 && flush === Z_NO_FLUSH) { // 4447
return BS_NEED_MORE; // 4448
} // 4449
// 4450
if (s.lookahead === 0) { // 4451
break; // 4452
} // 4453
/* flush the current block */ // 4454
} // 4455
//Assert(s->block_start >= 0L, "block gone"); // 4456
// if (s.block_start < 0) throw new Error("block gone"); // 4457
// 4458
s.strstart += s.lookahead; // 4459
s.lookahead = 0; // 4460
// 4461
/* Emit a stored block if pending_buf will be full: */ // 4462
var max_start = s.block_start + max_block_size; // 4463
// 4464
if (s.strstart === 0 || s.strstart >= max_start) { // 4465
/* strstart == 0 is possible when wraparound on 16-bit machine */ // 4466
s.lookahead = s.strstart - max_start; // 4467
s.strstart = max_start; // 4468
/*** FLUSH_BLOCK(s, 0); ***/ // 4469
flush_block_only(s, false); // 4470
if (s.strm.avail_out === 0) { // 4471
return BS_NEED_MORE; // 4472
} // 4473
/***/ // 4474
// 4475
// 4476
} // 4477
/* Flush if we may have to slide, otherwise block_start may become // 4478
* negative and the data will be gone: // 4479
*/ // 4480
if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) { // 4481
/*** FLUSH_BLOCK(s, 0); ***/ // 4482
flush_block_only(s, false); // 4483
if (s.strm.avail_out === 0) { // 4484
return BS_NEED_MORE; // 4485
} // 4486
/***/ // 4487
} // 4488
} // 4489
// 4490
s.insert = 0; // 4491
// 4492
if (flush === Z_FINISH) { // 4493
/*** FLUSH_BLOCK(s, 1); ***/ // 4494
flush_block_only(s, true); // 4495
if (s.strm.avail_out === 0) { // 4496
return BS_FINISH_STARTED; // 4497
} // 4498
/***/ // 4499
return BS_FINISH_DONE; // 4500
} // 4501
// 4502
if (s.strstart > s.block_start) { // 4503
/*** FLUSH_BLOCK(s, 0); ***/ // 4504
flush_block_only(s, false); // 4505
if (s.strm.avail_out === 0) { // 4506
return BS_NEED_MORE; // 4507
} // 4508
/***/ // 4509
} // 4510
// 4511
return BS_NEED_MORE; // 4512
} // 4513
// 4514
/* =========================================================================== // 4515
* Compress as much as possible from the input stream, return the current // 4516
* block state. // 4517
* This function does not perform lazy evaluation of matches and inserts // 4518
* new strings in the dictionary only for unmatched strings or for short // 4519
* matches. It is used only for the fast compression options. // 4520
*/ // 4521
function deflate_fast(s, flush) { // 4522
var hash_head; /* head of the hash chain */ // 4523
var bflush; /* set if current block must be flushed */ // 4524
// 4525
for (;;) { // 4526
/* Make sure that we always have enough lookahead, except // 4527
* at the end of the input file. We need MAX_MATCH bytes // 4528
* for the next match, plus MIN_MATCH bytes to insert the // 4529
* string following the next match. // 4530
*/ // 4531
if (s.lookahead < MIN_LOOKAHEAD) { // 4532
fill_window(s); // 4533
if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { // 4534
return BS_NEED_MORE; // 4535
} // 4536
if (s.lookahead === 0) { // 4537
break; /* flush the current block */ // 4538
} // 4539
} // 4540
// 4541
/* Insert the string window[strstart .. strstart+2] in the // 4542
* dictionary, and set hash_head to the head of the hash chain: // 4543
*/ // 4544
hash_head = 0/*NIL*/; // 4545
if (s.lookahead >= MIN_MATCH) { // 4546
/*** INSERT_STRING(s, s.strstart, hash_head); ***/ // 4547
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; // 4548
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; // 4549
s.head[s.ins_h] = s.strstart; // 4550
/***/ // 4551
} // 4552
// 4553
/* Find the longest match, discarding those <= prev_length. // 4554
* At this point we have always match_length < MIN_MATCH // 4555
*/ // 4556
if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) { // 4557
/* To simplify the code, we prevent matches with the string // 4558
* of window index 0 (in particular we have to avoid a match // 4559
* of the string with itself at the start of the input file). // 4560
*/ // 4561
s.match_length = longest_match(s, hash_head); // 4562
/* longest_match() sets match_start */ // 4563
} // 4564
if (s.match_length >= MIN_MATCH) { // 4565
// check_match(s, s.strstart, s.match_start, s.match_length); // for debug only // 4566
// 4567
/*** _tr_tally_dist(s, s.strstart - s.match_start, // 4568
s.match_length - MIN_MATCH, bflush); ***/ // 4569
bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); // 4570
// 4571
s.lookahead -= s.match_length; // 4572
// 4573
/* Insert new strings in the hash table only if the match length // 4574
* is not too large. This saves time but degrades compression. // 4575
*/ // 4576
if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) { // 4577
s.match_length--; /* string at strstart already in table */ // 4578
do { // 4579
s.strstart++; // 4580
/*** INSERT_STRING(s, s.strstart, hash_head); ***/ // 4581
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; // 4582
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; // 4583
s.head[s.ins_h] = s.strstart; // 4584
/***/ // 4585
/* strstart never exceeds WSIZE-MAX_MATCH, so there are // 4586
* always MIN_MATCH bytes ahead. // 4587
*/ // 4588
} while (--s.match_length !== 0); // 4589
s.strstart++; // 4590
} else // 4591
{ // 4592
s.strstart += s.match_length; // 4593
s.match_length = 0; // 4594
s.ins_h = s.window[s.strstart]; // 4595
/* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */ // 4596
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask; // 4597
// 4598
//#if MIN_MATCH != 3 // 4599
// Call UPDATE_HASH() MIN_MATCH-3 more times // 4600
//#endif // 4601
/* If lookahead < MIN_MATCH, ins_h is garbage, but it does not // 4602
* matter since it will be recomputed at next deflate call. // 4603
*/ // 4604
} // 4605
} else { // 4606
/* No match, output a literal byte */ // 4607
//Tracevv((stderr,"%c", s.window[s.strstart])); // 4608
/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ // 4609
bflush = trees._tr_tally(s, 0, s.window[s.strstart]); // 4610
// 4611
s.lookahead--; // 4612
s.strstart++; // 4613
} // 4614
if (bflush) { // 4615
/*** FLUSH_BLOCK(s, 0); ***/ // 4616
flush_block_only(s, false); // 4617
if (s.strm.avail_out === 0) { // 4618
return BS_NEED_MORE; // 4619
} // 4620
/***/ // 4621
} // 4622
} // 4623
s.insert = ((s.strstart < (MIN_MATCH-1)) ? s.strstart : MIN_MATCH-1); // 4624
if (flush === Z_FINISH) { // 4625
/*** FLUSH_BLOCK(s, 1); ***/ // 4626
flush_block_only(s, true); // 4627
if (s.strm.avail_out === 0) { // 4628
return BS_FINISH_STARTED; // 4629
} // 4630
/***/ // 4631
return BS_FINISH_DONE; // 4632
} // 4633
if (s.last_lit) { // 4634
/*** FLUSH_BLOCK(s, 0); ***/ // 4635
flush_block_only(s, false); // 4636
if (s.strm.avail_out === 0) { // 4637
return BS_NEED_MORE; // 4638
} // 4639
/***/ // 4640
} // 4641
return BS_BLOCK_DONE; // 4642
} // 4643
// 4644
/* =========================================================================== // 4645
* Same as above, but achieves better compression. We use a lazy // 4646
* evaluation for matches: a match is finally adopted only if there is // 4647
* no better match at the next window position. // 4648
*/ // 4649
function deflate_slow(s, flush) { // 4650
var hash_head; /* head of hash chain */ // 4651
var bflush; /* set if current block must be flushed */ // 4652
// 4653
var max_insert; // 4654
// 4655
/* Process the input block. */ // 4656
for (;;) { // 4657
/* Make sure that we always have enough lookahead, except // 4658
* at the end of the input file. We need MAX_MATCH bytes // 4659
* for the next match, plus MIN_MATCH bytes to insert the // 4660
* string following the next match. // 4661
*/ // 4662
if (s.lookahead < MIN_LOOKAHEAD) { // 4663
fill_window(s); // 4664
if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { // 4665
return BS_NEED_MORE; // 4666
} // 4667
if (s.lookahead === 0) { break; } /* flush the current block */ // 4668
} // 4669
// 4670
/* Insert the string window[strstart .. strstart+2] in the // 4671
* dictionary, and set hash_head to the head of the hash chain: // 4672
*/ // 4673
hash_head = 0/*NIL*/; // 4674
if (s.lookahead >= MIN_MATCH) { // 4675
/*** INSERT_STRING(s, s.strstart, hash_head); ***/ // 4676
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; // 4677
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; // 4678
s.head[s.ins_h] = s.strstart; // 4679
/***/ // 4680
} // 4681
// 4682
/* Find the longest match, discarding those <= prev_length. // 4683
*/ // 4684
s.prev_length = s.match_length; // 4685
s.prev_match = s.match_start; // 4686
s.match_length = MIN_MATCH-1; // 4687
// 4688
if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match && // 4689
s.strstart - hash_head <= (s.w_size-MIN_LOOKAHEAD)/*MAX_DIST(s)*/) { // 4690
/* To simplify the code, we prevent matches with the string // 4691
* of window index 0 (in particular we have to avoid a match // 4692
* of the string with itself at the start of the input file). // 4693
*/ // 4694
s.match_length = longest_match(s, hash_head); // 4695
/* longest_match() sets match_start */ // 4696
// 4697
if (s.match_length <= 5 && // 4698
(s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
// 4700
/* If prev_match is also MIN_MATCH, match_start is garbage // 4701
* but we will ignore the current match anyway. // 4702
*/ // 4703
s.match_length = MIN_MATCH-1; // 4704
} // 4705
} // 4706
/* If there was a match at the previous step and the current // 4707
* match is not better, output the previous match: // 4708
*/ // 4709
if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { // 4710
max_insert = s.strstart + s.lookahead - MIN_MATCH; // 4711
/* Do not insert strings in hash table beyond this. */ // 4712
// 4713
//check_match(s, s.strstart-1, s.prev_match, s.prev_length); // 4714
// 4715
/***_tr_tally_dist(s, s.strstart - 1 - s.prev_match, // 4716
s.prev_length - MIN_MATCH, bflush);***/ // 4717
bflush = trees._tr_tally(s, s.strstart - 1- s.prev_match, s.prev_length - MIN_MATCH); // 4718
/* Insert in hash table all strings up to the end of the match. // 4719
* strstart-1 and strstart are already inserted. If there is not // 4720
* enough lookahead, the last two strings are not inserted in // 4721
* the hash table. // 4722
*/ // 4723
s.lookahead -= s.prev_length-1; // 4724
s.prev_length -= 2; // 4725
do { // 4726
if (++s.strstart <= max_insert) { // 4727
/*** INSERT_STRING(s, s.strstart, hash_head); ***/ // 4728
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; // 4729
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; // 4730
s.head[s.ins_h] = s.strstart; // 4731
/***/ // 4732
} // 4733
} while (--s.prev_length !== 0); // 4734
s.match_available = 0; // 4735
s.match_length = MIN_MATCH-1; // 4736
s.strstart++; // 4737
// 4738
if (bflush) { // 4739
/*** FLUSH_BLOCK(s, 0); ***/ // 4740
flush_block_only(s, false); // 4741
if (s.strm.avail_out === 0) { // 4742
return BS_NEED_MORE; // 4743
} // 4744
/***/ // 4745
} // 4746
// 4747
} else if (s.match_available) { // 4748
/* If there was no match at the previous position, output a // 4749
* single literal. If there was a match but the current match // 4750
* is longer, truncate the previous match to a single literal. // 4751
*/ // 4752
//Tracevv((stderr,"%c", s->window[s->strstart-1])); // 4753
/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ // 4754
bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]); // 4755
// 4756
if (bflush) { // 4757
/*** FLUSH_BLOCK_ONLY(s, 0) ***/ // 4758
flush_block_only(s, false); // 4759
/***/ // 4760
} // 4761
s.strstart++; // 4762
s.lookahead--; // 4763
if (s.strm.avail_out === 0) { // 4764
return BS_NEED_MORE; // 4765
} // 4766
} else { // 4767
/* There is no previous match to compare with, wait for // 4768
* the next step to decide. // 4769
*/ // 4770
s.match_available = 1; // 4771
s.strstart++; // 4772
s.lookahead--; // 4773
} // 4774
} // 4775
//Assert (flush != Z_NO_FLUSH, "no flush?"); // 4776
if (s.match_available) { // 4777
//Tracevv((stderr,"%c", s->window[s->strstart-1])); // 4778
/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ // 4779
bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]); // 4780
// 4781
s.match_available = 0; // 4782
} // 4783
s.insert = s.strstart < MIN_MATCH-1 ? s.strstart : MIN_MATCH-1; // 4784
if (flush === Z_FINISH) { // 4785
/*** FLUSH_BLOCK(s, 1); ***/ // 4786
flush_block_only(s, true); // 4787
if (s.strm.avail_out === 0) { // 4788
return BS_FINISH_STARTED; // 4789
} // 4790
/***/ // 4791
return BS_FINISH_DONE; // 4792
} // 4793
if (s.last_lit) { // 4794
/*** FLUSH_BLOCK(s, 0); ***/ // 4795
flush_block_only(s, false); // 4796
if (s.strm.avail_out === 0) { // 4797
return BS_NEED_MORE; // 4798
} // 4799
/***/ // 4800
} // 4801
// 4802
return BS_BLOCK_DONE; // 4803
} // 4804
// 4805
// 4806
/* =========================================================================== // 4807
* For Z_RLE, simply look for runs of bytes, generate matches only of distance // 4808
* one. Do not maintain a hash table. (It will be regenerated if this run of // 4809
* deflate switches away from Z_RLE.) // 4810
*/ // 4811
function deflate_rle(s, flush) { // 4812
var bflush; /* set if current block must be flushed */ // 4813
var prev; /* byte at distance one to match */ // 4814
var scan, strend; /* scan goes up to strend for length of run */ // 4815
// 4816
var _win = s.window; // 4817
// 4818
for (;;) { // 4819
/* Make sure that we always have enough lookahead, except // 4820
* at the end of the input file. We need MAX_MATCH bytes // 4821
* for the longest run, plus one for the unrolled loop. // 4822
*/ // 4823
if (s.lookahead <= MAX_MATCH) { // 4824
fill_window(s); // 4825
if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { // 4826
return BS_NEED_MORE; // 4827
} // 4828
if (s.lookahead === 0) { break; } /* flush the current block */ // 4829
} // 4830
// 4831
/* See how many times the previous byte repeats */ // 4832
s.match_length = 0; // 4833
if (s.lookahead >= MIN_MATCH && s.strstart > 0) { // 4834
scan = s.strstart - 1; // 4835
prev = _win[scan]; // 4836
if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { // 4837
strend = s.strstart + MAX_MATCH; // 4838
do { // 4839
/*jshint noempty:false*/ // 4840
} while (prev === _win[++scan] && prev === _win[++scan] && // 4841
prev === _win[++scan] && prev === _win[++scan] && // 4842
prev === _win[++scan] && prev === _win[++scan] && // 4843
prev === _win[++scan] && prev === _win[++scan] && // 4844
scan < strend); // 4845
s.match_length = MAX_MATCH - (strend - scan); // 4846
if (s.match_length > s.lookahead) { // 4847
s.match_length = s.lookahead; // 4848
} // 4849
} // 4850
//Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); // 4851
} // 4852
// 4853
/* Emit match if have run of MIN_MATCH or longer, else emit literal */ // 4854
if (s.match_length >= MIN_MATCH) { // 4855
//check_match(s, s.strstart, s.strstart - 1, s.match_length); // 4856
// 4857
/*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/ // 4858
bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); // 4859
// 4860
s.lookahead -= s.match_length; // 4861
s.strstart += s.match_length; // 4862
s.match_length = 0; // 4863
} else { // 4864
/* No match, output a literal byte */ // 4865
//Tracevv((stderr,"%c", s->window[s->strstart])); // 4866
/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ // 4867
bflush = trees._tr_tally(s, 0, s.window[s.strstart]); // 4868
// 4869
s.lookahead--; // 4870
s.strstart++; // 4871
} // 4872
if (bflush) { // 4873
/*** FLUSH_BLOCK(s, 0); ***/ // 4874
flush_block_only(s, false); // 4875
if (s.strm.avail_out === 0) { // 4876
return BS_NEED_MORE; // 4877
} // 4878
/***/ // 4879
} // 4880
} // 4881
s.insert = 0; // 4882
if (flush === Z_FINISH) { // 4883
/*** FLUSH_BLOCK(s, 1); ***/ // 4884
flush_block_only(s, true); // 4885
if (s.strm.avail_out === 0) { // 4886
return BS_FINISH_STARTED; // 4887
} // 4888
/***/ // 4889
return BS_FINISH_DONE; // 4890
} // 4891
if (s.last_lit) { // 4892
/*** FLUSH_BLOCK(s, 0); ***/ // 4893
flush_block_only(s, false); // 4894
if (s.strm.avail_out === 0) { // 4895
return BS_NEED_MORE; // 4896
} // 4897
/***/ // 4898
} // 4899
return BS_BLOCK_DONE; // 4900
} // 4901
// 4902
/* =========================================================================== // 4903
* For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. // 4904
* (It will be regenerated if this run of deflate switches away from Huffman.) // 4905
*/ // 4906
function deflate_huff(s, flush) { // 4907
var bflush; /* set if current block must be flushed */ // 4908
// 4909
for (;;) { // 4910
/* Make sure that we have a literal to write. */ // 4911
if (s.lookahead === 0) { // 4912
fill_window(s); // 4913
if (s.lookahead === 0) { // 4914
if (flush === Z_NO_FLUSH) { // 4915
return BS_NEED_MORE; // 4916
} // 4917
break; /* flush the current block */ // 4918
} // 4919
} // 4920
// 4921
/* Output a literal byte */ // 4922
s.match_length = 0; // 4923
//Tracevv((stderr,"%c", s->window[s->strstart])); // 4924
/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ // 4925
bflush = trees._tr_tally(s, 0, s.window[s.strstart]); // 4926
s.lookahead--; // 4927
s.strstart++; // 4928
if (bflush) { // 4929
/*** FLUSH_BLOCK(s, 0); ***/ // 4930
flush_block_only(s, false); // 4931
if (s.strm.avail_out === 0) { // 4932
return BS_NEED_MORE; // 4933
} // 4934
/***/ // 4935
} // 4936
} // 4937
s.insert = 0; // 4938
if (flush === Z_FINISH) { // 4939
/*** FLUSH_BLOCK(s, 1); ***/ // 4940
flush_block_only(s, true); // 4941
if (s.strm.avail_out === 0) { // 4942
return BS_FINISH_STARTED; // 4943
} // 4944
/***/ // 4945
return BS_FINISH_DONE; // 4946
} // 4947
if (s.last_lit) { // 4948
/*** FLUSH_BLOCK(s, 0); ***/ // 4949
flush_block_only(s, false); // 4950
if (s.strm.avail_out === 0) { // 4951
return BS_NEED_MORE; // 4952
} // 4953
/***/ // 4954
} // 4955
return BS_BLOCK_DONE; // 4956
} // 4957
// 4958
/* Values for max_lazy_match, good_match and max_chain_length, depending on // 4959
* the desired pack level (0..9). The values given below have been tuned to // 4960
* exclude worst case performance for pathological files. Better values may be // 4961
* found for specific files. // 4962
*/ // 4963
var Config = function (good_length, max_lazy, nice_length, max_chain, func) { // 4964
this.good_length = good_length; // 4965
this.max_lazy = max_lazy; // 4966
this.nice_length = nice_length; // 4967
this.max_chain = max_chain; // 4968
this.func = func; // 4969
}; // 4970
// 4971
var configuration_table; // 4972
// 4973
configuration_table = [ // 4974
/* good lazy nice chain */ // 4975
new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */ // 4976
new Config(4, 4, 8, 4, deflate_fast), /* 1 max speed, no lazy matches */ // 4977
new Config(4, 5, 16, 8, deflate_fast), /* 2 */ // 4978
new Config(4, 6, 32, 32, deflate_fast), /* 3 */ // 4979
// 4980
new Config(4, 4, 16, 16, deflate_slow), /* 4 lazy matches */ // 4981
new Config(8, 16, 32, 32, deflate_slow), /* 5 */ // 4982
new Config(8, 16, 128, 128, deflate_slow), /* 6 */ // 4983
new Config(8, 32, 128, 256, deflate_slow), /* 7 */ // 4984
new Config(32, 128, 258, 1024, deflate_slow), /* 8 */ // 4985
new Config(32, 258, 258, 4096, deflate_slow) /* 9 max compression */ // 4986
]; // 4987
// 4988
// 4989
/* =========================================================================== // 4990
* Initialize the "longest match" routines for a new zlib stream // 4991
*/ // 4992
function lm_init(s) { // 4993
s.window_size = 2 * s.w_size; // 4994
// 4995
/*** CLEAR_HASH(s); ***/ // 4996
zero(s.head); // Fill with NIL (= 0); // 4997
// 4998
/* Set the default configuration parameters: // 4999
*/ // 5000
s.max_lazy_match = configuration_table[s.level].max_lazy; // 5001
s.good_match = configuration_table[s.level].good_length; // 5002
s.nice_match = configuration_table[s.level].nice_length; // 5003
s.max_chain_length = configuration_table[s.level].max_chain; // 5004
// 5005
s.strstart = 0; // 5006
s.block_start = 0; // 5007
s.lookahead = 0; // 5008
s.insert = 0; // 5009
s.match_length = s.prev_length = MIN_MATCH - 1; // 5010
s.match_available = 0; // 5011
s.ins_h = 0; // 5012
} // 5013
// 5014
// 5015
function DeflateState() { // 5016
this.strm = null; /* pointer back to this zlib stream */ // 5017
this.status = 0; /* as the name implies */ // 5018
this.pending_buf = null; /* output still pending */ // 5019
this.pending_buf_size = 0; /* size of pending_buf */ // 5020
this.pending_out = 0; /* next pending byte to output to the stream */ // 5021
this.pending = 0; /* nb of bytes in the pending buffer */ // 5022
this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ // 5023
this.gzhead = null; /* gzip header information to write */ // 5024
this.gzindex = 0; /* where in extra, name, or comment */ // 5025
this.method = Z_DEFLATED; /* can only be DEFLATED */ // 5026
this.last_flush = -1; /* value of flush param for previous deflate call */ // 5027
// 5028
this.w_size = 0; /* LZ77 window size (32K by default) */ // 5029
this.w_bits = 0; /* log2(w_size) (8..16) */ // 5030
this.w_mask = 0; /* w_size - 1 */ // 5031
// 5032
this.window = null; // 5033
/* Sliding window. Input bytes are read into the second half of the window, // 5034
* and move to the first half later to keep a dictionary of at least wSize // 5035
* bytes. With this organization, matches are limited to a distance of // 5036
* wSize-MAX_MATCH bytes, but this ensures that IO is always // 5037
* performed with a length multiple of the block size. // 5038
*/ // 5039
// 5040
this.window_size = 0; // 5041
/* Actual size of window: 2*wSize, except when the user input buffer // 5042
* is directly used as sliding window. // 5043
*/ // 5044
// 5045
this.prev = null; // 5046
/* Link to older string with same hash index. To limit the size of this // 5047
* array to 64K, this link is maintained only for the last 32K strings. // 5048
* An index in this array is thus a window index modulo 32K. // 5049
*/ // 5050
// 5051
this.head = null; /* Heads of the hash chains or NIL. */ // 5052
// 5053
this.ins_h = 0; /* hash index of string to be inserted */ // 5054
this.hash_size = 0; /* number of elements in hash table */ // 5055
this.hash_bits = 0; /* log2(hash_size) */ // 5056
this.hash_mask = 0; /* hash_size-1 */ // 5057
// 5058
this.hash_shift = 0; // 5059
/* Number of bits by which ins_h must be shifted at each input // 5060
* step. It must be such that after MIN_MATCH steps, the oldest // 5061
* byte no longer takes part in the hash key, that is: // 5062
* hash_shift * MIN_MATCH >= hash_bits // 5063
*/ // 5064
// 5065
this.block_start = 0; // 5066
/* Window position at the beginning of the current output block. Gets // 5067
* negative when the window is moved backwards. // 5068
*/ // 5069
// 5070
this.match_length = 0; /* length of best match */ // 5071
this.prev_match = 0; /* previous match */ // 5072
this.match_available = 0; /* set if previous match exists */ // 5073
this.strstart = 0; /* start of string to insert */ // 5074
this.match_start = 0; /* start of matching string */ // 5075
this.lookahead = 0; /* number of valid bytes ahead in window */ // 5076
// 5077
this.prev_length = 0; // 5078
/* Length of the best match at previous step. Matches not greater than this // 5079
* are discarded. This is used in the lazy match evaluation. // 5080
*/ // 5081
// 5082
this.max_chain_length = 0; // 5083
/* To speed up deflation, hash chains are never searched beyond this // 5084
* length. A higher limit improves compression ratio but degrades the // 5085
* speed. // 5086
*/ // 5087
// 5088
this.max_lazy_match = 0; // 5089
/* Attempt to find a better match only when the current match is strictly // 5090
* smaller than this value. This mechanism is used only for compression // 5091
* levels >= 4. // 5092
*/ // 5093
// That's alias to max_lazy_match, don't use directly // 5094
//this.max_insert_length = 0; // 5095
/* Insert new strings in the hash table only if the match length is not // 5096
* greater than this length. This saves time but degrades compression. // 5097
* max_insert_length is used only for compression levels <= 3. // 5098
*/ // 5099
// 5100
this.level = 0; /* compression level (1..9) */ // 5101
this.strategy = 0; /* favor or force Huffman coding*/ // 5102
// 5103
this.good_match = 0; // 5104
/* Use a faster search when the previous match is longer than this */ // 5105
// 5106
this.nice_match = 0; /* Stop searching when current match exceeds this */ // 5107
// 5108
/* used by trees.c: */ // 5109
// 5110
/* Didn't use ct_data typedef below to suppress compiler warning */ // 5111
// 5112
// struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ // 5113
// struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ // 5114
// struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ // 5115
// 5116
// Use flat array of DOUBLE size, with interleaved fata, // 5117
// because JS does not support effective // 5118
this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); // 5119
this.dyn_dtree = new utils.Buf16((2*D_CODES+1) * 2); // 5120
this.bl_tree = new utils.Buf16((2*BL_CODES+1) * 2); // 5121
zero(this.dyn_ltree); // 5122
zero(this.dyn_dtree); // 5123
zero(this.bl_tree); // 5124
// 5125
this.l_desc = null; /* desc. for literal tree */ // 5126
this.d_desc = null; /* desc. for distance tree */ // 5127
this.bl_desc = null; /* desc. for bit length tree */ // 5128
// 5129
//ush bl_count[MAX_BITS+1]; // 5130
this.bl_count = new utils.Buf16(MAX_BITS+1); // 5131
/* number of codes at each bit length for an optimal tree */ // 5132
// 5133
//int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ // 5134
this.heap = new utils.Buf16(2*L_CODES+1); /* heap used to build the Huffman trees */ // 5135
zero(this.heap); // 5136
// 5137
this.heap_len = 0; /* number of elements in the heap */ // 5138
this.heap_max = 0; /* element of largest frequency */ // 5139
/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. // 5140
* The same heap array is used to build all trees. // 5141
*/ // 5142
// 5143
this.depth = new utils.Buf16(2*L_CODES+1); //uch depth[2*L_CODES+1]; // 5144
zero(this.depth); // 5145
/* Depth of each subtree used as tie breaker for trees of equal frequency // 5146
*/ // 5147
// 5148
this.l_buf = 0; /* buffer index for literals or lengths */ // 5149
// 5150
this.lit_bufsize = 0; // 5151
/* Size of match buffer for literals/lengths. There are 4 reasons for // 5152
* limiting lit_bufsize to 64K: // 5153
* - frequencies can be kept in 16 bit counters // 5154
* - if compression is not successful for the first block, all input // 5155
* data is still in the window so we can still emit a stored block even // 5156
* when input comes from standard input. (This can also be done for // 5157
* all blocks if lit_bufsize is not greater than 32K.) // 5158
* - if compression is not successful for a file smaller than 64K, we can // 5159
* even emit a stored file instead of a stored block (saving 5 bytes). // 5160
* This is applicable only for zip (not gzip or zlib). // 5161
* - creating new Huffman trees less frequently may not provide fast // 5162
* adaptation to changes in the input data statistics. (Take for // 5163
* example a binary file with poorly compressible code followed by // 5164
* a highly compressible string table.) Smaller buffer sizes give // 5165
* fast adaptation but have of course the overhead of transmitting // 5166
* trees more frequently. // 5167
* - I can't count above 4 // 5168
*/ // 5169
// 5170
this.last_lit = 0; /* running index in l_buf */ // 5171
// 5172
this.d_buf = 0; // 5173
/* Buffer index for distances. To simplify the code, d_buf and l_buf have // 5174
* the same number of elements. To use different lengths, an extra flag // 5175
* array would be necessary. // 5176
*/ // 5177
// 5178
this.opt_len = 0; /* bit length of current block with optimal trees */ // 5179
this.static_len = 0; /* bit length of current block with static trees */ // 5180
this.matches = 0; /* number of string matches in current block */ // 5181
this.insert = 0; /* bytes at end of window left to insert */ // 5182
// 5183
// 5184
this.bi_buf = 0; // 5185
/* Output buffer. bits are inserted starting at the bottom (least // 5186
* significant bits). // 5187
*/ // 5188
this.bi_valid = 0; // 5189
/* Number of valid bits in bi_buf. All bits above the last valid bit // 5190
* are always zero. // 5191
*/ // 5192
// 5193
// Used for window memory init. We safely ignore it for JS. That makes // 5194
// sense only for pointers and memory check tools. // 5195
//this.high_water = 0; // 5196
/* High water mark offset in window for initialized bytes -- bytes above // 5197
* this are set to zero in order to avoid memory check warnings when // 5198
* longest match routines access bytes past the input. This is then // 5199
* updated to the new high water mark. // 5200
*/ // 5201
} // 5202
// 5203
// 5204
function deflateResetKeep(strm) { // 5205
var s; // 5206
// 5207
if (!strm || !strm.state) { // 5208
return err(strm, Z_STREAM_ERROR); // 5209
} // 5210
// 5211
strm.total_in = strm.total_out = 0; // 5212
strm.data_type = Z_UNKNOWN; // 5213
// 5214
s = strm.state; // 5215
s.pending = 0; // 5216
s.pending_out = 0; // 5217
// 5218
if (s.wrap < 0) { // 5219
s.wrap = -s.wrap; // 5220
/* was made negative by deflate(..., Z_FINISH); */ // 5221
} // 5222
s.status = (s.wrap ? INIT_STATE : BUSY_STATE); // 5223
strm.adler = (s.wrap === 2) ? // 5224
0 // crc32(0, Z_NULL, 0) // 5225
: // 5226
1; // adler32(0, Z_NULL, 0) // 5227
s.last_flush = Z_NO_FLUSH; // 5228
trees._tr_init(s); // 5229
return Z_OK; // 5230
} // 5231
// 5232
// 5233
function deflateReset(strm) { // 5234
var ret = deflateResetKeep(strm); // 5235
if (ret === Z_OK) { // 5236
lm_init(strm.state); // 5237
} // 5238
return ret; // 5239
} // 5240
// 5241
// 5242
function deflateSetHeader(strm, head) { // 5243
if (!strm || !strm.state) { return Z_STREAM_ERROR; } // 5244
if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; } // 5245
strm.state.gzhead = head; // 5246
return Z_OK; // 5247
} // 5248
// 5249
// 5250
function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { // 5251
if (!strm) { // === Z_NULL // 5252
return Z_STREAM_ERROR; // 5253
} // 5254
var wrap = 1; // 5255
// 5256
if (level === Z_DEFAULT_COMPRESSION) { // 5257
level = 6; // 5258
} // 5259
// 5260
if (windowBits < 0) { /* suppress zlib wrapper */ // 5261
wrap = 0; // 5262
windowBits = -windowBits; // 5263
} // 5264
// 5265
else if (windowBits > 15) { // 5266
wrap = 2; /* write gzip wrapper instead */ // 5267
windowBits -= 16; // 5268
} // 5269
// 5270
// 5271
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || // 5272
windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || // 5273
strategy < 0 || strategy > Z_FIXED) { // 5274
return err(strm, Z_STREAM_ERROR); // 5275
} // 5276
// 5277
// 5278
if (windowBits === 8) { // 5279
windowBits = 9; // 5280
} // 5281
/* until 256-byte window bug fixed */ // 5282
// 5283
var s = new DeflateState(); // 5284
// 5285
strm.state = s; // 5286
s.strm = strm; // 5287
// 5288
s.wrap = wrap; // 5289
s.gzhead = null; // 5290
s.w_bits = windowBits; // 5291
s.w_size = 1 << s.w_bits; // 5292
s.w_mask = s.w_size - 1; // 5293
// 5294
s.hash_bits = memLevel + 7; // 5295
s.hash_size = 1 << s.hash_bits; // 5296
s.hash_mask = s.hash_size - 1; // 5297
s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); // 5298
// 5299
s.window = new utils.Buf8(s.w_size * 2); // 5300
s.head = new utils.Buf16(s.hash_size); // 5301
s.prev = new utils.Buf16(s.w_size); // 5302
// 5303
// Don't need mem init magic for JS. // 5304
//s.high_water = 0; /* nothing written to s->window yet */ // 5305
// 5306
s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ // 5307
// 5308
s.pending_buf_size = s.lit_bufsize * 4; // 5309
s.pending_buf = new utils.Buf8(s.pending_buf_size); // 5310
// 5311
s.d_buf = s.lit_bufsize >> 1; // 5312
s.l_buf = (1 + 2) * s.lit_bufsize; // 5313
// 5314
s.level = level; // 5315
s.strategy = strategy; // 5316
s.method = method; // 5317
// 5318
return deflateReset(strm); // 5319
} // 5320
// 5321
function deflateInit(strm, level) { // 5322
return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); // 5323
} // 5324
// 5325
// 5326
function deflate(strm, flush) { // 5327
var old_flush, s; // 5328
var beg, val; // for gzip header write only // 5329
// 5330
if (!strm || !strm.state || // 5331
flush > Z_BLOCK || flush < 0) { // 5332
return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; // 5333
} // 5334
// 5335
s = strm.state; // 5336
// 5337
if (!strm.output || // 5338
(!strm.input && strm.avail_in !== 0) || // 5339
(s.status === FINISH_STATE && flush !== Z_FINISH)) { // 5340
return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR); // 5341
} // 5342
// 5343
s.strm = strm; /* just in case */ // 5344
old_flush = s.last_flush; // 5345
s.last_flush = flush; // 5346
// 5347
/* Write the header */ // 5348
if (s.status === INIT_STATE) { // 5349
// 5350
if (s.wrap === 2) { // GZIP header // 5351
strm.adler = 0; //crc32(0L, Z_NULL, 0); // 5352
put_byte(s, 31); // 5353
put_byte(s, 139); // 5354
put_byte(s, 8); // 5355
if (!s.gzhead) { // s->gzhead == Z_NULL // 5356
put_byte(s, 0); // 5357
put_byte(s, 0); // 5358
put_byte(s, 0); // 5359
put_byte(s, 0); // 5360
put_byte(s, 0); // 5361
put_byte(s, s.level === 9 ? 2 : // 5362
(s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? // 5363
4 : 0)); // 5364
put_byte(s, OS_CODE); // 5365
s.status = BUSY_STATE; // 5366
} // 5367
else { // 5368
put_byte(s, (s.gzhead.text ? 1 : 0) + // 5369
(s.gzhead.hcrc ? 2 : 0) + // 5370
(!s.gzhead.extra ? 0 : 4) + // 5371
(!s.gzhead.name ? 0 : 8) + // 5372
(!s.gzhead.comment ? 0 : 16) // 5373
); // 5374
put_byte(s, s.gzhead.time & 0xff); // 5375
put_byte(s, (s.gzhead.time >> 8) & 0xff); // 5376
put_byte(s, (s.gzhead.time >> 16) & 0xff); // 5377
put_byte(s, (s.gzhead.time >> 24) & 0xff); // 5378
put_byte(s, s.level === 9 ? 2 : // 5379
(s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? // 5380
4 : 0)); // 5381
put_byte(s, s.gzhead.os & 0xff); // 5382
if (s.gzhead.extra && s.gzhead.extra.length) { // 5383
put_byte(s, s.gzhead.extra.length & 0xff); // 5384
put_byte(s, (s.gzhead.extra.length >> 8) & 0xff); // 5385
} // 5386
if (s.gzhead.hcrc) { // 5387
strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0); // 5388
} // 5389
s.gzindex = 0; // 5390
s.status = EXTRA_STATE; // 5391
} // 5392
} // 5393
else // DEFLATE header // 5394
{ // 5395
var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8; // 5396
var level_flags = -1; // 5397
// 5398
if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { // 5399
level_flags = 0; // 5400
} else if (s.level < 6) { // 5401
level_flags = 1; // 5402
} else if (s.level === 6) { // 5403
level_flags = 2; // 5404
} else { // 5405
level_flags = 3; // 5406
} // 5407
header |= (level_flags << 6); // 5408
if (s.strstart !== 0) { header |= PRESET_DICT; } // 5409
header += 31 - (header % 31); // 5410
// 5411
s.status = BUSY_STATE; // 5412
putShortMSB(s, header); // 5413
// 5414
/* Save the adler32 of the preset dictionary: */ // 5415
if (s.strstart !== 0) { // 5416
putShortMSB(s, strm.adler >>> 16); // 5417
putShortMSB(s, strm.adler & 0xffff); // 5418
} // 5419
strm.adler = 1; // adler32(0L, Z_NULL, 0); // 5420
} // 5421
} // 5422
// 5423
//#ifdef GZIP // 5424
if (s.status === EXTRA_STATE) { // 5425
if (s.gzhead.extra/* != Z_NULL*/) { // 5426
beg = s.pending; /* start of bytes to update crc */ // 5427
// 5428
while (s.gzindex < (s.gzhead.extra.length & 0xffff)) { // 5429
if (s.pending === s.pending_buf_size) { // 5430
if (s.gzhead.hcrc && s.pending > beg) { // 5431
strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); // 5432
} // 5433
flush_pending(strm); // 5434
beg = s.pending; // 5435
if (s.pending === s.pending_buf_size) { // 5436
break; // 5437
} // 5438
} // 5439
put_byte(s, s.gzhead.extra[s.gzindex] & 0xff); // 5440
s.gzindex++; // 5441
} // 5442
if (s.gzhead.hcrc && s.pending > beg) { // 5443
strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); // 5444
} // 5445
if (s.gzindex === s.gzhead.extra.length) { // 5446
s.gzindex = 0; // 5447
s.status = NAME_STATE; // 5448
} // 5449
} // 5450
else { // 5451
s.status = NAME_STATE; // 5452
} // 5453
} // 5454
if (s.status === NAME_STATE) { // 5455
if (s.gzhead.name/* != Z_NULL*/) { // 5456
beg = s.pending; /* start of bytes to update crc */ // 5457
//int val; // 5458
// 5459
do { // 5460
if (s.pending === s.pending_buf_size) { // 5461
if (s.gzhead.hcrc && s.pending > beg) { // 5462
strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); // 5463
} // 5464
flush_pending(strm); // 5465
beg = s.pending; // 5466
if (s.pending === s.pending_buf_size) { // 5467
val = 1; // 5468
break; // 5469
} // 5470
} // 5471
// JS specific: little magic to add zero terminator to end of string // 5472
if (s.gzindex < s.gzhead.name.length) { // 5473
val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff; // 5474
} else { // 5475
val = 0; // 5476
} // 5477
put_byte(s, val); // 5478
} while (val !== 0); // 5479
// 5480
if (s.gzhead.hcrc && s.pending > beg){ // 5481
strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); // 5482
} // 5483
if (val === 0) { // 5484
s.gzindex = 0; // 5485
s.status = COMMENT_STATE; // 5486
} // 5487
} // 5488
else { // 5489
s.status = COMMENT_STATE; // 5490
} // 5491
} // 5492
if (s.status === COMMENT_STATE) { // 5493
if (s.gzhead.comment/* != Z_NULL*/) { // 5494
beg = s.pending; /* start of bytes to update crc */ // 5495
//int val; // 5496
// 5497
do { // 5498
if (s.pending === s.pending_buf_size) { // 5499
if (s.gzhead.hcrc && s.pending > beg) { // 5500
strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); // 5501
} // 5502
flush_pending(strm); // 5503
beg = s.pending; // 5504
if (s.pending === s.pending_buf_size) { // 5505
val = 1; // 5506
break; // 5507
} // 5508
} // 5509
// JS specific: little magic to add zero terminator to end of string // 5510
if (s.gzindex < s.gzhead.comment.length) { // 5511
val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff; // 5512
} else { // 5513
val = 0; // 5514
} // 5515
put_byte(s, val); // 5516
} while (val !== 0); // 5517
// 5518
if (s.gzhead.hcrc && s.pending > beg) { // 5519
strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); // 5520
} // 5521
if (val === 0) { // 5522
s.status = HCRC_STATE; // 5523
} // 5524
} // 5525
else { // 5526
s.status = HCRC_STATE; // 5527
} // 5528
} // 5529
if (s.status === HCRC_STATE) { // 5530
if (s.gzhead.hcrc) { // 5531
if (s.pending + 2 > s.pending_buf_size) { // 5532
flush_pending(strm); // 5533
} // 5534
if (s.pending + 2 <= s.pending_buf_size) { // 5535
put_byte(s, strm.adler & 0xff); // 5536
put_byte(s, (strm.adler >> 8) & 0xff); // 5537
strm.adler = 0; //crc32(0L, Z_NULL, 0); // 5538
s.status = BUSY_STATE; // 5539
} // 5540
} // 5541
else { // 5542
s.status = BUSY_STATE; // 5543
} // 5544
} // 5545
//#endif // 5546
// 5547
/* Flush as much pending output as possible */ // 5548
if (s.pending !== 0) { // 5549
flush_pending(strm); // 5550
if (strm.avail_out === 0) { // 5551
/* Since avail_out is 0, deflate will be called again with // 5552
* more output space, but possibly with both pending and // 5553
* avail_in equal to zero. There won't be anything to do, // 5554
* but this is not an error situation so make sure we // 5555
* return OK instead of BUF_ERROR at next call of deflate: // 5556
*/ // 5557
s.last_flush = -1; // 5558
return Z_OK; // 5559
} // 5560
// 5561
/* Make sure there is something to do and avoid duplicate consecutive // 5562
* flushes. For repeated and useless calls with Z_FINISH, we keep // 5563
* returning Z_STREAM_END instead of Z_BUF_ERROR. // 5564
*/ // 5565
} else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && // 5566
flush !== Z_FINISH) { // 5567
return err(strm, Z_BUF_ERROR); // 5568
} // 5569
// 5570
/* User must not provide more input after the first FINISH: */ // 5571
if (s.status === FINISH_STATE && strm.avail_in !== 0) { // 5572
return err(strm, Z_BUF_ERROR); // 5573
} // 5574
// 5575
/* Start a new block or continue the current one. // 5576
*/ // 5577
if (strm.avail_in !== 0 || s.lookahead !== 0 || // 5578
(flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) { // 5579
var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) : // 5580
(s.strategy === Z_RLE ? deflate_rle(s, flush) : // 5581
configuration_table[s.level].func(s, flush)); // 5582
// 5583
if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { // 5584
s.status = FINISH_STATE; // 5585
} // 5586
if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { // 5587
if (strm.avail_out === 0) { // 5588
s.last_flush = -1; // 5589
/* avoid BUF_ERROR next call, see above */ // 5590
} // 5591
return Z_OK; // 5592
/* If flush != Z_NO_FLUSH && avail_out == 0, the next call // 5593
* of deflate should use the same flush parameter to make sure // 5594
* that the flush is complete. So we don't have to output an // 5595
* empty block here, this will be done at next call. This also // 5596
* ensures that for a very small output buffer, we emit at most // 5597
* one empty block. // 5598
*/ // 5599
} // 5600
if (bstate === BS_BLOCK_DONE) { // 5601
if (flush === Z_PARTIAL_FLUSH) { // 5602
trees._tr_align(s); // 5603
} // 5604
else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ // 5605
// 5606
trees._tr_stored_block(s, 0, 0, false); // 5607
/* For a full flush, this empty block will be recognized // 5608
* as a special marker by inflate_sync(). // 5609
*/ // 5610
if (flush === Z_FULL_FLUSH) { // 5611
/*** CLEAR_HASH(s); ***/ /* forget history */ // 5612
zero(s.head); // Fill with NIL (= 0); // 5613
// 5614
if (s.lookahead === 0) { // 5615
s.strstart = 0; // 5616
s.block_start = 0; // 5617
s.insert = 0; // 5618
} // 5619
} // 5620
} // 5621
flush_pending(strm); // 5622
if (strm.avail_out === 0) { // 5623
s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */ // 5624
return Z_OK; // 5625
} // 5626
} // 5627
} // 5628
//Assert(strm->avail_out > 0, "bug2"); // 5629
//if (strm.avail_out <= 0) { throw new Error("bug2");} // 5630
// 5631
if (flush !== Z_FINISH) { return Z_OK; } // 5632
if (s.wrap <= 0) { return Z_STREAM_END; } // 5633
// 5634
/* Write the trailer */ // 5635
if (s.wrap === 2) { // 5636
put_byte(s, strm.adler & 0xff); // 5637
put_byte(s, (strm.adler >> 8) & 0xff); // 5638
put_byte(s, (strm.adler >> 16) & 0xff); // 5639
put_byte(s, (strm.adler >> 24) & 0xff); // 5640
put_byte(s, strm.total_in & 0xff); // 5641
put_byte(s, (strm.total_in >> 8) & 0xff); // 5642
put_byte(s, (strm.total_in >> 16) & 0xff); // 5643
put_byte(s, (strm.total_in >> 24) & 0xff); // 5644
} // 5645
else // 5646
{ // 5647
putShortMSB(s, strm.adler >>> 16); // 5648
putShortMSB(s, strm.adler & 0xffff); // 5649
} // 5650
// 5651
flush_pending(strm); // 5652
/* If avail_out is zero, the application will call deflate again // 5653
* to flush the rest. // 5654
*/ // 5655
if (s.wrap > 0) { s.wrap = -s.wrap; } // 5656
/* write the trailer only once! */ // 5657
return s.pending !== 0 ? Z_OK : Z_STREAM_END; // 5658
} // 5659
// 5660
function deflateEnd(strm) { // 5661
var status; // 5662
// 5663
if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) { // 5664
return Z_STREAM_ERROR; // 5665
} // 5666
// 5667
status = strm.state.status; // 5668
if (status !== INIT_STATE && // 5669
status !== EXTRA_STATE && // 5670
status !== NAME_STATE && // 5671
status !== COMMENT_STATE && // 5672
status !== HCRC_STATE && // 5673
status !== BUSY_STATE && // 5674
status !== FINISH_STATE // 5675
) { // 5676
return err(strm, Z_STREAM_ERROR); // 5677
} // 5678
// 5679
strm.state = null; // 5680
// 5681
return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; // 5682
} // 5683
// 5684
/* ========================================================================= // 5685
* Copy the source state to the destination state // 5686
*/ // 5687
//function deflateCopy(dest, source) { // 5688
// // 5689
//} // 5690
// 5691
exports.deflateInit = deflateInit; // 5692
exports.deflateInit2 = deflateInit2; // 5693
exports.deflateReset = deflateReset; // 5694
exports.deflateResetKeep = deflateResetKeep; // 5695
exports.deflateSetHeader = deflateSetHeader; // 5696
exports.deflate = deflate; // 5697
exports.deflateEnd = deflateEnd; // 5698
exports.deflateInfo = 'pako deflate (from Nodeca project)'; // 5699
// 5700
/* Not implemented // 5701
exports.deflateBound = deflateBound; // 5702
exports.deflateCopy = deflateCopy; // 5703
exports.deflateSetDictionary = deflateSetDictionary; // 5704
exports.deflateParams = deflateParams; // 5705
exports.deflatePending = deflatePending; // 5706
exports.deflatePrime = deflatePrime; // 5707
exports.deflateTune = deflateTune; // 5708
*/ // 5709
},{"../utils/common":27,"./adler32":29,"./crc32":31,"./messages":37,"./trees":38}],33:[function(_dereq_,module,exports){
'use strict'; // 5711
// 5712
// 5713
function GZheader() { // 5714
/* true if compressed data believed to be text */ // 5715
this.text = 0; // 5716
/* modification time */ // 5717
this.time = 0; // 5718
/* extra flags (not used when writing a gzip file) */ // 5719
this.xflags = 0; // 5720
/* operating system */ // 5721
this.os = 0; // 5722
/* pointer to extra field or Z_NULL if none */ // 5723
this.extra = null; // 5724
/* extra field length (valid if extra != Z_NULL) */ // 5725
this.extra_len = 0; // Actually, we don't need it in JS, // 5726
// but leave for few code modifications // 5727
// 5728
// // 5729
// Setup limits is not necessary because in js we should not preallocate memory // 5730
// for inflate use constant limit in 65536 bytes // 5731
// // 5732
// 5733
/* space at extra (only when reading header) */ // 5734
// this.extra_max = 0; // 5735
/* pointer to zero-terminated file name or Z_NULL */ // 5736
this.name = ''; // 5737
/* space at name (only when reading header) */ // 5738
// this.name_max = 0; // 5739
/* pointer to zero-terminated comment or Z_NULL */ // 5740
this.comment = ''; // 5741
/* space at comment (only when reading header) */ // 5742
// this.comm_max = 0; // 5743
/* true if there was or will be a header crc */ // 5744
this.hcrc = 0; // 5745
/* true when done reading gzip header (not used when writing a gzip file) */ // 5746
this.done = false; // 5747
} // 5748
// 5749
module.exports = GZheader; // 5750
},{}],34:[function(_dereq_,module,exports){ // 5751
'use strict'; // 5752
// 5753
// See state defs from inflate.js // 5754
var BAD = 30; /* got a data error -- remain here until reset */ // 5755
var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ // 5756
// 5757
/* // 5758
Decode literal, length, and distance codes and write out the resulting // 5759
literal and match bytes until either not enough input or output is // 5760
available, an end-of-block is encountered, or a data error is encountered. // 5761
When large enough input and output buffers are supplied to inflate(), for // 5762
example, a 16K input buffer and a 64K output buffer, more than 95% of the // 5763
inflate execution time is spent in this routine. // 5764
// 5765
Entry assumptions: // 5766
// 5767
state.mode === LEN // 5768
strm.avail_in >= 6 // 5769
strm.avail_out >= 258 // 5770
start >= strm.avail_out // 5771
state.bits < 8 // 5772
// 5773
On return, state.mode is one of: // 5774
// 5775
LEN -- ran out of enough output space or enough available input // 5776
TYPE -- reached end of block code, inflate() to interpret next block // 5777
BAD -- error in block data // 5778
// 5779
Notes: // 5780
// 5781
- The maximum input bits used by a length/distance pair is 15 bits for the // 5782
length code, 5 bits for the length extra, 15 bits for the distance code, // 5783
and 13 bits for the distance extra. This totals 48 bits, or six bytes. // 5784
Therefore if strm.avail_in >= 6, then there is enough input to avoid // 5785
checking for available input while decoding. // 5786
// 5787
- The maximum bytes that a single length/distance pair can output is 258 // 5788
bytes, which is the maximum length that can be coded. inflate_fast() // 5789
requires strm.avail_out >= 258 for each loop to avoid checking for // 5790
output space. // 5791
*/ // 5792
module.exports = function inflate_fast(strm, start) { // 5793
var state; // 5794
var _in; /* local strm.input */ // 5795
var last; /* have enough input while in < last */ // 5796
var _out; /* local strm.output */ // 5797
var beg; /* inflate()'s initial strm.output */ // 5798
var end; /* while out < end, enough space available */ // 5799
//#ifdef INFLATE_STRICT // 5800
var dmax; /* maximum distance from zlib header */ // 5801
//#endif // 5802
var wsize; /* window size or zero if not using window */ // 5803
var whave; /* valid bytes in the window */ // 5804
var wnext; /* window write index */ // 5805
var window; /* allocated sliding window, if wsize != 0 */ // 5806
var hold; /* local strm.hold */ // 5807
var bits; /* local strm.bits */ // 5808
var lcode; /* local strm.lencode */ // 5809
var dcode; /* local strm.distcode */ // 5810
var lmask; /* mask for first level of length codes */ // 5811
var dmask; /* mask for first level of distance codes */ // 5812
var here; /* retrieved table entry */ // 5813
var op; /* code bits, operation, extra bits, or */ // 5814
/* window position, window bytes to copy */ // 5815
var len; /* match length, unused bytes */ // 5816
var dist; /* match distance */ // 5817
var from; /* where to copy match from */ // 5818
var from_source; // 5819
// 5820
// 5821
var input, output; // JS specific, because we have no pointers // 5822
// 5823
/* copy state to local variables */ // 5824
state = strm.state; // 5825
//here = state.here; // 5826
_in = strm.next_in; // 5827
input = strm.input; // 5828
last = _in + (strm.avail_in - 5); // 5829
_out = strm.next_out; // 5830
output = strm.output; // 5831
beg = _out - (start - strm.avail_out); // 5832
end = _out + (strm.avail_out - 257); // 5833
//#ifdef INFLATE_STRICT // 5834
dmax = state.dmax; // 5835
//#endif // 5836
wsize = state.wsize; // 5837
whave = state.whave; // 5838
wnext = state.wnext; // 5839
window = state.window; // 5840
hold = state.hold; // 5841
bits = state.bits; // 5842
lcode = state.lencode; // 5843
dcode = state.distcode; // 5844
lmask = (1 << state.lenbits) - 1; // 5845
dmask = (1 << state.distbits) - 1; // 5846
// 5847
// 5848
/* decode literals and length/distances until end-of-block or not enough // 5849
input data or output space */ // 5850
// 5851
top: // 5852
do { // 5853
if (bits < 15) { // 5854
hold += input[_in++] << bits; // 5855
bits += 8; // 5856
hold += input[_in++] << bits; // 5857
bits += 8; // 5858
} // 5859
// 5860
here = lcode[hold & lmask]; // 5861
// 5862
dolen: // 5863
for (;;) { // Goto emulation // 5864
op = here >>> 24/*here.bits*/; // 5865
hold >>>= op; // 5866
bits -= op; // 5867
op = (here >>> 16) & 0xff/*here.op*/; // 5868
if (op === 0) { /* literal */ // 5869
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? // 5870
// "inflate: literal '%c'\n" : // 5871
// "inflate: literal 0x%02x\n", here.val)); // 5872
output[_out++] = here & 0xffff/*here.val*/; // 5873
} // 5874
else if (op & 16) { /* length base */ // 5875
len = here & 0xffff/*here.val*/; // 5876
op &= 15; /* number of extra bits */ // 5877
if (op) { // 5878
if (bits < op) { // 5879
hold += input[_in++] << bits; // 5880
bits += 8; // 5881
} // 5882
len += hold & ((1 << op) - 1); // 5883
hold >>>= op; // 5884
bits -= op; // 5885
} // 5886
//Tracevv((stderr, "inflate: length %u\n", len)); // 5887
if (bits < 15) { // 5888
hold += input[_in++] << bits; // 5889
bits += 8; // 5890
hold += input[_in++] << bits; // 5891
bits += 8; // 5892
} // 5893
here = dcode[hold & dmask]; // 5894
// 5895
dodist: // 5896
for (;;) { // goto emulation // 5897
op = here >>> 24/*here.bits*/; // 5898
hold >>>= op; // 5899
bits -= op; // 5900
op = (here >>> 16) & 0xff/*here.op*/; // 5901
// 5902
if (op & 16) { /* distance base */ // 5903
dist = here & 0xffff/*here.val*/; // 5904
op &= 15; /* number of extra bits */ // 5905
if (bits < op) { // 5906
hold += input[_in++] << bits; // 5907
bits += 8; // 5908
if (bits < op) { // 5909
hold += input[_in++] << bits; // 5910
bits += 8; // 5911
} // 5912
} // 5913
dist += hold & ((1 << op) - 1); // 5914
//#ifdef INFLATE_STRICT // 5915
if (dist > dmax) { // 5916
strm.msg = 'invalid distance too far back'; // 5917
state.mode = BAD; // 5918
break top; // 5919
} // 5920
//#endif // 5921
hold >>>= op; // 5922
bits -= op; // 5923
//Tracevv((stderr, "inflate: distance %u\n", dist)); // 5924
op = _out - beg; /* max distance in output */ // 5925
if (dist > op) { /* see if copy from window */ // 5926
op = dist - op; /* distance back in window */ // 5927
if (op > whave) { // 5928
if (state.sane) { // 5929
strm.msg = 'invalid distance too far back'; // 5930
state.mode = BAD; // 5931
break top; // 5932
} // 5933
// 5934
// (!) This block is disabled in zlib defailts, // 5935
// don't enable it for binary compatibility // 5936
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR // 5937
// if (len <= op - whave) { // 5938
// do { // 5939
// output[_out++] = 0; // 5940
// } while (--len); // 5941
// continue top; // 5942
// } // 5943
// len -= op - whave; // 5944
// do { // 5945
// output[_out++] = 0; // 5946
// } while (--op > whave); // 5947
// if (op === 0) { // 5948
// from = _out - dist; // 5949
// do { // 5950
// output[_out++] = output[from++]; // 5951
// } while (--len); // 5952
// continue top; // 5953
// } // 5954
//#endif // 5955
} // 5956
from = 0; // window index // 5957
from_source = window; // 5958
if (wnext === 0) { /* very common case */ // 5959
from += wsize - op; // 5960
if (op < len) { /* some from window */ // 5961
len -= op; // 5962
do { // 5963
output[_out++] = window[from++]; // 5964
} while (--op); // 5965
from = _out - dist; /* rest from output */ // 5966
from_source = output; // 5967
} // 5968
} // 5969
else if (wnext < op) { /* wrap around window */ // 5970
from += wsize + wnext - op; // 5971
op -= wnext; // 5972
if (op < len) { /* some from end of window */ // 5973
len -= op; // 5974
do { // 5975
output[_out++] = window[from++]; // 5976
} while (--op); // 5977
from = 0; // 5978
if (wnext < len) { /* some from start of window */ // 5979
op = wnext; // 5980
len -= op; // 5981
do { // 5982
output[_out++] = window[from++]; // 5983
} while (--op); // 5984
from = _out - dist; /* rest from output */ // 5985
from_source = output; // 5986
} // 5987
} // 5988
} // 5989
else { /* contiguous in window */ // 5990
from += wnext - op; // 5991
if (op < len) { /* some from window */ // 5992
len -= op; // 5993
do { // 5994
output[_out++] = window[from++]; // 5995
} while (--op); // 5996
from = _out - dist; /* rest from output */ // 5997
from_source = output; // 5998
} // 5999
} // 6000
while (len > 2) { // 6001
output[_out++] = from_source[from++]; // 6002
output[_out++] = from_source[from++]; // 6003
output[_out++] = from_source[from++]; // 6004
len -= 3; // 6005
} // 6006
if (len) { // 6007
output[_out++] = from_source[from++]; // 6008
if (len > 1) { // 6009
output[_out++] = from_source[from++]; // 6010
} // 6011
} // 6012
} // 6013
else { // 6014
from = _out - dist; /* copy direct from output */ // 6015
do { /* minimum length is three */ // 6016
output[_out++] = output[from++]; // 6017
output[_out++] = output[from++]; // 6018
output[_out++] = output[from++]; // 6019
len -= 3; // 6020
} while (len > 2); // 6021
if (len) { // 6022
output[_out++] = output[from++]; // 6023
if (len > 1) { // 6024
output[_out++] = output[from++]; // 6025
} // 6026
} // 6027
} // 6028
} // 6029
else if ((op & 64) === 0) { /* 2nd level distance code */ // 6030
here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; // 6031
continue dodist; // 6032
} // 6033
else { // 6034
strm.msg = 'invalid distance code'; // 6035
state.mode = BAD; // 6036
break top; // 6037
} // 6038
// 6039
break; // need to emulate goto via "continue" // 6040
} // 6041
} // 6042
else if ((op & 64) === 0) { /* 2nd level length code */ // 6043
here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; // 6044
continue dolen; // 6045
} // 6046
else if (op & 32) { /* end-of-block */ // 6047
//Tracevv((stderr, "inflate: end of block\n")); // 6048
state.mode = TYPE; // 6049
break top; // 6050
} // 6051
else { // 6052
strm.msg = 'invalid literal/length code'; // 6053
state.mode = BAD; // 6054
break top; // 6055
} // 6056
// 6057
break; // need to emulate goto via "continue" // 6058
} // 6059
} while (_in < last && _out < end); // 6060
// 6061
/* return unused bytes (on entry, bits < 8, so in won't go too far back) */ // 6062
len = bits >> 3; // 6063
_in -= len; // 6064
bits -= len << 3; // 6065
hold &= (1 << bits) - 1; // 6066
// 6067
/* update state and return */ // 6068
strm.next_in = _in; // 6069
strm.next_out = _out; // 6070
strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last)); // 6071
strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end)); // 6072
state.hold = hold; // 6073
state.bits = bits; // 6074
return; // 6075
}; // 6076
// 6077
},{}],35:[function(_dereq_,module,exports){ // 6078
'use strict'; // 6079
// 6080
// 6081
var utils = _dereq_('../utils/common'); // 6082
var adler32 = _dereq_('./adler32'); // 6083
var crc32 = _dereq_('./crc32'); // 6084
var inflate_fast = _dereq_('./inffast'); // 6085
var inflate_table = _dereq_('./inftrees'); // 6086
// 6087
var CODES = 0; // 6088
var LENS = 1; // 6089
var DISTS = 2; // 6090
// 6091
/* Public constants ==========================================================*/ // 6092
/* ===========================================================================*/ // 6093
// 6094
// 6095
/* Allowed flush values; see deflate() and inflate() below for details */ // 6096
//var Z_NO_FLUSH = 0; // 6097
//var Z_PARTIAL_FLUSH = 1; // 6098
//var Z_SYNC_FLUSH = 2; // 6099
//var Z_FULL_FLUSH = 3; // 6100
var Z_FINISH = 4; // 6101
var Z_BLOCK = 5; // 6102
var Z_TREES = 6; // 6103
// 6104
// 6105
/* Return codes for the compression/decompression functions. Negative values // 6106
* are errors, positive values are used for special but normal events. // 6107
*/ // 6108
var Z_OK = 0; // 6109
var Z_STREAM_END = 1; // 6110
var Z_NEED_DICT = 2; // 6111
//var Z_ERRNO = -1; // 6112
var Z_STREAM_ERROR = -2; // 6113
var Z_DATA_ERROR = -3; // 6114
var Z_MEM_ERROR = -4; // 6115
var Z_BUF_ERROR = -5; // 6116
//var Z_VERSION_ERROR = -6; // 6117
// 6118
/* The deflate compression method */ // 6119
var Z_DEFLATED = 8; // 6120
// 6121
// 6122
/* STATES ====================================================================*/ // 6123
/* ===========================================================================*/ // 6124
// 6125
// 6126
var HEAD = 1; /* i: waiting for magic header */ // 6127
var FLAGS = 2; /* i: waiting for method and flags (gzip) */ // 6128
var TIME = 3; /* i: waiting for modification time (gzip) */ // 6129
var OS = 4; /* i: waiting for extra flags and operating system (gzip) */ // 6130
var EXLEN = 5; /* i: waiting for extra length (gzip) */ // 6131
var EXTRA = 6; /* i: waiting for extra bytes (gzip) */ // 6132
var NAME = 7; /* i: waiting for end of file name (gzip) */ // 6133
var COMMENT = 8; /* i: waiting for end of comment (gzip) */ // 6134
var HCRC = 9; /* i: waiting for header crc (gzip) */ // 6135
var DICTID = 10; /* i: waiting for dictionary check value */ // 6136
var DICT = 11; /* waiting for inflateSetDictionary() call */ // 6137
var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ // 6138
var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */ // 6139
var STORED = 14; /* i: waiting for stored size (length and complement) */ // 6140
var COPY_ = 15; /* i/o: same as COPY below, but only first time in */ // 6141
var COPY = 16; /* i/o: waiting for input or output to copy stored block */ // 6142
var TABLE = 17; /* i: waiting for dynamic block table lengths */ // 6143
var LENLENS = 18; /* i: waiting for code length code lengths */ // 6144
var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */ // 6145
var LEN_ = 20; /* i: same as LEN below, but only first time in */ // 6146
var LEN = 21; /* i: waiting for length/lit/eob code */ // 6147
var LENEXT = 22; /* i: waiting for length extra bits */ // 6148
var DIST = 23; /* i: waiting for distance code */ // 6149
var DISTEXT = 24; /* i: waiting for distance extra bits */ // 6150
var MATCH = 25; /* o: waiting for output space to copy string */ // 6151
var LIT = 26; /* o: waiting for output space to write literal */ // 6152
var CHECK = 27; /* i: waiting for 32-bit check value */ // 6153
var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */ // 6154
var DONE = 29; /* finished check, done -- remain here until reset */ // 6155
var BAD = 30; /* got a data error -- remain here until reset */ // 6156
var MEM = 31; /* got an inflate() memory error -- remain here until reset */ // 6157
var SYNC = 32; /* looking for synchronization bytes to restart inflate() */ // 6158
// 6159
/* ===========================================================================*/ // 6160
// 6161
// 6162
// 6163
var ENOUGH_LENS = 852; // 6164
var ENOUGH_DISTS = 592; // 6165
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); // 6166
// 6167
var MAX_WBITS = 15; // 6168
/* 32K LZ77 window */ // 6169
var DEF_WBITS = MAX_WBITS; // 6170
// 6171
// 6172
function ZSWAP32(q) { // 6173
return (((q >>> 24) & 0xff) + // 6174
((q >>> 8) & 0xff00) + // 6175
((q & 0xff00) << 8) + // 6176
((q & 0xff) << 24)); // 6177
} // 6178
// 6179
// 6180
function InflateState() { // 6181
this.mode = 0; /* current inflate mode */ // 6182
this.last = false; /* true if processing last block */ // 6183
this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ // 6184
this.havedict = false; /* true if dictionary provided */ // 6185
this.flags = 0; /* gzip header method and flags (0 if zlib) */ // 6186
this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */ // 6187
this.check = 0; /* protected copy of check value */ // 6188
this.total = 0; /* protected copy of output count */ // 6189
// TODO: may be {} // 6190
this.head = null; /* where to save gzip header information */ // 6191
// 6192
/* sliding window */ // 6193
this.wbits = 0; /* log base 2 of requested window size */ // 6194
this.wsize = 0; /* window size or zero if not using window */ // 6195
this.whave = 0; /* valid bytes in the window */ // 6196
this.wnext = 0; /* window write index */ // 6197
this.window = null; /* allocated sliding window, if needed */ // 6198
// 6199
/* bit accumulator */ // 6200
this.hold = 0; /* input bit accumulator */ // 6201
this.bits = 0; /* number of bits in "in" */ // 6202
// 6203
/* for string and stored block copying */ // 6204
this.length = 0; /* literal or length of data to copy */ // 6205
this.offset = 0; /* distance back to copy string from */ // 6206
// 6207
/* for table and code decoding */ // 6208
this.extra = 0; /* extra bits needed */ // 6209
// 6210
/* fixed and dynamic code tables */ // 6211
this.lencode = null; /* starting table for length/literal codes */ // 6212
this.distcode = null; /* starting table for distance codes */ // 6213
this.lenbits = 0; /* index bits for lencode */ // 6214
this.distbits = 0; /* index bits for distcode */ // 6215
// 6216
/* dynamic table building */ // 6217
this.ncode = 0; /* number of code length code lengths */ // 6218
this.nlen = 0; /* number of length code lengths */ // 6219
this.ndist = 0; /* number of distance code lengths */ // 6220
this.have = 0; /* number of code lengths in lens[] */ // 6221
this.next = null; /* next available space in codes[] */ // 6222
// 6223
this.lens = new utils.Buf16(320); /* temporary storage for code lengths */ // 6224
this.work = new utils.Buf16(288); /* work area for code table building */ // 6225
// 6226
/* // 6227
because we don't have pointers in js, we use lencode and distcode directly // 6228
as buffers so we don't need codes // 6229
*/ // 6230
//this.codes = new utils.Buf32(ENOUGH); /* space for code tables */ // 6231
this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */ // 6232
this.distdyn = null; /* dynamic table for distance codes (JS specific) */ // 6233
this.sane = 0; /* if false, allow invalid distance too far */ // 6234
this.back = 0; /* bits back of last unprocessed length/lit */ // 6235
this.was = 0; /* initial length of match */ // 6236
} // 6237
// 6238
function inflateResetKeep(strm) { // 6239
var state; // 6240
// 6241
if (!strm || !strm.state) { return Z_STREAM_ERROR; } // 6242
state = strm.state; // 6243
strm.total_in = strm.total_out = state.total = 0; // 6244
strm.msg = ''; /*Z_NULL*/ // 6245
if (state.wrap) { /* to support ill-conceived Java test suite */ // 6246
strm.adler = state.wrap & 1; // 6247
} // 6248
state.mode = HEAD; // 6249
state.last = 0; // 6250
state.havedict = 0; // 6251
state.dmax = 32768; // 6252
state.head = null/*Z_NULL*/; // 6253
state.hold = 0; // 6254
state.bits = 0; // 6255
//state.lencode = state.distcode = state.next = state.codes; // 6256
state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); // 6257
state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); // 6258
// 6259
state.sane = 1; // 6260
state.back = -1; // 6261
//Tracev((stderr, "inflate: reset\n")); // 6262
return Z_OK; // 6263
} // 6264
// 6265
function inflateReset(strm) { // 6266
var state; // 6267
// 6268
if (!strm || !strm.state) { return Z_STREAM_ERROR; } // 6269
state = strm.state; // 6270
state.wsize = 0; // 6271
state.whave = 0; // 6272
state.wnext = 0; // 6273
return inflateResetKeep(strm); // 6274
// 6275
} // 6276
// 6277
function inflateReset2(strm, windowBits) { // 6278
var wrap; // 6279
var state; // 6280
// 6281
/* get the state */ // 6282
if (!strm || !strm.state) { return Z_STREAM_ERROR; } // 6283
state = strm.state; // 6284
// 6285
/* extract wrap request from windowBits parameter */ // 6286
if (windowBits < 0) { // 6287
wrap = 0; // 6288
windowBits = -windowBits; // 6289
} // 6290
else { // 6291
wrap = (windowBits >> 4) + 1; // 6292
if (windowBits < 48) { // 6293
windowBits &= 15; // 6294
} // 6295
} // 6296
// 6297
/* set number of window bits, free window if different */ // 6298
if (windowBits && (windowBits < 8 || windowBits > 15)) { // 6299
return Z_STREAM_ERROR; // 6300
} // 6301
if (state.window !== null && state.wbits !== windowBits) { // 6302
state.window = null; // 6303
} // 6304
// 6305
/* update state and reset the rest of it */ // 6306
state.wrap = wrap; // 6307
state.wbits = windowBits; // 6308
return inflateReset(strm); // 6309
} // 6310
// 6311
function inflateInit2(strm, windowBits) { // 6312
var ret; // 6313
var state; // 6314
// 6315
if (!strm) { return Z_STREAM_ERROR; } // 6316
//strm.msg = Z_NULL; /* in case we return an error */ // 6317
// 6318
state = new InflateState(); // 6319
// 6320
//if (state === Z_NULL) return Z_MEM_ERROR; // 6321
//Tracev((stderr, "inflate: allocated\n")); // 6322
strm.state = state; // 6323
state.window = null/*Z_NULL*/; // 6324
ret = inflateReset2(strm, windowBits); // 6325
if (ret !== Z_OK) { // 6326
strm.state = null/*Z_NULL*/; // 6327
} // 6328
return ret; // 6329
} // 6330
// 6331
function inflateInit(strm) { // 6332
return inflateInit2(strm, DEF_WBITS); // 6333
} // 6334
// 6335
// 6336
/* // 6337
Return state with length and distance decoding tables and index sizes set to // 6338
fixed code decoding. Normally this returns fixed tables from inffixed.h. // 6339
If BUILDFIXED is defined, then instead this routine builds the tables the // 6340
first time it's called, and returns those tables the first time and // 6341
thereafter. This reduces the size of the code by about 2K bytes, in // 6342
exchange for a little execution time. However, BUILDFIXED should not be // 6343
used for threaded applications, since the rewriting of the tables and virgin // 6344
may not be thread-safe. // 6345
*/ // 6346
var virgin = true; // 6347
// 6348
var lenfix, distfix; // We have no pointers in JS, so keep tables separate // 6349
// 6350
function fixedtables(state) { // 6351
/* build fixed huffman tables if first call (may not be thread safe) */ // 6352
if (virgin) { // 6353
var sym; // 6354
// 6355
lenfix = new utils.Buf32(512); // 6356
distfix = new utils.Buf32(32); // 6357
// 6358
/* literal/length table */ // 6359
sym = 0; // 6360
while (sym < 144) { state.lens[sym++] = 8; } // 6361
while (sym < 256) { state.lens[sym++] = 9; } // 6362
while (sym < 280) { state.lens[sym++] = 7; } // 6363
while (sym < 288) { state.lens[sym++] = 8; } // 6364
// 6365
inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, {bits: 9}); // 6366
// 6367
/* distance table */ // 6368
sym = 0; // 6369
while (sym < 32) { state.lens[sym++] = 5; } // 6370
// 6371
inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, {bits: 5}); // 6372
// 6373
/* do this just once */ // 6374
virgin = false; // 6375
} // 6376
// 6377
state.lencode = lenfix; // 6378
state.lenbits = 9; // 6379
state.distcode = distfix; // 6380
state.distbits = 5; // 6381
} // 6382
// 6383
// 6384
/* // 6385
Update the window with the last wsize (normally 32K) bytes written before // 6386
returning. If window does not exist yet, create it. This is only called // 6387
when a window is already in use, or when output has been written during this // 6388
inflate call, but the end of the deflate stream has not been reached yet. // 6389
It is also called to create a window for dictionary data when a dictionary // 6390
is loaded. // 6391
// 6392
Providing output buffers larger than 32K to inflate() should provide a speed // 6393
advantage, since only the last 32K of output is copied to the sliding window // 6394
upon return from inflate(), and since all distances after the first 32K of // 6395
output will fall in the output data, making match copies simpler and faster. // 6396
The advantage may be dependent on the size of the processor's data caches. // 6397
*/ // 6398
function updatewindow(strm, src, end, copy) { // 6399
var dist; // 6400
var state = strm.state; // 6401
// 6402
/* if it hasn't been done already, allocate space for the window */ // 6403
if (state.window === null) { // 6404
state.wsize = 1 << state.wbits; // 6405
state.wnext = 0; // 6406
state.whave = 0; // 6407
// 6408
state.window = new utils.Buf8(state.wsize); // 6409
} // 6410
// 6411
/* copy state->wsize or less output bytes into the circular window */ // 6412
if (copy >= state.wsize) { // 6413
utils.arraySet(state.window,src, end - state.wsize, state.wsize, 0); // 6414
state.wnext = 0; // 6415
state.whave = state.wsize; // 6416
} // 6417
else { // 6418
dist = state.wsize - state.wnext; // 6419
if (dist > copy) { // 6420
dist = copy; // 6421
} // 6422
//zmemcpy(state->window + state->wnext, end - copy, dist); // 6423
utils.arraySet(state.window,src, end - copy, dist, state.wnext); // 6424
copy -= dist; // 6425
if (copy) { // 6426
//zmemcpy(state->window, end - copy, copy); // 6427
utils.arraySet(state.window,src, end - copy, copy, 0); // 6428
state.wnext = copy; // 6429
state.whave = state.wsize; // 6430
} // 6431
else { // 6432
state.wnext += dist; // 6433
if (state.wnext === state.wsize) { state.wnext = 0; } // 6434
if (state.whave < state.wsize) { state.whave += dist; } // 6435
} // 6436
} // 6437
return 0; // 6438
} // 6439
// 6440
function inflate(strm, flush) { // 6441
var state; // 6442
var input, output; // input/output buffers // 6443
var next; /* next input INDEX */ // 6444
var put; /* next output INDEX */ // 6445
var have, left; /* available input and output */ // 6446
var hold; /* bit buffer */ // 6447
var bits; /* bits in bit buffer */ // 6448
var _in, _out; /* save starting available input and output */ // 6449
var copy; /* number of stored or match bytes to copy */ // 6450
var from; /* where to copy match bytes from */ // 6451
var from_source; // 6452
var here = 0; /* current decoding table entry */ // 6453
var here_bits, here_op, here_val; // paked "here" denormalized (JS specific) // 6454
//var last; /* parent table entry */ // 6455
var last_bits, last_op, last_val; // paked "last" denormalized (JS specific) // 6456
var len; /* length to copy for repeats, bits to drop */ // 6457
var ret; /* return code */ // 6458
var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */ // 6459
var opts; // 6460
// 6461
var n; // temporary var for NEED_BITS // 6462
// 6463
var order = /* permutation of code lengths */ // 6464
[16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; // 6465
// 6466
// 6467
if (!strm || !strm.state || !strm.output || // 6468
(!strm.input && strm.avail_in !== 0)) { // 6469
return Z_STREAM_ERROR; // 6470
} // 6471
// 6472
state = strm.state; // 6473
if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */ // 6474
// 6475
// 6476
//--- LOAD() --- // 6477
put = strm.next_out; // 6478
output = strm.output; // 6479
left = strm.avail_out; // 6480
next = strm.next_in; // 6481
input = strm.input; // 6482
have = strm.avail_in; // 6483
hold = state.hold; // 6484
bits = state.bits; // 6485
//--- // 6486
// 6487
_in = have; // 6488
_out = left; // 6489
ret = Z_OK; // 6490
// 6491
inf_leave: // goto emulation // 6492
for (;;) { // 6493
switch (state.mode) { // 6494
case HEAD: // 6495
if (state.wrap === 0) { // 6496
state.mode = TYPEDO; // 6497
break; // 6498
} // 6499
//=== NEEDBITS(16); // 6500
while (bits < 16) { // 6501
if (have === 0) { break inf_leave; } // 6502
have--; // 6503
hold += input[next++] << bits; // 6504
bits += 8; // 6505
} // 6506
//===// // 6507
if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */ // 6508
state.check = 0/*crc32(0L, Z_NULL, 0)*/; // 6509
//=== CRC2(state.check, hold); // 6510
hbuf[0] = hold & 0xff; // 6511
hbuf[1] = (hold >>> 8) & 0xff; // 6512
state.check = crc32(state.check, hbuf, 2, 0); // 6513
//===// // 6514
// 6515
//=== INITBITS(); // 6516
hold = 0; // 6517
bits = 0; // 6518
//===// // 6519
state.mode = FLAGS; // 6520
break; // 6521
} // 6522
state.flags = 0; /* expect zlib header */ // 6523
if (state.head) { // 6524
state.head.done = false; // 6525
} // 6526
if (!(state.wrap & 1) || /* check if zlib header allowed */ // 6527
(((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) { // 6528
strm.msg = 'incorrect header check'; // 6529
state.mode = BAD; // 6530
break; // 6531
} // 6532
if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) { // 6533
strm.msg = 'unknown compression method'; // 6534
state.mode = BAD; // 6535
break; // 6536
} // 6537
//--- DROPBITS(4) ---// // 6538
hold >>>= 4; // 6539
bits -= 4; // 6540
//---// // 6541
len = (hold & 0x0f)/*BITS(4)*/ + 8; // 6542
if (state.wbits === 0) { // 6543
state.wbits = len; // 6544
} // 6545
else if (len > state.wbits) { // 6546
strm.msg = 'invalid window size'; // 6547
state.mode = BAD; // 6548
break; // 6549
} // 6550
state.dmax = 1 << len; // 6551
//Tracev((stderr, "inflate: zlib header ok\n")); // 6552
strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; // 6553
state.mode = hold & 0x200 ? DICTID : TYPE; // 6554
//=== INITBITS(); // 6555
hold = 0; // 6556
bits = 0; // 6557
//===// // 6558
break; // 6559
case FLAGS: // 6560
//=== NEEDBITS(16); */ // 6561
while (bits < 16) { // 6562
if (have === 0) { break inf_leave; } // 6563
have--; // 6564
hold += input[next++] << bits; // 6565
bits += 8; // 6566
} // 6567
//===// // 6568
state.flags = hold; // 6569
if ((state.flags & 0xff) !== Z_DEFLATED) { // 6570
strm.msg = 'unknown compression method'; // 6571
state.mode = BAD; // 6572
break; // 6573
} // 6574
if (state.flags & 0xe000) { // 6575
strm.msg = 'unknown header flags set'; // 6576
state.mode = BAD; // 6577
break; // 6578
} // 6579
if (state.head) { // 6580
state.head.text = ((hold >> 8) & 1); // 6581
} // 6582
if (state.flags & 0x0200) { // 6583
//=== CRC2(state.check, hold); // 6584
hbuf[0] = hold & 0xff; // 6585
hbuf[1] = (hold >>> 8) & 0xff; // 6586
state.check = crc32(state.check, hbuf, 2, 0); // 6587
//===// // 6588
} // 6589
//=== INITBITS(); // 6590
hold = 0; // 6591
bits = 0; // 6592
//===// // 6593
state.mode = TIME; // 6594
/* falls through */ // 6595
case TIME: // 6596
//=== NEEDBITS(32); */ // 6597
while (bits < 32) { // 6598
if (have === 0) { break inf_leave; } // 6599
have--; // 6600
hold += input[next++] << bits; // 6601
bits += 8; // 6602
} // 6603
//===// // 6604
if (state.head) { // 6605
state.head.time = hold; // 6606
} // 6607
if (state.flags & 0x0200) { // 6608
//=== CRC4(state.check, hold) // 6609
hbuf[0] = hold & 0xff; // 6610
hbuf[1] = (hold >>> 8) & 0xff; // 6611
hbuf[2] = (hold >>> 16) & 0xff; // 6612
hbuf[3] = (hold >>> 24) & 0xff; // 6613
state.check = crc32(state.check, hbuf, 4, 0); // 6614
//=== // 6615
} // 6616
//=== INITBITS(); // 6617
hold = 0; // 6618
bits = 0; // 6619
//===// // 6620
state.mode = OS; // 6621
/* falls through */ // 6622
case OS: // 6623
//=== NEEDBITS(16); */ // 6624
while (bits < 16) { // 6625
if (have === 0) { break inf_leave; } // 6626
have--; // 6627
hold += input[next++] << bits; // 6628
bits += 8; // 6629
} // 6630
//===// // 6631
if (state.head) { // 6632
state.head.xflags = (hold & 0xff); // 6633
state.head.os = (hold >> 8); // 6634
} // 6635
if (state.flags & 0x0200) { // 6636
//=== CRC2(state.check, hold); // 6637
hbuf[0] = hold & 0xff; // 6638
hbuf[1] = (hold >>> 8) & 0xff; // 6639
state.check = crc32(state.check, hbuf, 2, 0); // 6640
//===// // 6641
} // 6642
//=== INITBITS(); // 6643
hold = 0; // 6644
bits = 0; // 6645
//===// // 6646
state.mode = EXLEN; // 6647
/* falls through */ // 6648
case EXLEN: // 6649
if (state.flags & 0x0400) { // 6650
//=== NEEDBITS(16); */ // 6651
while (bits < 16) { // 6652
if (have === 0) { break inf_leave; } // 6653
have--; // 6654
hold += input[next++] << bits; // 6655
bits += 8; // 6656
} // 6657
//===// // 6658
state.length = hold; // 6659
if (state.head) { // 6660
state.head.extra_len = hold; // 6661
} // 6662
if (state.flags & 0x0200) { // 6663
//=== CRC2(state.check, hold); // 6664
hbuf[0] = hold & 0xff; // 6665
hbuf[1] = (hold >>> 8) & 0xff; // 6666
state.check = crc32(state.check, hbuf, 2, 0); // 6667
//===// // 6668
} // 6669
//=== INITBITS(); // 6670
hold = 0; // 6671
bits = 0; // 6672
//===// // 6673
} // 6674
else if (state.head) { // 6675
state.head.extra = null/*Z_NULL*/; // 6676
} // 6677
state.mode = EXTRA; // 6678
/* falls through */ // 6679
case EXTRA: // 6680
if (state.flags & 0x0400) { // 6681
copy = state.length; // 6682
if (copy > have) { copy = have; } // 6683
if (copy) { // 6684
if (state.head) { // 6685
len = state.head.extra_len - state.length; // 6686
if (!state.head.extra) { // 6687
// Use untyped array for more conveniend processing later // 6688
state.head.extra = new Array(state.head.extra_len); // 6689
} // 6690
utils.arraySet( // 6691
state.head.extra, // 6692
input, // 6693
next, // 6694
// extra field is limited to 65536 bytes // 6695
// - no need for additional size check // 6696
copy, // 6697
/*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ // 6698
len // 6699
); // 6700
//zmemcpy(state.head.extra + len, next, // 6701
// len + copy > state.head.extra_max ? // 6702
// state.head.extra_max - len : copy); // 6703
} // 6704
if (state.flags & 0x0200) { // 6705
state.check = crc32(state.check, input, copy, next); // 6706
} // 6707
have -= copy; // 6708
next += copy; // 6709
state.length -= copy; // 6710
} // 6711
if (state.length) { break inf_leave; } // 6712
} // 6713
state.length = 0; // 6714
state.mode = NAME; // 6715
/* falls through */ // 6716
case NAME: // 6717
if (state.flags & 0x0800) { // 6718
if (have === 0) { break inf_leave; } // 6719
copy = 0; // 6720
do { // 6721
// TODO: 2 or 1 bytes? // 6722
len = input[next + copy++]; // 6723
/* use constant limit because in js we should not preallocate memory */ // 6724
if (state.head && len && // 6725
(state.length < 65536 /*state.head.name_max*/)) { // 6726
state.head.name += String.fromCharCode(len); // 6727
} // 6728
} while (len && copy < have); // 6729
// 6730
if (state.flags & 0x0200) { // 6731
state.check = crc32(state.check, input, copy, next); // 6732
} // 6733
have -= copy; // 6734
next += copy; // 6735
if (len) { break inf_leave; } // 6736
} // 6737
else if (state.head) { // 6738
state.head.name = null; // 6739
} // 6740
state.length = 0; // 6741
state.mode = COMMENT; // 6742
/* falls through */ // 6743
case COMMENT: // 6744
if (state.flags & 0x1000) { // 6745
if (have === 0) { break inf_leave; } // 6746
copy = 0; // 6747
do { // 6748
len = input[next + copy++]; // 6749
/* use constant limit because in js we should not preallocate memory */ // 6750
if (state.head && len && // 6751
(state.length < 65536 /*state.head.comm_max*/)) { // 6752
state.head.comment += String.fromCharCode(len); // 6753
} // 6754
} while (len && copy < have); // 6755
if (state.flags & 0x0200) { // 6756
state.check = crc32(state.check, input, copy, next); // 6757
} // 6758
have -= copy; // 6759
next += copy; // 6760
if (len) { break inf_leave; } // 6761
} // 6762
else if (state.head) { // 6763
state.head.comment = null; // 6764
} // 6765
state.mode = HCRC; // 6766
/* falls through */ // 6767
case HCRC: // 6768
if (state.flags & 0x0200) { // 6769
//=== NEEDBITS(16); */ // 6770
while (bits < 16) { // 6771
if (have === 0) { break inf_leave; } // 6772
have--; // 6773
hold += input[next++] << bits; // 6774
bits += 8; // 6775
} // 6776
//===// // 6777
if (hold !== (state.check & 0xffff)) { // 6778
strm.msg = 'header crc mismatch'; // 6779
state.mode = BAD; // 6780
break; // 6781
} // 6782
//=== INITBITS(); // 6783
hold = 0; // 6784
bits = 0; // 6785
//===// // 6786
} // 6787
if (state.head) { // 6788
state.head.hcrc = ((state.flags >> 9) & 1); // 6789
state.head.done = true; // 6790
} // 6791
strm.adler = state.check = 0 /*crc32(0L, Z_NULL, 0)*/; // 6792
state.mode = TYPE; // 6793
break; // 6794
case DICTID: // 6795
//=== NEEDBITS(32); */ // 6796
while (bits < 32) { // 6797
if (have === 0) { break inf_leave; } // 6798
have--; // 6799
hold += input[next++] << bits; // 6800
bits += 8; // 6801
} // 6802
//===// // 6803
strm.adler = state.check = ZSWAP32(hold); // 6804
//=== INITBITS(); // 6805
hold = 0; // 6806
bits = 0; // 6807
//===// // 6808
state.mode = DICT; // 6809
/* falls through */ // 6810
case DICT: // 6811
if (state.havedict === 0) { // 6812
//--- RESTORE() --- // 6813
strm.next_out = put; // 6814
strm.avail_out = left; // 6815
strm.next_in = next; // 6816
strm.avail_in = have; // 6817
state.hold = hold; // 6818
state.bits = bits; // 6819
//--- // 6820
return Z_NEED_DICT; // 6821
} // 6822
strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; // 6823
state.mode = TYPE; // 6824
/* falls through */ // 6825
case TYPE: // 6826
if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; } // 6827
/* falls through */ // 6828
case TYPEDO: // 6829
if (state.last) { // 6830
//--- BYTEBITS() ---// // 6831
hold >>>= bits & 7; // 6832
bits -= bits & 7; // 6833
//---// // 6834
state.mode = CHECK; // 6835
break; // 6836
} // 6837
//=== NEEDBITS(3); */ // 6838
while (bits < 3) { // 6839
if (have === 0) { break inf_leave; } // 6840
have--; // 6841
hold += input[next++] << bits; // 6842
bits += 8; // 6843
} // 6844
//===// // 6845
state.last = (hold & 0x01)/*BITS(1)*/; // 6846
//--- DROPBITS(1) ---// // 6847
hold >>>= 1; // 6848
bits -= 1; // 6849
//---// // 6850
// 6851
switch ((hold & 0x03)/*BITS(2)*/) { // 6852
case 0: /* stored block */ // 6853
//Tracev((stderr, "inflate: stored block%s\n", // 6854
// state.last ? " (last)" : "")); // 6855
state.mode = STORED; // 6856
break; // 6857
case 1: /* fixed block */ // 6858
fixedtables(state); // 6859
//Tracev((stderr, "inflate: fixed codes block%s\n", // 6860
// state.last ? " (last)" : "")); // 6861
state.mode = LEN_; /* decode codes */ // 6862
if (flush === Z_TREES) { // 6863
//--- DROPBITS(2) ---// // 6864
hold >>>= 2; // 6865
bits -= 2; // 6866
//---// // 6867
break inf_leave; // 6868
} // 6869
break; // 6870
case 2: /* dynamic block */ // 6871
//Tracev((stderr, "inflate: dynamic codes block%s\n", // 6872
// state.last ? " (last)" : "")); // 6873
state.mode = TABLE; // 6874
break; // 6875
case 3: // 6876
strm.msg = 'invalid block type'; // 6877
state.mode = BAD; // 6878
} // 6879
//--- DROPBITS(2) ---// // 6880
hold >>>= 2; // 6881
bits -= 2; // 6882
//---// // 6883
break; // 6884
case STORED: // 6885
//--- BYTEBITS() ---// /* go to byte boundary */ // 6886
hold >>>= bits & 7; // 6887
bits -= bits & 7; // 6888
//---// // 6889
//=== NEEDBITS(32); */ // 6890
while (bits < 32) { // 6891
if (have === 0) { break inf_leave; } // 6892
have--; // 6893
hold += input[next++] << bits; // 6894
bits += 8; // 6895
} // 6896
//===// // 6897
if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) { // 6898
strm.msg = 'invalid stored block lengths'; // 6899
state.mode = BAD; // 6900
break; // 6901
} // 6902
state.length = hold & 0xffff; // 6903
//Tracev((stderr, "inflate: stored length %u\n", // 6904
// state.length)); // 6905
//=== INITBITS(); // 6906
hold = 0; // 6907
bits = 0; // 6908
//===// // 6909
state.mode = COPY_; // 6910
if (flush === Z_TREES) { break inf_leave; } // 6911
/* falls through */ // 6912
case COPY_: // 6913
state.mode = COPY; // 6914
/* falls through */ // 6915
case COPY: // 6916
copy = state.length; // 6917
if (copy) { // 6918
if (copy > have) { copy = have; } // 6919
if (copy > left) { copy = left; } // 6920
if (copy === 0) { break inf_leave; } // 6921
//--- zmemcpy(put, next, copy); --- // 6922
utils.arraySet(output, input, next, copy, put); // 6923
//---// // 6924
have -= copy; // 6925
next += copy; // 6926
left -= copy; // 6927
put += copy; // 6928
state.length -= copy; // 6929
break; // 6930
} // 6931
//Tracev((stderr, "inflate: stored end\n")); // 6932
state.mode = TYPE; // 6933
break; // 6934
case TABLE: // 6935
//=== NEEDBITS(14); */ // 6936
while (bits < 14) { // 6937
if (have === 0) { break inf_leave; } // 6938
have--; // 6939
hold += input[next++] << bits; // 6940
bits += 8; // 6941
} // 6942
//===// // 6943
state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257; // 6944
//--- DROPBITS(5) ---// // 6945
hold >>>= 5; // 6946
bits -= 5; // 6947
//---// // 6948
state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1; // 6949
//--- DROPBITS(5) ---// // 6950
hold >>>= 5; // 6951
bits -= 5; // 6952
//---// // 6953
state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4; // 6954
//--- DROPBITS(4) ---// // 6955
hold >>>= 4; // 6956
bits -= 4; // 6957
//---// // 6958
//#ifndef PKZIP_BUG_WORKAROUND // 6959
if (state.nlen > 286 || state.ndist > 30) { // 6960
strm.msg = 'too many length or distance symbols'; // 6961
state.mode = BAD; // 6962
break; // 6963
} // 6964
//#endif // 6965
//Tracev((stderr, "inflate: table sizes ok\n")); // 6966
state.have = 0; // 6967
state.mode = LENLENS; // 6968
/* falls through */ // 6969
case LENLENS: // 6970
while (state.have < state.ncode) { // 6971
//=== NEEDBITS(3); // 6972
while (bits < 3) { // 6973
if (have === 0) { break inf_leave; } // 6974
have--; // 6975
hold += input[next++] << bits; // 6976
bits += 8; // 6977
} // 6978
//===// // 6979
state.lens[order[state.have++]] = (hold & 0x07);//BITS(3); // 6980
//--- DROPBITS(3) ---// // 6981
hold >>>= 3; // 6982
bits -= 3; // 6983
//---// // 6984
} // 6985
while (state.have < 19) { // 6986
state.lens[order[state.have++]] = 0; // 6987
} // 6988
// We have separate tables & no pointers. 2 commented lines below not needed. // 6989
//state.next = state.codes; // 6990
//state.lencode = state.next; // 6991
// Switch to use dynamic table // 6992
state.lencode = state.lendyn; // 6993
state.lenbits = 7; // 6994
// 6995
opts = {bits: state.lenbits}; // 6996
ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); // 6997
state.lenbits = opts.bits; // 6998
// 6999
if (ret) { // 7000
strm.msg = 'invalid code lengths set'; // 7001
state.mode = BAD; // 7002
break; // 7003
} // 7004
//Tracev((stderr, "inflate: code lengths ok\n")); // 7005
state.have = 0; // 7006
state.mode = CODELENS; // 7007
/* falls through */ // 7008
case CODELENS: // 7009
while (state.have < state.nlen + state.ndist) { // 7010
for (;;) { // 7011
here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/ // 7012
here_bits = here >>> 24; // 7013
here_op = (here >>> 16) & 0xff; // 7014
here_val = here & 0xffff; // 7015
// 7016
if ((here_bits) <= bits) { break; } // 7017
//--- PULLBYTE() ---// // 7018
if (have === 0) { break inf_leave; } // 7019
have--; // 7020
hold += input[next++] << bits; // 7021
bits += 8; // 7022
//---// // 7023
} // 7024
if (here_val < 16) { // 7025
//--- DROPBITS(here.bits) ---// // 7026
hold >>>= here_bits; // 7027
bits -= here_bits; // 7028
//---// // 7029
state.lens[state.have++] = here_val; // 7030
} // 7031
else { // 7032
if (here_val === 16) { // 7033
//=== NEEDBITS(here.bits + 2); // 7034
n = here_bits + 2; // 7035
while (bits < n) { // 7036
if (have === 0) { break inf_leave; } // 7037
have--; // 7038
hold += input[next++] << bits; // 7039
bits += 8; // 7040
} // 7041
//===// // 7042
//--- DROPBITS(here.bits) ---// // 7043
hold >>>= here_bits; // 7044
bits -= here_bits; // 7045
//---// // 7046
if (state.have === 0) { // 7047
strm.msg = 'invalid bit length repeat'; // 7048
state.mode = BAD; // 7049
break; // 7050
} // 7051
len = state.lens[state.have - 1]; // 7052
copy = 3 + (hold & 0x03);//BITS(2); // 7053
//--- DROPBITS(2) ---// // 7054
hold >>>= 2; // 7055
bits -= 2; // 7056
//---// // 7057
} // 7058
else if (here_val === 17) { // 7059
//=== NEEDBITS(here.bits + 3); // 7060
n = here_bits + 3; // 7061
while (bits < n) { // 7062
if (have === 0) { break inf_leave; } // 7063
have--; // 7064
hold += input[next++] << bits; // 7065
bits += 8; // 7066
} // 7067
//===// // 7068
//--- DROPBITS(here.bits) ---// // 7069
hold >>>= here_bits; // 7070
bits -= here_bits; // 7071
//---// // 7072
len = 0; // 7073
copy = 3 + (hold & 0x07);//BITS(3); // 7074
//--- DROPBITS(3) ---// // 7075
hold >>>= 3; // 7076
bits -= 3; // 7077
//---// // 7078
} // 7079
else { // 7080
//=== NEEDBITS(here.bits + 7); // 7081
n = here_bits + 7; // 7082
while (bits < n) { // 7083
if (have === 0) { break inf_leave; } // 7084
have--; // 7085
hold += input[next++] << bits; // 7086
bits += 8; // 7087
} // 7088
//===// // 7089
//--- DROPBITS(here.bits) ---// // 7090
hold >>>= here_bits; // 7091
bits -= here_bits; // 7092
//---// // 7093
len = 0; // 7094
copy = 11 + (hold & 0x7f);//BITS(7); // 7095
//--- DROPBITS(7) ---// // 7096
hold >>>= 7; // 7097
bits -= 7; // 7098
//---// // 7099
} // 7100
if (state.have + copy > state.nlen + state.ndist) { // 7101
strm.msg = 'invalid bit length repeat'; // 7102
state.mode = BAD; // 7103
break; // 7104
} // 7105
while (copy--) { // 7106
state.lens[state.have++] = len; // 7107
} // 7108
} // 7109
} // 7110
// 7111
/* handle error breaks in while */ // 7112
if (state.mode === BAD) { break; } // 7113
// 7114
/* check for end-of-block code (better have one) */ // 7115
if (state.lens[256] === 0) { // 7116
strm.msg = 'invalid code -- missing end-of-block'; // 7117
state.mode = BAD; // 7118
break; // 7119
} // 7120
// 7121
/* build code tables -- note: do not change the lenbits or distbits // 7122
values here (9 and 6) without reading the comments in inftrees.h // 7123
concerning the ENOUGH constants, which depend on those values */ // 7124
state.lenbits = 9; // 7125
// 7126
opts = {bits: state.lenbits}; // 7127
ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); // 7128
// We have separate tables & no pointers. 2 commented lines below not needed. // 7129
// state.next_index = opts.table_index; // 7130
state.lenbits = opts.bits; // 7131
// state.lencode = state.next; // 7132
// 7133
if (ret) { // 7134
strm.msg = 'invalid literal/lengths set'; // 7135
state.mode = BAD; // 7136
break; // 7137
} // 7138
// 7139
state.distbits = 6; // 7140
//state.distcode.copy(state.codes); // 7141
// Switch to use dynamic table // 7142
state.distcode = state.distdyn; // 7143
opts = {bits: state.distbits}; // 7144
ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); // 7145
// We have separate tables & no pointers. 2 commented lines below not needed. // 7146
// state.next_index = opts.table_index; // 7147
state.distbits = opts.bits; // 7148
// state.distcode = state.next; // 7149
// 7150
if (ret) { // 7151
strm.msg = 'invalid distances set'; // 7152
state.mode = BAD; // 7153
break; // 7154
} // 7155
//Tracev((stderr, 'inflate: codes ok\n')); // 7156
state.mode = LEN_; // 7157
if (flush === Z_TREES) { break inf_leave; } // 7158
/* falls through */ // 7159
case LEN_: // 7160
state.mode = LEN; // 7161
/* falls through */ // 7162
case LEN: // 7163
if (have >= 6 && left >= 258) { // 7164
//--- RESTORE() --- // 7165
strm.next_out = put; // 7166
strm.avail_out = left; // 7167
strm.next_in = next; // 7168
strm.avail_in = have; // 7169
state.hold = hold; // 7170
state.bits = bits; // 7171
//--- // 7172
inflate_fast(strm, _out); // 7173
//--- LOAD() --- // 7174
put = strm.next_out; // 7175
output = strm.output; // 7176
left = strm.avail_out; // 7177
next = strm.next_in; // 7178
input = strm.input; // 7179
have = strm.avail_in; // 7180
hold = state.hold; // 7181
bits = state.bits; // 7182
//--- // 7183
// 7184
if (state.mode === TYPE) { // 7185
state.back = -1; // 7186
} // 7187
break; // 7188
} // 7189
state.back = 0; // 7190
for (;;) { // 7191
here = state.lencode[hold & ((1 << state.lenbits) -1)]; /*BITS(state.lenbits)*/ // 7192
here_bits = here >>> 24; // 7193
here_op = (here >>> 16) & 0xff; // 7194
here_val = here & 0xffff; // 7195
// 7196
if (here_bits <= bits) { break; } // 7197
//--- PULLBYTE() ---// // 7198
if (have === 0) { break inf_leave; } // 7199
have--; // 7200
hold += input[next++] << bits; // 7201
bits += 8; // 7202
//---// // 7203
} // 7204
if (here_op && (here_op & 0xf0) === 0) { // 7205
last_bits = here_bits; // 7206
last_op = here_op; // 7207
last_val = here_val; // 7208
for (;;) { // 7209
here = state.lencode[last_val + // 7210
((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)]; // 7211
here_bits = here >>> 24; // 7212
here_op = (here >>> 16) & 0xff; // 7213
here_val = here & 0xffff; // 7214
// 7215
if ((last_bits + here_bits) <= bits) { break; } // 7216
//--- PULLBYTE() ---// // 7217
if (have === 0) { break inf_leave; } // 7218
have--; // 7219
hold += input[next++] << bits; // 7220
bits += 8; // 7221
//---// // 7222
} // 7223
//--- DROPBITS(last.bits) ---// // 7224
hold >>>= last_bits; // 7225
bits -= last_bits; // 7226
//---// // 7227
state.back += last_bits; // 7228
} // 7229
//--- DROPBITS(here.bits) ---// // 7230
hold >>>= here_bits; // 7231
bits -= here_bits; // 7232
//---// // 7233
state.back += here_bits; // 7234
state.length = here_val; // 7235
if (here_op === 0) { // 7236
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? // 7237
// "inflate: literal '%c'\n" : // 7238
// "inflate: literal 0x%02x\n", here.val)); // 7239
state.mode = LIT; // 7240
break; // 7241
} // 7242
if (here_op & 32) { // 7243
//Tracevv((stderr, "inflate: end of block\n")); // 7244
state.back = -1; // 7245
state.mode = TYPE; // 7246
break; // 7247
} // 7248
if (here_op & 64) { // 7249
strm.msg = 'invalid literal/length code'; // 7250
state.mode = BAD; // 7251
break; // 7252
} // 7253
state.extra = here_op & 15; // 7254
state.mode = LENEXT; // 7255
/* falls through */ // 7256
case LENEXT: // 7257
if (state.extra) { // 7258
//=== NEEDBITS(state.extra); // 7259
n = state.extra; // 7260
while (bits < n) { // 7261
if (have === 0) { break inf_leave; } // 7262
have--; // 7263
hold += input[next++] << bits; // 7264
bits += 8; // 7265
} // 7266
//===// // 7267
state.length += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/; // 7268
//--- DROPBITS(state.extra) ---// // 7269
hold >>>= state.extra; // 7270
bits -= state.extra; // 7271
//---// // 7272
state.back += state.extra; // 7273
} // 7274
//Tracevv((stderr, "inflate: length %u\n", state.length)); // 7275
state.was = state.length; // 7276
state.mode = DIST; // 7277
/* falls through */ // 7278
case DIST: // 7279
for (;;) { // 7280
here = state.distcode[hold & ((1 << state.distbits) -1)];/*BITS(state.distbits)*/ // 7281
here_bits = here >>> 24; // 7282
here_op = (here >>> 16) & 0xff; // 7283
here_val = here & 0xffff; // 7284
// 7285
if ((here_bits) <= bits) { break; } // 7286
//--- PULLBYTE() ---// // 7287
if (have === 0) { break inf_leave; } // 7288
have--; // 7289
hold += input[next++] << bits; // 7290
bits += 8; // 7291
//---// // 7292
} // 7293
if ((here_op & 0xf0) === 0) { // 7294
last_bits = here_bits; // 7295
last_op = here_op; // 7296
last_val = here_val; // 7297
for (;;) { // 7298
here = state.distcode[last_val + // 7299
((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)]; // 7300
here_bits = here >>> 24; // 7301
here_op = (here >>> 16) & 0xff; // 7302
here_val = here & 0xffff; // 7303
// 7304
if ((last_bits + here_bits) <= bits) { break; } // 7305
//--- PULLBYTE() ---// // 7306
if (have === 0) { break inf_leave; } // 7307
have--; // 7308
hold += input[next++] << bits; // 7309
bits += 8; // 7310
//---// // 7311
} // 7312
//--- DROPBITS(last.bits) ---// // 7313
hold >>>= last_bits; // 7314
bits -= last_bits; // 7315
//---// // 7316
state.back += last_bits; // 7317
} // 7318
//--- DROPBITS(here.bits) ---// // 7319
hold >>>= here_bits; // 7320
bits -= here_bits; // 7321
//---// // 7322
state.back += here_bits; // 7323
if (here_op & 64) { // 7324
strm.msg = 'invalid distance code'; // 7325
state.mode = BAD; // 7326
break; // 7327
} // 7328
state.offset = here_val; // 7329
state.extra = (here_op) & 15; // 7330
state.mode = DISTEXT; // 7331
/* falls through */ // 7332
case DISTEXT: // 7333
if (state.extra) { // 7334
//=== NEEDBITS(state.extra); // 7335
n = state.extra; // 7336
while (bits < n) { // 7337
if (have === 0) { break inf_leave; } // 7338
have--; // 7339
hold += input[next++] << bits; // 7340
bits += 8; // 7341
} // 7342
//===// // 7343
state.offset += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/; // 7344
//--- DROPBITS(state.extra) ---// // 7345
hold >>>= state.extra; // 7346
bits -= state.extra; // 7347
//---// // 7348
state.back += state.extra; // 7349
} // 7350
//#ifdef INFLATE_STRICT // 7351
if (state.offset > state.dmax) { // 7352
strm.msg = 'invalid distance too far back'; // 7353
state.mode = BAD; // 7354
break; // 7355
} // 7356
//#endif // 7357
//Tracevv((stderr, "inflate: distance %u\n", state.offset)); // 7358
state.mode = MATCH; // 7359
/* falls through */ // 7360
case MATCH: // 7361
if (left === 0) { break inf_leave; } // 7362
copy = _out - left; // 7363
if (state.offset > copy) { /* copy from window */ // 7364
copy = state.offset - copy; // 7365
if (copy > state.whave) { // 7366
if (state.sane) { // 7367
strm.msg = 'invalid distance too far back'; // 7368
state.mode = BAD; // 7369
break; // 7370
} // 7371
// (!) This block is disabled in zlib defailts, // 7372
// don't enable it for binary compatibility // 7373
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR // 7374
// Trace((stderr, "inflate.c too far\n")); // 7375
// copy -= state.whave; // 7376
// if (copy > state.length) { copy = state.length; } // 7377
// if (copy > left) { copy = left; } // 7378
// left -= copy; // 7379
// state.length -= copy; // 7380
// do { // 7381
// output[put++] = 0; // 7382
// } while (--copy); // 7383
// if (state.length === 0) { state.mode = LEN; } // 7384
// break; // 7385
//#endif // 7386
} // 7387
if (copy > state.wnext) { // 7388
copy -= state.wnext; // 7389
from = state.wsize - copy; // 7390
} // 7391
else { // 7392
from = state.wnext - copy; // 7393
} // 7394
if (copy > state.length) { copy = state.length; } // 7395
from_source = state.window; // 7396
} // 7397
else { /* copy from output */ // 7398
from_source = output; // 7399
from = put - state.offset; // 7400
copy = state.length; // 7401
} // 7402
if (copy > left) { copy = left; } // 7403
left -= copy; // 7404
state.length -= copy; // 7405
do { // 7406
output[put++] = from_source[from++]; // 7407
} while (--copy); // 7408
if (state.length === 0) { state.mode = LEN; } // 7409
break; // 7410
case LIT: // 7411
if (left === 0) { break inf_leave; } // 7412
output[put++] = state.length; // 7413
left--; // 7414
state.mode = LEN; // 7415
break; // 7416
case CHECK: // 7417
if (state.wrap) { // 7418
//=== NEEDBITS(32); // 7419
while (bits < 32) { // 7420
if (have === 0) { break inf_leave; } // 7421
have--; // 7422
// Use '|' insdead of '+' to make sure that result is signed // 7423
hold |= input[next++] << bits; // 7424
bits += 8; // 7425
} // 7426
//===// // 7427
_out -= left; // 7428
strm.total_out += _out; // 7429
state.total += _out; // 7430
if (_out) { // 7431
strm.adler = state.check = // 7432
/*UPDATE(state.check, put - _out, _out);*/ // 7433
(state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
// 7435
} // 7436
_out = left; // 7437
// NB: crc32 stored as signed 32-bit int, ZSWAP32 returns signed too // 7438
if ((state.flags ? hold : ZSWAP32(hold)) !== state.check) { // 7439
strm.msg = 'incorrect data check'; // 7440
state.mode = BAD; // 7441
break; // 7442
} // 7443
//=== INITBITS(); // 7444
hold = 0; // 7445
bits = 0; // 7446
//===// // 7447
//Tracev((stderr, "inflate: check matches trailer\n")); // 7448
} // 7449
state.mode = LENGTH; // 7450
/* falls through */ // 7451
case LENGTH: // 7452
if (state.wrap && state.flags) { // 7453
//=== NEEDBITS(32); // 7454
while (bits < 32) { // 7455
if (have === 0) { break inf_leave; } // 7456
have--; // 7457
hold += input[next++] << bits; // 7458
bits += 8; // 7459
} // 7460
//===// // 7461
if (hold !== (state.total & 0xffffffff)) { // 7462
strm.msg = 'incorrect length check'; // 7463
state.mode = BAD; // 7464
break; // 7465
} // 7466
//=== INITBITS(); // 7467
hold = 0; // 7468
bits = 0; // 7469
//===// // 7470
//Tracev((stderr, "inflate: length matches trailer\n")); // 7471
} // 7472
state.mode = DONE; // 7473
/* falls through */ // 7474
case DONE: // 7475
ret = Z_STREAM_END; // 7476
break inf_leave; // 7477
case BAD: // 7478
ret = Z_DATA_ERROR; // 7479
break inf_leave; // 7480
case MEM: // 7481
return Z_MEM_ERROR; // 7482
case SYNC: // 7483
/* falls through */ // 7484
default: // 7485
return Z_STREAM_ERROR; // 7486
} // 7487
} // 7488
// 7489
// inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave" // 7490
// 7491
/* // 7492
Return from inflate(), updating the total counts and the check value. // 7493
If there was no progress during the inflate() call, return a buffer // 7494
error. Call updatewindow() to create and/or update the window state. // 7495
Note: a memory error from inflate() is non-recoverable. // 7496
*/ // 7497
// 7498
//--- RESTORE() --- // 7499
strm.next_out = put; // 7500
strm.avail_out = left; // 7501
strm.next_in = next; // 7502
strm.avail_in = have; // 7503
state.hold = hold; // 7504
state.bits = bits; // 7505
//--- // 7506
// 7507
if (state.wsize || (_out !== strm.avail_out && state.mode < BAD && // 7508
(state.mode < CHECK || flush !== Z_FINISH))) { // 7509
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { // 7510
state.mode = MEM; // 7511
return Z_MEM_ERROR; // 7512
} // 7513
} // 7514
_in -= strm.avail_in; // 7515
_out -= strm.avail_out; // 7516
strm.total_in += _in; // 7517
strm.total_out += _out; // 7518
state.total += _out; // 7519
if (state.wrap && _out) { // 7520
strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/ // 7521
(state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
} // 7523
strm.data_type = state.bits + (state.last ? 64 : 0) + // 7524
(state.mode === TYPE ? 128 : 0) + // 7525
(state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); // 7526
if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) { // 7527
ret = Z_BUF_ERROR; // 7528
} // 7529
return ret; // 7530
} // 7531
// 7532
function inflateEnd(strm) { // 7533
// 7534
if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) { // 7535
return Z_STREAM_ERROR; // 7536
} // 7537
// 7538
var state = strm.state; // 7539
if (state.window) { // 7540
state.window = null; // 7541
} // 7542
strm.state = null; // 7543
return Z_OK; // 7544
} // 7545
// 7546
function inflateGetHeader(strm, head) { // 7547
var state; // 7548
// 7549
/* check state */ // 7550
if (!strm || !strm.state) { return Z_STREAM_ERROR; } // 7551
state = strm.state; // 7552
if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; } // 7553
// 7554
/* save header structure */ // 7555
state.head = head; // 7556
head.done = false; // 7557
return Z_OK; // 7558
} // 7559
// 7560
// 7561
exports.inflateReset = inflateReset; // 7562
exports.inflateReset2 = inflateReset2; // 7563
exports.inflateResetKeep = inflateResetKeep; // 7564
exports.inflateInit = inflateInit; // 7565
exports.inflateInit2 = inflateInit2; // 7566
exports.inflate = inflate; // 7567
exports.inflateEnd = inflateEnd; // 7568
exports.inflateGetHeader = inflateGetHeader; // 7569
exports.inflateInfo = 'pako inflate (from Nodeca project)'; // 7570
// 7571
/* Not implemented // 7572
exports.inflateCopy = inflateCopy; // 7573
exports.inflateGetDictionary = inflateGetDictionary; // 7574
exports.inflateMark = inflateMark; // 7575
exports.inflatePrime = inflatePrime; // 7576
exports.inflateSetDictionary = inflateSetDictionary; // 7577
exports.inflateSync = inflateSync; // 7578
exports.inflateSyncPoint = inflateSyncPoint; // 7579
exports.inflateUndermine = inflateUndermine; // 7580
*/ // 7581
},{"../utils/common":27,"./adler32":29,"./crc32":31,"./inffast":34,"./inftrees":36}],36:[function(_dereq_,module,exports){
'use strict'; // 7583
// 7584
// 7585
var utils = _dereq_('../utils/common'); // 7586
// 7587
var MAXBITS = 15; // 7588
var ENOUGH_LENS = 852; // 7589
var ENOUGH_DISTS = 592; // 7590
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); // 7591
// 7592
var CODES = 0; // 7593
var LENS = 1; // 7594
var DISTS = 2; // 7595
// 7596
var lbase = [ /* Length codes 257..285 base */ // 7597
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, // 7598
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 // 7599
]; // 7600
// 7601
var lext = [ /* Length codes 257..285 extra */ // 7602
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, // 7603
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78 // 7604
]; // 7605
// 7606
var dbase = [ /* Distance codes 0..29 base */ // 7607
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, // 7608
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, // 7609
8193, 12289, 16385, 24577, 0, 0 // 7610
]; // 7611
// 7612
var dext = [ /* Distance codes 0..29 extra */ // 7613
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, // 7614
23, 23, 24, 24, 25, 25, 26, 26, 27, 27, // 7615
28, 28, 29, 29, 64, 64 // 7616
]; // 7617
// 7618
module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) // 7619
{ // 7620
var bits = opts.bits; // 7621
//here = opts.here; /* table entry for duplication */ // 7622
// 7623
var len = 0; /* a code's length in bits */ // 7624
var sym = 0; /* index of code symbols */ // 7625
var min = 0, max = 0; /* minimum and maximum code lengths */ // 7626
var root = 0; /* number of index bits for root table */ // 7627
var curr = 0; /* number of index bits for current table */ // 7628
var drop = 0; /* code bits to drop for sub-table */ // 7629
var left = 0; /* number of prefix codes available */ // 7630
var used = 0; /* code entries in table used */ // 7631
var huff = 0; /* Huffman code */ // 7632
var incr; /* for incrementing code, index */ // 7633
var fill; /* index for replicating entries */ // 7634
var low; /* low bits for current root entry */ // 7635
var mask; /* mask for low root bits */ // 7636
var next; /* next available space in table */ // 7637
var base = null; /* base value table to use */ // 7638
var base_index = 0; // 7639
// var shoextra; /* extra bits table to use */ // 7640
var end; /* use base and extra for symbol > end */ // 7641
var count = new utils.Buf16(MAXBITS+1); //[MAXBITS+1]; /* number of codes of each length */ // 7642
var offs = new utils.Buf16(MAXBITS+1); //[MAXBITS+1]; /* offsets in table for each length */ // 7643
var extra = null; // 7644
var extra_index = 0; // 7645
// 7646
var here_bits, here_op, here_val; // 7647
// 7648
/* // 7649
Process a set of code lengths to create a canonical Huffman code. The // 7650
code lengths are lens[0..codes-1]. Each length corresponds to the // 7651
symbols 0..codes-1. The Huffman code is generated by first sorting the // 7652
symbols by length from short to long, and retaining the symbol order // 7653
for codes with equal lengths. Then the code starts with all zero bits // 7654
for the first code of the shortest length, and the codes are integer // 7655
increments for the same length, and zeros are appended as the length // 7656
increases. For the deflate format, these bits are stored backwards // 7657
from their more natural integer increment ordering, and so when the // 7658
decoding tables are built in the large loop below, the integer codes // 7659
are incremented backwards. // 7660
// 7661
This routine assumes, but does not check, that all of the entries in // 7662
lens[] are in the range 0..MAXBITS. The caller must assure this. // 7663
1..MAXBITS is interpreted as that code length. zero means that that // 7664
symbol does not occur in this code. // 7665
// 7666
The codes are sorted by computing a count of codes for each length, // 7667
creating from that a table of starting indices for each length in the // 7668
sorted table, and then entering the symbols in order in the sorted // 7669
table. The sorted table is work[], with that space being provided by // 7670
the caller. // 7671
// 7672
The length counts are used for other purposes as well, i.e. finding // 7673
the minimum and maximum length codes, determining if there are any // 7674
codes at all, checking for a valid set of lengths, and looking ahead // 7675
at length counts to determine sub-table sizes when building the // 7676
decoding tables. // 7677
*/ // 7678
// 7679
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ // 7680
for (len = 0; len <= MAXBITS; len++) { // 7681
count[len] = 0; // 7682
} // 7683
for (sym = 0; sym < codes; sym++) { // 7684
count[lens[lens_index + sym]]++; // 7685
} // 7686
// 7687
/* bound code lengths, force root to be within code lengths */ // 7688
root = bits; // 7689
for (max = MAXBITS; max >= 1; max--) { // 7690
if (count[max] !== 0) { break; } // 7691
} // 7692
if (root > max) { // 7693
root = max; // 7694
} // 7695
if (max === 0) { /* no symbols to code at all */ // 7696
//table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */ // 7697
//table.bits[opts.table_index] = 1; //here.bits = (var char)1; // 7698
//table.val[opts.table_index++] = 0; //here.val = (var short)0; // 7699
table[table_index++] = (1 << 24) | (64 << 16) | 0; // 7700
// 7701
// 7702
//table.op[opts.table_index] = 64; // 7703
//table.bits[opts.table_index] = 1; // 7704
//table.val[opts.table_index++] = 0; // 7705
table[table_index++] = (1 << 24) | (64 << 16) | 0; // 7706
// 7707
opts.bits = 1; // 7708
return 0; /* no symbols, but wait for decoding to report error */ // 7709
} // 7710
for (min = 1; min < max; min++) { // 7711
if (count[min] !== 0) { break; } // 7712
} // 7713
if (root < min) { // 7714
root = min; // 7715
} // 7716
// 7717
/* check for an over-subscribed or incomplete set of lengths */ // 7718
left = 1; // 7719
for (len = 1; len <= MAXBITS; len++) { // 7720
left <<= 1; // 7721
left -= count[len]; // 7722
if (left < 0) { // 7723
return -1; // 7724
} /* over-subscribed */ // 7725
} // 7726
if (left > 0 && (type === CODES || max !== 1)) { // 7727
return -1; /* incomplete set */ // 7728
} // 7729
// 7730
/* generate offsets into symbol table for each length for sorting */ // 7731
offs[1] = 0; // 7732
for (len = 1; len < MAXBITS; len++) { // 7733
offs[len + 1] = offs[len] + count[len]; // 7734
} // 7735
// 7736
/* sort symbols by length, by symbol order within each length */ // 7737
for (sym = 0; sym < codes; sym++) { // 7738
if (lens[lens_index + sym] !== 0) { // 7739
work[offs[lens[lens_index + sym]]++] = sym; // 7740
} // 7741
} // 7742
// 7743
/* // 7744
Create and fill in decoding tables. In this loop, the table being // 7745
filled is at next and has curr index bits. The code being used is huff // 7746
with length len. That code is converted to an index by dropping drop // 7747
bits off of the bottom. For codes where len is less than drop + curr, // 7748
those top drop + curr - len bits are incremented through all values to // 7749
fill the table with replicated entries. // 7750
// 7751
root is the number of index bits for the root table. When len exceeds // 7752
root, sub-tables are created pointed to by the root entry with an index // 7753
of the low root bits of huff. This is saved in low to check for when a // 7754
new sub-table should be started. drop is zero when the root table is // 7755
being filled, and drop is root when sub-tables are being filled. // 7756
// 7757
When a new sub-table is needed, it is necessary to look ahead in the // 7758
code lengths to determine what size sub-table is needed. The length // 7759
counts are used for this, and so count[] is decremented as codes are // 7760
entered in the tables. // 7761
// 7762
used keeps track of how many table entries have been allocated from the // 7763
provided *table space. It is checked for LENS and DIST tables against // 7764
the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in // 7765
the initial root table size constants. See the comments in inftrees.h // 7766
for more information. // 7767
// 7768
sym increments through all symbols, and the loop terminates when // 7769
all codes of length max, i.e. all codes, have been processed. This // 7770
routine permits incomplete codes, so another loop after this one fills // 7771
in the rest of the decoding tables with invalid code markers. // 7772
*/ // 7773
// 7774
/* set up for code type */ // 7775
// poor man optimization - use if-else instead of switch, // 7776
// to avoid deopts in old v8 // 7777
if (type === CODES) { // 7778
base = extra = work; /* dummy value--not used */ // 7779
end = 19; // 7780
} else if (type === LENS) { // 7781
base = lbase; // 7782
base_index -= 257; // 7783
extra = lext; // 7784
extra_index -= 257; // 7785
end = 256; // 7786
} else { /* DISTS */ // 7787
base = dbase; // 7788
extra = dext; // 7789
end = -1; // 7790
} // 7791
// 7792
/* initialize opts for loop */ // 7793
huff = 0; /* starting code */ // 7794
sym = 0; /* starting code symbol */ // 7795
len = min; /* starting code length */ // 7796
next = table_index; /* current table to fill in */ // 7797
curr = root; /* current table index bits */ // 7798
drop = 0; /* current bits to drop from code for index */ // 7799
low = -1; /* trigger new sub-table when len > root */ // 7800
used = 1 << root; /* use root table entries */ // 7801
mask = used - 1; /* mask for comparing low */ // 7802
// 7803
/* check available table space */ // 7804
if ((type === LENS && used > ENOUGH_LENS) || // 7805
(type === DISTS && used > ENOUGH_DISTS)) { // 7806
return 1; // 7807
} // 7808
// 7809
var i=0; // 7810
/* process all codes and make table entries */ // 7811
for (;;) { // 7812
i++; // 7813
/* create table entry */ // 7814
here_bits = len - drop; // 7815
if (work[sym] < end) { // 7816
here_op = 0; // 7817
here_val = work[sym]; // 7818
} // 7819
else if (work[sym] > end) { // 7820
here_op = extra[extra_index + work[sym]]; // 7821
here_val = base[base_index + work[sym]]; // 7822
} // 7823
else { // 7824
here_op = 32 + 64; /* end of block */ // 7825
here_val = 0; // 7826
} // 7827
// 7828
/* replicate for those indices with low len bits equal to huff */ // 7829
incr = 1 << (len - drop); // 7830
fill = 1 << curr; // 7831
min = fill; /* save offset to next table */ // 7832
do { // 7833
fill -= incr; // 7834
table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0; // 7835
} while (fill !== 0); // 7836
// 7837
/* backwards increment the len-bit code huff */ // 7838
incr = 1 << (len - 1); // 7839
while (huff & incr) { // 7840
incr >>= 1; // 7841
} // 7842
if (incr !== 0) { // 7843
huff &= incr - 1; // 7844
huff += incr; // 7845
} else { // 7846
huff = 0; // 7847
} // 7848
// 7849
/* go to next symbol, update count, len */ // 7850
sym++; // 7851
if (--count[len] === 0) { // 7852
if (len === max) { break; } // 7853
len = lens[lens_index + work[sym]]; // 7854
} // 7855
// 7856
/* create new sub-table if needed */ // 7857
if (len > root && (huff & mask) !== low) { // 7858
/* if first time, transition to sub-tables */ // 7859
if (drop === 0) { // 7860
drop = root; // 7861
} // 7862
// 7863
/* increment past last table */ // 7864
next += min; /* here min is 1 << curr */ // 7865
// 7866
/* determine length of next table */ // 7867
curr = len - drop; // 7868
left = 1 << curr; // 7869
while (curr + drop < max) { // 7870
left -= count[curr + drop]; // 7871
if (left <= 0) { break; } // 7872
curr++; // 7873
left <<= 1; // 7874
} // 7875
// 7876
/* check for enough space */ // 7877
used += 1 << curr; // 7878
if ((type === LENS && used > ENOUGH_LENS) || // 7879
(type === DISTS && used > ENOUGH_DISTS)) { // 7880
return 1; // 7881
} // 7882
// 7883
/* point entry in root table to sub-table */ // 7884
low = huff & mask; // 7885
/*table.op[low] = curr; // 7886
table.bits[low] = root; // 7887
table.val[low] = next - opts.table_index;*/ // 7888
table[low] = (root << 24) | (curr << 16) | (next - table_index) |0; // 7889
} // 7890
} // 7891
// 7892
/* fill in remaining table entry if code is incomplete (guaranteed to have // 7893
at most one remaining entry, since if the code is incomplete, the // 7894
maximum code length that was allowed to get this far is one bit) */ // 7895
if (huff !== 0) { // 7896
//table.op[next + huff] = 64; /* invalid code marker */ // 7897
//table.bits[next + huff] = len - drop; // 7898
//table.val[next + huff] = 0; // 7899
table[next + huff] = ((len - drop) << 24) | (64 << 16) |0; // 7900
} // 7901
// 7902
/* set return parameters */ // 7903
//opts.table_index += used; // 7904
opts.bits = root; // 7905
return 0; // 7906
}; // 7907
// 7908
},{"../utils/common":27}],37:[function(_dereq_,module,exports){ // 7909
'use strict'; // 7910
// 7911
module.exports = { // 7912
'2': 'need dictionary', /* Z_NEED_DICT 2 */ // 7913
'1': 'stream end', /* Z_STREAM_END 1 */ // 7914
'0': '', /* Z_OK 0 */ // 7915
'-1': 'file error', /* Z_ERRNO (-1) */ // 7916
'-2': 'stream error', /* Z_STREAM_ERROR (-2) */ // 7917
'-3': 'data error', /* Z_DATA_ERROR (-3) */ // 7918
'-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */ // 7919
'-5': 'buffer error', /* Z_BUF_ERROR (-5) */ // 7920
'-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */ // 7921
}; // 7922
},{}],38:[function(_dereq_,module,exports){ // 7923
'use strict'; // 7924
// 7925
// 7926
var utils = _dereq_('../utils/common'); // 7927
// 7928
/* Public constants ==========================================================*/ // 7929
/* ===========================================================================*/ // 7930
// 7931
// 7932
//var Z_FILTERED = 1; // 7933
//var Z_HUFFMAN_ONLY = 2; // 7934
//var Z_RLE = 3; // 7935
var Z_FIXED = 4; // 7936
//var Z_DEFAULT_STRATEGY = 0; // 7937
// 7938
/* Possible values of the data_type field (though see inflate()) */ // 7939
var Z_BINARY = 0; // 7940
var Z_TEXT = 1; // 7941
//var Z_ASCII = 1; // = Z_TEXT // 7942
var Z_UNKNOWN = 2; // 7943
// 7944
/*============================================================================*/ // 7945
// 7946
// 7947
function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } // 7948
// 7949
// From zutil.h // 7950
// 7951
var STORED_BLOCK = 0; // 7952
var STATIC_TREES = 1; // 7953
var DYN_TREES = 2; // 7954
/* The three kinds of block type */ // 7955
// 7956
var MIN_MATCH = 3; // 7957
var MAX_MATCH = 258; // 7958
/* The minimum and maximum match lengths */ // 7959
// 7960
// From deflate.h // 7961
/* =========================================================================== // 7962
* Internal compression state. // 7963
*/ // 7964
// 7965
var LENGTH_CODES = 29; // 7966
/* number of length codes, not counting the special END_BLOCK code */ // 7967
// 7968
var LITERALS = 256; // 7969
/* number of literal bytes 0..255 */ // 7970
// 7971
var L_CODES = LITERALS + 1 + LENGTH_CODES; // 7972
/* number of Literal or Length codes, including the END_BLOCK code */ // 7973
// 7974
var D_CODES = 30; // 7975
/* number of distance codes */ // 7976
// 7977
var BL_CODES = 19; // 7978
/* number of codes used to transfer the bit lengths */ // 7979
// 7980
var HEAP_SIZE = 2*L_CODES + 1; // 7981
/* maximum heap size */ // 7982
// 7983
var MAX_BITS = 15; // 7984
/* All codes must not exceed MAX_BITS bits */ // 7985
// 7986
var Buf_size = 16; // 7987
/* size of bit buffer in bi_buf */ // 7988
// 7989
// 7990
/* =========================================================================== // 7991
* Constants // 7992
*/ // 7993
// 7994
var MAX_BL_BITS = 7; // 7995
/* Bit length codes must not exceed MAX_BL_BITS bits */ // 7996
// 7997
var END_BLOCK = 256; // 7998
/* end of block literal code */ // 7999
// 8000
var REP_3_6 = 16; // 8001
/* repeat previous bit length 3-6 times (2 bits of repeat count) */ // 8002
// 8003
var REPZ_3_10 = 17; // 8004
/* repeat a zero length 3-10 times (3 bits of repeat count) */ // 8005
// 8006
var REPZ_11_138 = 18; // 8007
/* repeat a zero length 11-138 times (7 bits of repeat count) */ // 8008
// 8009
var extra_lbits = /* extra bits for each length code */ // 8010
[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]; // 8011
// 8012
var extra_dbits = /* extra bits for each distance code */ // 8013
[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]; // 8014
// 8015
var extra_blbits = /* extra bits for each bit length code */ // 8016
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]; // 8017
// 8018
var bl_order = // 8019
[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]; // 8020
/* The lengths of the bit length codes are sent in order of decreasing // 8021
* probability, to avoid transmitting the lengths for unused bit length codes. // 8022
*/ // 8023
// 8024
/* =========================================================================== // 8025
* Local data. These are initialized only once. // 8026
*/ // 8027
// 8028
// We pre-fill arrays with 0 to avoid uninitialized gaps // 8029
// 8030
var DIST_CODE_LEN = 512; /* see definition of array dist_code below */ // 8031
// 8032
// !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1 // 8033
var static_ltree = new Array((L_CODES+2) * 2); // 8034
zero(static_ltree); // 8035
/* The static literal tree. Since the bit lengths are imposed, there is no // 8036
* need for the L_CODES extra codes used during heap construction. However // 8037
* The codes 286 and 287 are needed to build a canonical tree (see _tr_init // 8038
* below). // 8039
*/ // 8040
// 8041
var static_dtree = new Array(D_CODES * 2); // 8042
zero(static_dtree); // 8043
/* The static distance tree. (Actually a trivial tree since all codes use // 8044
* 5 bits.) // 8045
*/ // 8046
// 8047
var _dist_code = new Array(DIST_CODE_LEN); // 8048
zero(_dist_code); // 8049
/* Distance codes. The first 256 values correspond to the distances // 8050
* 3 .. 258, the last 256 values correspond to the top 8 bits of // 8051
* the 15 bit distances. // 8052
*/ // 8053
// 8054
var _length_code = new Array(MAX_MATCH-MIN_MATCH+1); // 8055
zero(_length_code); // 8056
/* length code for each normalized match length (0 == MIN_MATCH) */ // 8057
// 8058
var base_length = new Array(LENGTH_CODES); // 8059
zero(base_length); // 8060
/* First normalized length for each code (0 = MIN_MATCH) */ // 8061
// 8062
var base_dist = new Array(D_CODES); // 8063
zero(base_dist); // 8064
/* First normalized distance for each code (0 = distance of 1) */ // 8065
// 8066
// 8067
var StaticTreeDesc = function (static_tree, extra_bits, extra_base, elems, max_length) { // 8068
// 8069
this.static_tree = static_tree; /* static tree or NULL */ // 8070
this.extra_bits = extra_bits; /* extra bits for each code or NULL */ // 8071
this.extra_base = extra_base; /* base index for extra_bits */ // 8072
this.elems = elems; /* max number of elements in the tree */ // 8073
this.max_length = max_length; /* max bit length for the codes */ // 8074
// 8075
// show if `static_tree` has data or dummy - needed for monomorphic objects // 8076
this.has_stree = static_tree && static_tree.length; // 8077
}; // 8078
// 8079
// 8080
var static_l_desc; // 8081
var static_d_desc; // 8082
var static_bl_desc; // 8083
// 8084
// 8085
var TreeDesc = function(dyn_tree, stat_desc) { // 8086
this.dyn_tree = dyn_tree; /* the dynamic tree */ // 8087
this.max_code = 0; /* largest code with non zero frequency */ // 8088
this.stat_desc = stat_desc; /* the corresponding static tree */ // 8089
}; // 8090
// 8091
// 8092
// 8093
function d_code(dist) { // 8094
return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; // 8095
} // 8096
// 8097
// 8098
/* =========================================================================== // 8099
* Output a short LSB first on the stream. // 8100
* IN assertion: there is enough room in pendingBuf. // 8101
*/ // 8102
function put_short (s, w) { // 8103
// put_byte(s, (uch)((w) & 0xff)); // 8104
// put_byte(s, (uch)((ush)(w) >> 8)); // 8105
s.pending_buf[s.pending++] = (w) & 0xff; // 8106
s.pending_buf[s.pending++] = (w >>> 8) & 0xff; // 8107
} // 8108
// 8109
// 8110
/* =========================================================================== // 8111
* Send a value on a given number of bits. // 8112
* IN assertion: length <= 16 and value fits in length bits. // 8113
*/ // 8114
function send_bits(s, value, length) { // 8115
if (s.bi_valid > (Buf_size - length)) { // 8116
s.bi_buf |= (value << s.bi_valid) & 0xffff; // 8117
put_short(s, s.bi_buf); // 8118
s.bi_buf = value >> (Buf_size - s.bi_valid); // 8119
s.bi_valid += length - Buf_size; // 8120
} else { // 8121
s.bi_buf |= (value << s.bi_valid) & 0xffff; // 8122
s.bi_valid += length; // 8123
} // 8124
} // 8125
// 8126
// 8127
function send_code(s, c, tree) { // 8128
send_bits(s, tree[c*2]/*.Code*/, tree[c*2 + 1]/*.Len*/); // 8129
} // 8130
// 8131
// 8132
/* =========================================================================== // 8133
* Reverse the first len bits of a code, using straightforward code (a faster // 8134
* method would use a table) // 8135
* IN assertion: 1 <= len <= 15 // 8136
*/ // 8137
function bi_reverse(code, len) { // 8138
var res = 0; // 8139
do { // 8140
res |= code & 1; // 8141
code >>>= 1; // 8142
res <<= 1; // 8143
} while (--len > 0); // 8144
return res >>> 1; // 8145
} // 8146
// 8147
// 8148
/* =========================================================================== // 8149
* Flush the bit buffer, keeping at most 7 bits in it. // 8150
*/ // 8151
function bi_flush(s) { // 8152
if (s.bi_valid === 16) { // 8153
put_short(s, s.bi_buf); // 8154
s.bi_buf = 0; // 8155
s.bi_valid = 0; // 8156
// 8157
} else if (s.bi_valid >= 8) { // 8158
s.pending_buf[s.pending++] = s.bi_buf & 0xff; // 8159
s.bi_buf >>= 8; // 8160
s.bi_valid -= 8; // 8161
} // 8162
} // 8163
// 8164
// 8165
/* =========================================================================== // 8166
* Compute the optimal bit lengths for a tree and update the total bit length // 8167
* for the current block. // 8168
* IN assertion: the fields freq and dad are set, heap[heap_max] and // 8169
* above are the tree nodes sorted by increasing frequency. // 8170
* OUT assertions: the field len is set to the optimal bit length, the // 8171
* array bl_count contains the frequencies for each bit length. // 8172
* The length opt_len is updated; static_len is also updated if stree is // 8173
* not null. // 8174
*/ // 8175
function gen_bitlen(s, desc) // 8176
// deflate_state *s; // 8177
// tree_desc *desc; /* the tree descriptor */ // 8178
{ // 8179
var tree = desc.dyn_tree; // 8180
var max_code = desc.max_code; // 8181
var stree = desc.stat_desc.static_tree; // 8182
var has_stree = desc.stat_desc.has_stree; // 8183
var extra = desc.stat_desc.extra_bits; // 8184
var base = desc.stat_desc.extra_base; // 8185
var max_length = desc.stat_desc.max_length; // 8186
var h; /* heap index */ // 8187
var n, m; /* iterate over the tree elements */ // 8188
var bits; /* bit length */ // 8189
var xbits; /* extra bits */ // 8190
var f; /* frequency */ // 8191
var overflow = 0; /* number of elements with bit length too large */ // 8192
// 8193
for (bits = 0; bits <= MAX_BITS; bits++) { // 8194
s.bl_count[bits] = 0; // 8195
} // 8196
// 8197
/* In a first pass, compute the optimal bit lengths (which may // 8198
* overflow in the case of the bit length tree). // 8199
*/ // 8200
tree[s.heap[s.heap_max]*2 + 1]/*.Len*/ = 0; /* root of the heap */ // 8201
// 8202
for (h = s.heap_max+1; h < HEAP_SIZE; h++) { // 8203
n = s.heap[h]; // 8204
bits = tree[tree[n*2 +1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1; // 8205
if (bits > max_length) { // 8206
bits = max_length; // 8207
overflow++; // 8208
} // 8209
tree[n*2 + 1]/*.Len*/ = bits; // 8210
/* We overwrite tree[n].Dad which is no longer needed */ // 8211
// 8212
if (n > max_code) { continue; } /* not a leaf node */ // 8213
// 8214
s.bl_count[bits]++; // 8215
xbits = 0; // 8216
if (n >= base) { // 8217
xbits = extra[n-base]; // 8218
} // 8219
f = tree[n * 2]/*.Freq*/; // 8220
s.opt_len += f * (bits + xbits); // 8221
if (has_stree) { // 8222
s.static_len += f * (stree[n*2 + 1]/*.Len*/ + xbits); // 8223
} // 8224
} // 8225
if (overflow === 0) { return; } // 8226
// 8227
// Trace((stderr,"\nbit length overflow\n")); // 8228
/* This happens for example on obj2 and pic of the Calgary corpus */ // 8229
// 8230
/* Find the first bit length which could increase: */ // 8231
do { // 8232
bits = max_length-1; // 8233
while (s.bl_count[bits] === 0) { bits--; } // 8234
s.bl_count[bits]--; /* move one leaf down the tree */ // 8235
s.bl_count[bits+1] += 2; /* move one overflow item as its brother */ // 8236
s.bl_count[max_length]--; // 8237
/* The brother of the overflow item also moves one step up, // 8238
* but this does not affect bl_count[max_length] // 8239
*/ // 8240
overflow -= 2; // 8241
} while (overflow > 0); // 8242
// 8243
/* Now recompute all bit lengths, scanning in increasing frequency. // 8244
* h is still equal to HEAP_SIZE. (It is simpler to reconstruct all // 8245
* lengths instead of fixing only the wrong ones. This idea is taken // 8246
* from 'ar' written by Haruhiko Okumura.) // 8247
*/ // 8248
for (bits = max_length; bits !== 0; bits--) { // 8249
n = s.bl_count[bits]; // 8250
while (n !== 0) { // 8251
m = s.heap[--h]; // 8252
if (m > max_code) { continue; } // 8253
if (tree[m*2 + 1]/*.Len*/ !== bits) { // 8254
// Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); // 8255
s.opt_len += (bits - tree[m*2 + 1]/*.Len*/)*tree[m*2]/*.Freq*/; // 8256
tree[m*2 + 1]/*.Len*/ = bits; // 8257
} // 8258
n--; // 8259
} // 8260
} // 8261
} // 8262
// 8263
// 8264
/* =========================================================================== // 8265
* Generate the codes for a given tree and bit counts (which need not be // 8266
* optimal). // 8267
* IN assertion: the array bl_count contains the bit length statistics for // 8268
* the given tree and the field len is set for all tree elements. // 8269
* OUT assertion: the field code is set for all tree elements of non // 8270
* zero code length. // 8271
*/ // 8272
function gen_codes(tree, max_code, bl_count) // 8273
// ct_data *tree; /* the tree to decorate */ // 8274
// int max_code; /* largest code with non zero frequency */ // 8275
// ushf *bl_count; /* number of codes at each bit length */ // 8276
{ // 8277
var next_code = new Array(MAX_BITS+1); /* next code value for each bit length */ // 8278
var code = 0; /* running code value */ // 8279
var bits; /* bit index */ // 8280
var n; /* code index */ // 8281
// 8282
/* The distribution counts are first used to generate the code values // 8283
* without bit reversal. // 8284
*/ // 8285
for (bits = 1; bits <= MAX_BITS; bits++) { // 8286
next_code[bits] = code = (code + bl_count[bits-1]) << 1; // 8287
} // 8288
/* Check that the bit counts in bl_count are consistent. The last code // 8289
* must be all ones. // 8290
*/ // 8291
//Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1, // 8292
// "inconsistent bit counts"); // 8293
//Tracev((stderr,"\ngen_codes: max_code %d ", max_code)); // 8294
// 8295
for (n = 0; n <= max_code; n++) { // 8296
var len = tree[n*2 + 1]/*.Len*/; // 8297
if (len === 0) { continue; } // 8298
/* Now reverse the bits */ // 8299
tree[n*2]/*.Code*/ = bi_reverse(next_code[len]++, len); // 8300
// 8301
//Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ", // 8302
// n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1)); // 8303
} // 8304
} // 8305
// 8306
// 8307
/* =========================================================================== // 8308
* Initialize the various 'constant' tables. // 8309
*/ // 8310
function tr_static_init() { // 8311
var n; /* iterates over tree elements */ // 8312
var bits; /* bit counter */ // 8313
var length; /* length value */ // 8314
var code; /* code value */ // 8315
var dist; /* distance index */ // 8316
var bl_count = new Array(MAX_BITS+1); // 8317
/* number of codes at each bit length for an optimal tree */ // 8318
// 8319
// do check in _tr_init() // 8320
//if (static_init_done) return; // 8321
// 8322
/* For some embedded targets, global variables are not initialized: */ // 8323
/*#ifdef NO_INIT_GLOBAL_POINTERS // 8324
static_l_desc.static_tree = static_ltree; // 8325
static_l_desc.extra_bits = extra_lbits; // 8326
static_d_desc.static_tree = static_dtree; // 8327
static_d_desc.extra_bits = extra_dbits; // 8328
static_bl_desc.extra_bits = extra_blbits; // 8329
#endif*/ // 8330
// 8331
/* Initialize the mapping length (0..255) -> length code (0..28) */ // 8332
length = 0; // 8333
for (code = 0; code < LENGTH_CODES-1; code++) { // 8334
base_length[code] = length; // 8335
for (n = 0; n < (1<<extra_lbits[code]); n++) { // 8336
_length_code[length++] = code; // 8337
} // 8338
} // 8339
//Assert (length == 256, "tr_static_init: length != 256"); // 8340
/* Note that the length 255 (match length 258) can be represented // 8341
* in two different ways: code 284 + 5 bits or code 285, so we // 8342
* overwrite length_code[255] to use the best encoding: // 8343
*/ // 8344
_length_code[length-1] = code; // 8345
// 8346
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */ // 8347
dist = 0; // 8348
for (code = 0 ; code < 16; code++) { // 8349
base_dist[code] = dist; // 8350
for (n = 0; n < (1<<extra_dbits[code]); n++) { // 8351
_dist_code[dist++] = code; // 8352
} // 8353
} // 8354
//Assert (dist == 256, "tr_static_init: dist != 256"); // 8355
dist >>= 7; /* from now on, all distances are divided by 128 */ // 8356
for ( ; code < D_CODES; code++) { // 8357
base_dist[code] = dist << 7; // 8358
for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { // 8359
_dist_code[256 + dist++] = code; // 8360
} // 8361
} // 8362
//Assert (dist == 256, "tr_static_init: 256+dist != 512"); // 8363
// 8364
/* Construct the codes of the static literal tree */ // 8365
for (bits = 0; bits <= MAX_BITS; bits++) { // 8366
bl_count[bits] = 0; // 8367
} // 8368
// 8369
n = 0; // 8370
while (n <= 143) { // 8371
static_ltree[n*2 + 1]/*.Len*/ = 8; // 8372
n++; // 8373
bl_count[8]++; // 8374
} // 8375
while (n <= 255) { // 8376
static_ltree[n*2 + 1]/*.Len*/ = 9; // 8377
n++; // 8378
bl_count[9]++; // 8379
} // 8380
while (n <= 279) { // 8381
static_ltree[n*2 + 1]/*.Len*/ = 7; // 8382
n++; // 8383
bl_count[7]++; // 8384
} // 8385
while (n <= 287) { // 8386
static_ltree[n*2 + 1]/*.Len*/ = 8; // 8387
n++; // 8388
bl_count[8]++; // 8389
} // 8390
/* Codes 286 and 287 do not exist, but we must include them in the // 8391
* tree construction to get a canonical Huffman tree (longest code // 8392
* all ones) // 8393
*/ // 8394
gen_codes(static_ltree, L_CODES+1, bl_count); // 8395
// 8396
/* The static distance tree is trivial: */ // 8397
for (n = 0; n < D_CODES; n++) { // 8398
static_dtree[n*2 + 1]/*.Len*/ = 5; // 8399
static_dtree[n*2]/*.Code*/ = bi_reverse(n, 5); // 8400
} // 8401
// 8402
// Now data ready and we can init static trees // 8403
static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS); // 8404
static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); // 8405
static_bl_desc =new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); // 8406
// 8407
//static_init_done = true; // 8408
} // 8409
// 8410
// 8411
/* =========================================================================== // 8412
* Initialize a new block. // 8413
*/ // 8414
function init_block(s) { // 8415
var n; /* iterates over tree elements */ // 8416
// 8417
/* Initialize the trees. */ // 8418
for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n*2]/*.Freq*/ = 0; } // 8419
for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n*2]/*.Freq*/ = 0; } // 8420
for (n = 0; n < BL_CODES; n++) { s.bl_tree[n*2]/*.Freq*/ = 0; } // 8421
// 8422
s.dyn_ltree[END_BLOCK*2]/*.Freq*/ = 1; // 8423
s.opt_len = s.static_len = 0; // 8424
s.last_lit = s.matches = 0; // 8425
} // 8426
// 8427
// 8428
/* =========================================================================== // 8429
* Flush the bit buffer and align the output on a byte boundary // 8430
*/ // 8431
function bi_windup(s) // 8432
{ // 8433
if (s.bi_valid > 8) { // 8434
put_short(s, s.bi_buf); // 8435
} else if (s.bi_valid > 0) { // 8436
//put_byte(s, (Byte)s->bi_buf); // 8437
s.pending_buf[s.pending++] = s.bi_buf; // 8438
} // 8439
s.bi_buf = 0; // 8440
s.bi_valid = 0; // 8441
} // 8442
// 8443
/* =========================================================================== // 8444
* Copy a stored block, storing first the length and its // 8445
* one's complement if requested. // 8446
*/ // 8447
function copy_block(s, buf, len, header) // 8448
//DeflateState *s; // 8449
//charf *buf; /* the input data */ // 8450
//unsigned len; /* its length */ // 8451
//int header; /* true if block header must be written */ // 8452
{ // 8453
bi_windup(s); /* align on byte boundary */ // 8454
// 8455
if (header) { // 8456
put_short(s, len); // 8457
put_short(s, ~len); // 8458
} // 8459
// while (len--) { // 8460
// put_byte(s, *buf++); // 8461
// } // 8462
utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); // 8463
s.pending += len; // 8464
} // 8465
// 8466
/* =========================================================================== // 8467
* Compares to subtrees, using the tree depth as tie breaker when // 8468
* the subtrees have equal frequency. This minimizes the worst case length. // 8469
*/ // 8470
function smaller(tree, n, m, depth) { // 8471
var _n2 = n*2; // 8472
var _m2 = m*2; // 8473
return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ || // 8474
(tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m])); // 8475
} // 8476
// 8477
/* =========================================================================== // 8478
* Restore the heap property by moving down the tree starting at node k, // 8479
* exchanging a node with the smallest of its two sons if necessary, stopping // 8480
* when the heap property is re-established (each father smaller than its // 8481
* two sons). // 8482
*/ // 8483
function pqdownheap(s, tree, k) // 8484
// deflate_state *s; // 8485
// ct_data *tree; /* the tree to restore */ // 8486
// int k; /* node to move down */ // 8487
{ // 8488
var v = s.heap[k]; // 8489
var j = k << 1; /* left son of k */ // 8490
while (j <= s.heap_len) { // 8491
/* Set j to the smallest of the two sons: */ // 8492
if (j < s.heap_len && // 8493
smaller(tree, s.heap[j+1], s.heap[j], s.depth)) { // 8494
j++; // 8495
} // 8496
/* Exit if v is smaller than both sons */ // 8497
if (smaller(tree, v, s.heap[j], s.depth)) { break; } // 8498
// 8499
/* Exchange v with the smallest son */ // 8500
s.heap[k] = s.heap[j]; // 8501
k = j; // 8502
// 8503
/* And continue down the tree, setting j to the left son of k */ // 8504
j <<= 1; // 8505
} // 8506
s.heap[k] = v; // 8507
} // 8508
// 8509
// 8510
// inlined manually // 8511
// var SMALLEST = 1; // 8512
// 8513
/* =========================================================================== // 8514
* Send the block data compressed using the given Huffman trees // 8515
*/ // 8516
function compress_block(s, ltree, dtree) // 8517
// deflate_state *s; // 8518
// const ct_data *ltree; /* literal tree */ // 8519
// const ct_data *dtree; /* distance tree */ // 8520
{ // 8521
var dist; /* distance of matched string */ // 8522
var lc; /* match length or unmatched char (if dist == 0) */ // 8523
var lx = 0; /* running index in l_buf */ // 8524
var code; /* the code to send */ // 8525
var extra; /* number of extra bits to send */ // 8526
// 8527
if (s.last_lit !== 0) { // 8528
do { // 8529
dist = (s.pending_buf[s.d_buf + lx*2] << 8) | (s.pending_buf[s.d_buf + lx*2 + 1]); // 8530
lc = s.pending_buf[s.l_buf + lx]; // 8531
lx++; // 8532
// 8533
if (dist === 0) { // 8534
send_code(s, lc, ltree); /* send a literal byte */ // 8535
//Tracecv(isgraph(lc), (stderr," '%c' ", lc)); // 8536
} else { // 8537
/* Here, lc is the match length - MIN_MATCH */ // 8538
code = _length_code[lc]; // 8539
send_code(s, code+LITERALS+1, ltree); /* send the length code */ // 8540
extra = extra_lbits[code]; // 8541
if (extra !== 0) { // 8542
lc -= base_length[code]; // 8543
send_bits(s, lc, extra); /* send the extra length bits */ // 8544
} // 8545
dist--; /* dist is now the match distance - 1 */ // 8546
code = d_code(dist); // 8547
//Assert (code < D_CODES, "bad d_code"); // 8548
// 8549
send_code(s, code, dtree); /* send the distance code */ // 8550
extra = extra_dbits[code]; // 8551
if (extra !== 0) { // 8552
dist -= base_dist[code]; // 8553
send_bits(s, dist, extra); /* send the extra distance bits */ // 8554
} // 8555
} /* literal or match pair ? */ // 8556
// 8557
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ // 8558
//Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, // 8559
// "pendingBuf overflow"); // 8560
// 8561
} while (lx < s.last_lit); // 8562
} // 8563
// 8564
send_code(s, END_BLOCK, ltree); // 8565
} // 8566
// 8567
// 8568
/* =========================================================================== // 8569
* Construct one Huffman tree and assigns the code bit strings and lengths. // 8570
* Update the total bit length for the current block. // 8571
* IN assertion: the field freq is set for all tree elements. // 8572
* OUT assertions: the fields len and code are set to the optimal bit length // 8573
* and corresponding code. The length opt_len is updated; static_len is // 8574
* also updated if stree is not null. The field max_code is set. // 8575
*/ // 8576
function build_tree(s, desc) // 8577
// deflate_state *s; // 8578
// tree_desc *desc; /* the tree descriptor */ // 8579
{ // 8580
var tree = desc.dyn_tree; // 8581
var stree = desc.stat_desc.static_tree; // 8582
var has_stree = desc.stat_desc.has_stree; // 8583
var elems = desc.stat_desc.elems; // 8584
var n, m; /* iterate over heap elements */ // 8585
var max_code = -1; /* largest code with non zero frequency */ // 8586
var node; /* new node being created */ // 8587
// 8588
/* Construct the initial heap, with least frequent element in // 8589
* heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. // 8590
* heap[0] is not used. // 8591
*/ // 8592
s.heap_len = 0; // 8593
s.heap_max = HEAP_SIZE; // 8594
// 8595
for (n = 0; n < elems; n++) { // 8596
if (tree[n * 2]/*.Freq*/ !== 0) { // 8597
s.heap[++s.heap_len] = max_code = n; // 8598
s.depth[n] = 0; // 8599
// 8600
} else { // 8601
tree[n*2 + 1]/*.Len*/ = 0; // 8602
} // 8603
} // 8604
// 8605
/* The pkzip format requires that at least one distance code exists, // 8606
* and that at least one bit should be sent even if there is only one // 8607
* possible code. So to avoid special checks later on we force at least // 8608
* two codes of non zero frequency. // 8609
*/ // 8610
while (s.heap_len < 2) { // 8611
node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0); // 8612
tree[node * 2]/*.Freq*/ = 1; // 8613
s.depth[node] = 0; // 8614
s.opt_len--; // 8615
// 8616
if (has_stree) { // 8617
s.static_len -= stree[node*2 + 1]/*.Len*/; // 8618
} // 8619
/* node is 0 or 1 so it does not have extra bits */ // 8620
} // 8621
desc.max_code = max_code; // 8622
// 8623
/* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, // 8624
* establish sub-heaps of increasing lengths: // 8625
*/ // 8626
for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); } // 8627
// 8628
/* Construct the Huffman tree by repeatedly combining the least two // 8629
* frequent nodes. // 8630
*/ // 8631
node = elems; /* next internal node of the tree */ // 8632
do { // 8633
//pqremove(s, tree, n); /* n = node of least frequency */ // 8634
/*** pqremove ***/ // 8635
n = s.heap[1/*SMALLEST*/]; // 8636
s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--]; // 8637
pqdownheap(s, tree, 1/*SMALLEST*/); // 8638
/***/ // 8639
// 8640
m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */ // 8641
// 8642
s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */ // 8643
s.heap[--s.heap_max] = m; // 8644
// 8645
/* Create a new node father of n and m */ // 8646
tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/; // 8647
s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; // 8648
tree[n*2 + 1]/*.Dad*/ = tree[m*2 + 1]/*.Dad*/ = node; // 8649
// 8650
/* and insert the new node in the heap */ // 8651
s.heap[1/*SMALLEST*/] = node++; // 8652
pqdownheap(s, tree, 1/*SMALLEST*/); // 8653
// 8654
} while (s.heap_len >= 2); // 8655
// 8656
s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/]; // 8657
// 8658
/* At this point, the fields freq and dad are set. We can now // 8659
* generate the bit lengths. // 8660
*/ // 8661
gen_bitlen(s, desc); // 8662
// 8663
/* The field len is now set, we can generate the bit codes */ // 8664
gen_codes(tree, max_code, s.bl_count); // 8665
} // 8666
// 8667
// 8668
/* =========================================================================== // 8669
* Scan a literal or distance tree to determine the frequencies of the codes // 8670
* in the bit length tree. // 8671
*/ // 8672
function scan_tree(s, tree, max_code) // 8673
// deflate_state *s; // 8674
// ct_data *tree; /* the tree to be scanned */ // 8675
// int max_code; /* and its largest code of non zero frequency */ // 8676
{ // 8677
var n; /* iterates over all tree elements */ // 8678
var prevlen = -1; /* last emitted length */ // 8679
var curlen; /* length of current code */ // 8680
// 8681
var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */ // 8682
// 8683
var count = 0; /* repeat count of the current code */ // 8684
var max_count = 7; /* max repeat count */ // 8685
var min_count = 4; /* min repeat count */ // 8686
// 8687
if (nextlen === 0) { // 8688
max_count = 138; // 8689
min_count = 3; // 8690
} // 8691
tree[(max_code+1)*2 + 1]/*.Len*/ = 0xffff; /* guard */ // 8692
// 8693
for (n = 0; n <= max_code; n++) { // 8694
curlen = nextlen; // 8695
nextlen = tree[(n+1)*2 + 1]/*.Len*/; // 8696
// 8697
if (++count < max_count && curlen === nextlen) { // 8698
continue; // 8699
// 8700
} else if (count < min_count) { // 8701
s.bl_tree[curlen * 2]/*.Freq*/ += count; // 8702
// 8703
} else if (curlen !== 0) { // 8704
// 8705
if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; } // 8706
s.bl_tree[REP_3_6*2]/*.Freq*/++; // 8707
// 8708
} else if (count <= 10) { // 8709
s.bl_tree[REPZ_3_10*2]/*.Freq*/++; // 8710
// 8711
} else { // 8712
s.bl_tree[REPZ_11_138*2]/*.Freq*/++; // 8713
} // 8714
// 8715
count = 0; // 8716
prevlen = curlen; // 8717
// 8718
if (nextlen === 0) { // 8719
max_count = 138; // 8720
min_count = 3; // 8721
// 8722
} else if (curlen === nextlen) { // 8723
max_count = 6; // 8724
min_count = 3; // 8725
// 8726
} else { // 8727
max_count = 7; // 8728
min_count = 4; // 8729
} // 8730
} // 8731
} // 8732
// 8733
// 8734
/* =========================================================================== // 8735
* Send a literal or distance tree in compressed form, using the codes in // 8736
* bl_tree. // 8737
*/ // 8738
function send_tree(s, tree, max_code) // 8739
// deflate_state *s; // 8740
// ct_data *tree; /* the tree to be scanned */ // 8741
// int max_code; /* and its largest code of non zero frequency */ // 8742
{ // 8743
var n; /* iterates over all tree elements */ // 8744
var prevlen = -1; /* last emitted length */ // 8745
var curlen; /* length of current code */ // 8746
// 8747
var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */ // 8748
// 8749
var count = 0; /* repeat count of the current code */ // 8750
var max_count = 7; /* max repeat count */ // 8751
var min_count = 4; /* min repeat count */ // 8752
// 8753
/* tree[max_code+1].Len = -1; */ /* guard already set */ // 8754
if (nextlen === 0) { // 8755
max_count = 138; // 8756
min_count = 3; // 8757
} // 8758
// 8759
for (n = 0; n <= max_code; n++) { // 8760
curlen = nextlen; // 8761
nextlen = tree[(n+1)*2 + 1]/*.Len*/; // 8762
// 8763
if (++count < max_count && curlen === nextlen) { // 8764
continue; // 8765
// 8766
} else if (count < min_count) { // 8767
do { send_code(s, curlen, s.bl_tree); } while (--count !== 0); // 8768
// 8769
} else if (curlen !== 0) { // 8770
if (curlen !== prevlen) { // 8771
send_code(s, curlen, s.bl_tree); // 8772
count--; // 8773
} // 8774
//Assert(count >= 3 && count <= 6, " 3_6?"); // 8775
send_code(s, REP_3_6, s.bl_tree); // 8776
send_bits(s, count-3, 2); // 8777
// 8778
} else if (count <= 10) { // 8779
send_code(s, REPZ_3_10, s.bl_tree); // 8780
send_bits(s, count-3, 3); // 8781
// 8782
} else { // 8783
send_code(s, REPZ_11_138, s.bl_tree); // 8784
send_bits(s, count-11, 7); // 8785
} // 8786
// 8787
count = 0; // 8788
prevlen = curlen; // 8789
if (nextlen === 0) { // 8790
max_count = 138; // 8791
min_count = 3; // 8792
// 8793
} else if (curlen === nextlen) { // 8794
max_count = 6; // 8795
min_count = 3; // 8796
// 8797
} else { // 8798
max_count = 7; // 8799
min_count = 4; // 8800
} // 8801
} // 8802
} // 8803
// 8804
// 8805
/* =========================================================================== // 8806
* Construct the Huffman tree for the bit lengths and return the index in // 8807
* bl_order of the last bit length code to send. // 8808
*/ // 8809
function build_bl_tree(s) { // 8810
var max_blindex; /* index of last bit length code of non zero freq */ // 8811
// 8812
/* Determine the bit length frequencies for literal and distance trees */ // 8813
scan_tree(s, s.dyn_ltree, s.l_desc.max_code); // 8814
scan_tree(s, s.dyn_dtree, s.d_desc.max_code); // 8815
// 8816
/* Build the bit length tree: */ // 8817
build_tree(s, s.bl_desc); // 8818
/* opt_len now includes the length of the tree representations, except // 8819
* the lengths of the bit lengths codes and the 5+5+4 bits for the counts. // 8820
*/ // 8821
// 8822
/* Determine the number of bit length codes to send. The pkzip format // 8823
* requires that at least 4 bit length codes be sent. (appnote.txt says // 8824
* 3 but the actual value used is 4.) // 8825
*/ // 8826
for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { // 8827
if (s.bl_tree[bl_order[max_blindex]*2 + 1]/*.Len*/ !== 0) { // 8828
break; // 8829
} // 8830
} // 8831
/* Update opt_len to include the bit length tree and counts */ // 8832
s.opt_len += 3*(max_blindex+1) + 5+5+4; // 8833
//Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", // 8834
// s->opt_len, s->static_len)); // 8835
// 8836
return max_blindex; // 8837
} // 8838
// 8839
// 8840
/* =========================================================================== // 8841
* Send the header for a block using dynamic Huffman trees: the counts, the // 8842
* lengths of the bit length codes, the literal tree and the distance tree. // 8843
* IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. // 8844
*/ // 8845
function send_all_trees(s, lcodes, dcodes, blcodes) // 8846
// deflate_state *s; // 8847
// int lcodes, dcodes, blcodes; /* number of codes for each tree */ // 8848
{ // 8849
var rank; /* index in bl_order */ // 8850
// 8851
//Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); // 8852
//Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, // 8853
// "too many codes"); // 8854
//Tracev((stderr, "\nbl counts: ")); // 8855
send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ // 8856
send_bits(s, dcodes-1, 5); // 8857
send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ // 8858
for (rank = 0; rank < blcodes; rank++) { // 8859
//Tracev((stderr, "\nbl code %2d ", bl_order[rank])); // 8860
send_bits(s, s.bl_tree[bl_order[rank]*2 + 1]/*.Len*/, 3); // 8861
} // 8862
//Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); // 8863
// 8864
send_tree(s, s.dyn_ltree, lcodes-1); /* literal tree */ // 8865
//Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); // 8866
// 8867
send_tree(s, s.dyn_dtree, dcodes-1); /* distance tree */ // 8868
//Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); // 8869
} // 8870
// 8871
// 8872
/* =========================================================================== // 8873
* Check if the data type is TEXT or BINARY, using the following algorithm: // 8874
* - TEXT if the two conditions below are satisfied: // 8875
* a) There are no non-portable control characters belonging to the // 8876
* "black list" (0..6, 14..25, 28..31). // 8877
* b) There is at least one printable character belonging to the // 8878
* "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). // 8879
* - BINARY otherwise. // 8880
* - The following partially-portable control characters form a // 8881
* "gray list" that is ignored in this detection algorithm: // 8882
* (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). // 8883
* IN assertion: the fields Freq of dyn_ltree are set. // 8884
*/ // 8885
function detect_data_type(s) { // 8886
/* black_mask is the bit mask of black-listed bytes // 8887
* set bits 0..6, 14..25, and 28..31 // 8888
* 0xf3ffc07f = binary 11110011111111111100000001111111 // 8889
*/ // 8890
var black_mask = 0xf3ffc07f; // 8891
var n; // 8892
// 8893
/* Check for non-textual ("black-listed") bytes. */ // 8894
for (n = 0; n <= 31; n++, black_mask >>>= 1) { // 8895
if ((black_mask & 1) && (s.dyn_ltree[n*2]/*.Freq*/ !== 0)) { // 8896
return Z_BINARY; // 8897
} // 8898
} // 8899
// 8900
/* Check for textual ("white-listed") bytes. */ // 8901
if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 || // 8902
s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) { // 8903
return Z_TEXT; // 8904
} // 8905
for (n = 32; n < LITERALS; n++) { // 8906
if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) { // 8907
return Z_TEXT; // 8908
} // 8909
} // 8910
// 8911
/* There are no "black-listed" or "white-listed" bytes: // 8912
* this stream either is empty or has tolerated ("gray-listed") bytes only. // 8913
*/ // 8914
return Z_BINARY; // 8915
} // 8916
// 8917
// 8918
var static_init_done = false; // 8919
// 8920
/* =========================================================================== // 8921
* Initialize the tree data structures for a new zlib stream. // 8922
*/ // 8923
function _tr_init(s) // 8924
{ // 8925
// 8926
if (!static_init_done) { // 8927
tr_static_init(); // 8928
static_init_done = true; // 8929
} // 8930
// 8931
s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); // 8932
s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); // 8933
s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); // 8934
// 8935
s.bi_buf = 0; // 8936
s.bi_valid = 0; // 8937
// 8938
/* Initialize the first block of the first file: */ // 8939
init_block(s); // 8940
} // 8941
// 8942
// 8943
/* =========================================================================== // 8944
* Send a stored block // 8945
*/ // 8946
function _tr_stored_block(s, buf, stored_len, last) // 8947
//DeflateState *s; // 8948
//charf *buf; /* input block */ // 8949
//ulg stored_len; /* length of input block */ // 8950
//int last; /* one if this is the last block for a file */ // 8951
{ // 8952
send_bits(s, (STORED_BLOCK<<1)+(last ? 1 : 0), 3); /* send block type */ // 8953
copy_block(s, buf, stored_len, true); /* with header */ // 8954
} // 8955
// 8956
// 8957
/* =========================================================================== // 8958
* Send one empty static block to give enough lookahead for inflate. // 8959
* This takes 10 bits, of which 7 may remain in the bit buffer. // 8960
*/ // 8961
function _tr_align(s) { // 8962
send_bits(s, STATIC_TREES<<1, 3); // 8963
send_code(s, END_BLOCK, static_ltree); // 8964
bi_flush(s); // 8965
} // 8966
// 8967
// 8968
/* =========================================================================== // 8969
* Determine the best encoding for the current block: dynamic trees, static // 8970
* trees or store, and output the encoded block to the zip file. // 8971
*/ // 8972
function _tr_flush_block(s, buf, stored_len, last) // 8973
//DeflateState *s; // 8974
//charf *buf; /* input block, or NULL if too old */ // 8975
//ulg stored_len; /* length of input block */ // 8976
//int last; /* one if this is the last block for a file */ // 8977
{ // 8978
var opt_lenb, static_lenb; /* opt_len and static_len in bytes */ // 8979
var max_blindex = 0; /* index of last bit length code of non zero freq */ // 8980
// 8981
/* Build the Huffman trees unless a stored block is forced */ // 8982
if (s.level > 0) { // 8983
// 8984
/* Check if the file is binary or text */ // 8985
if (s.strm.data_type === Z_UNKNOWN) { // 8986
s.strm.data_type = detect_data_type(s); // 8987
} // 8988
// 8989
/* Construct the literal and distance trees */ // 8990
build_tree(s, s.l_desc); // 8991
// Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, // 8992
// s->static_len)); // 8993
// 8994
build_tree(s, s.d_desc); // 8995
// Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, // 8996
// s->static_len)); // 8997
/* At this point, opt_len and static_len are the total bit lengths of // 8998
* the compressed block data, excluding the tree representations. // 8999
*/ // 9000
// 9001
/* Build the bit length tree for the above two trees, and get the index // 9002
* in bl_order of the last bit length code to send. // 9003
*/ // 9004
max_blindex = build_bl_tree(s); // 9005
// 9006
/* Determine the best encoding. Compute the block lengths in bytes. */ // 9007
opt_lenb = (s.opt_len+3+7) >>> 3; // 9008
static_lenb = (s.static_len+3+7) >>> 3; // 9009
// 9010
// Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", // 9011
// opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, // 9012
// s->last_lit)); // 9013
// 9014
if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; } // 9015
// 9016
} else { // 9017
// Assert(buf != (char*)0, "lost buf"); // 9018
opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ // 9019
} // 9020
// 9021
if ((stored_len+4 <= opt_lenb) && (buf !== -1)) { // 9022
/* 4: two words for the lengths */ // 9023
// 9024
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. // 9025
* Otherwise we can't have processed more than WSIZE input bytes since // 9026
* the last block flush, because compression would have been // 9027
* successful. If LIT_BUFSIZE <= WSIZE, it is never too late to // 9028
* transform a block into a stored block. // 9029
*/ // 9030
_tr_stored_block(s, buf, stored_len, last); // 9031
// 9032
} else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { // 9033
// 9034
send_bits(s, (STATIC_TREES<<1) + (last ? 1 : 0), 3); // 9035
compress_block(s, static_ltree, static_dtree); // 9036
// 9037
} else { // 9038
send_bits(s, (DYN_TREES<<1) + (last ? 1 : 0), 3); // 9039
send_all_trees(s, s.l_desc.max_code+1, s.d_desc.max_code+1, max_blindex+1); // 9040
compress_block(s, s.dyn_ltree, s.dyn_dtree); // 9041
} // 9042
// Assert (s->compressed_len == s->bits_sent, "bad compressed size"); // 9043
/* The above check is made mod 2^32, for files larger than 512 MB // 9044
* and uLong implemented on 32 bits. // 9045
*/ // 9046
init_block(s); // 9047
// 9048
if (last) { // 9049
bi_windup(s); // 9050
} // 9051
// Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, // 9052
// s->compressed_len-7*last)); // 9053
} // 9054
// 9055
/* =========================================================================== // 9056
* Save the match info and tally the frequency counts. Return true if // 9057
* the current block must be flushed. // 9058
*/ // 9059
function _tr_tally(s, dist, lc) // 9060
// deflate_state *s; // 9061
// unsigned dist; /* distance of matched string */ // 9062
// unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ // 9063
{ // 9064
//var out_length, in_length, dcode; // 9065
// 9066
s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff; // 9067
s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff; // 9068
// 9069
s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff; // 9070
s.last_lit++; // 9071
// 9072
if (dist === 0) { // 9073
/* lc is the unmatched char */ // 9074
s.dyn_ltree[lc*2]/*.Freq*/++; // 9075
} else { // 9076
s.matches++; // 9077
/* Here, lc is the match length - MIN_MATCH */ // 9078
dist--; /* dist = match distance - 1 */ // 9079
//Assert((ush)dist < (ush)MAX_DIST(s) && // 9080
// (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && // 9081
// (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); // 9082
// 9083
s.dyn_ltree[(_length_code[lc]+LITERALS+1) * 2]/*.Freq*/++; // 9084
s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++; // 9085
} // 9086
// 9087
// (!) This block is disabled in zlib defailts, // 9088
// don't enable it for binary compatibility // 9089
// 9090
//#ifdef TRUNCATE_BLOCK // 9091
// /* Try to guess if it is profitable to stop the current block here */ // 9092
// if ((s.last_lit & 0x1fff) === 0 && s.level > 2) { // 9093
// /* Compute an upper bound for the compressed length */ // 9094
// out_length = s.last_lit*8; // 9095
// in_length = s.strstart - s.block_start; // 9096
// // 9097
// for (dcode = 0; dcode < D_CODES; dcode++) { // 9098
// out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]); // 9099
// } // 9100
// out_length >>>= 3; // 9101
// //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", // 9102
// // s->last_lit, in_length, out_length, // 9103
// // 100L - out_length*100L/in_length)); // 9104
// if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) { // 9105
// return true; // 9106
// } // 9107
// } // 9108
//#endif // 9109
// 9110
return (s.last_lit === s.lit_bufsize-1); // 9111
/* We avoid equality with lit_bufsize because of wraparound at 64K // 9112
* on 16 bit machines and because stored blocks are restricted to // 9113
* 64K-1 bytes. // 9114
*/ // 9115
} // 9116
// 9117
exports._tr_init = _tr_init; // 9118
exports._tr_stored_block = _tr_stored_block; // 9119
exports._tr_flush_block = _tr_flush_block; // 9120
exports._tr_tally = _tr_tally; // 9121
exports._tr_align = _tr_align; // 9122
},{"../utils/common":27}],39:[function(_dereq_,module,exports){ // 9123
'use strict'; // 9124
// 9125
// 9126
function ZStream() { // 9127
/* next input byte */ // 9128
this.input = null; // JS specific, because we have no pointers // 9129
this.next_in = 0; // 9130
/* number of bytes available at input */ // 9131
this.avail_in = 0; // 9132
/* total number of input bytes read so far */ // 9133
this.total_in = 0; // 9134
/* next output byte should be put there */ // 9135
this.output = null; // JS specific, because we have no pointers // 9136
this.next_out = 0; // 9137
/* remaining free space at output */ // 9138
this.avail_out = 0; // 9139
/* total number of bytes output so far */ // 9140
this.total_out = 0; // 9141
/* last error message, NULL if no error */ // 9142
this.msg = ''/*Z_NULL*/; // 9143
/* not visible by applications */ // 9144
this.state = null; // 9145
/* best guess about the data type: binary or text */ // 9146
this.data_type = 2/*Z_UNKNOWN*/; // 9147
/* adler32 value of the uncompressed data */ // 9148
this.adler = 0; // 9149
} // 9150
// 9151
module.exports = ZStream; // 9152
},{}]},{},[9]) // 9153
(9) // 9154
}); // 9155
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}).call(this);
(function () {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/silentcicero:jszip/lib/saveas.js //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
/* FileSaver.js // 1
* A saveAs() FileSaver implementation. // 2
* 2015-05-07.2 // 3
* // 4
* By Eli Grey, http://eligrey.com // 5
* License: X11/MIT // 6
* See https://github.com/eligrey/FileSaver.js/blob/master/LICENSE.md // 7
*/ // 8
// 9
/*global self */ // 10
/*jslint bitwise: true, indent: 4, laxbreak: true, laxcomma: true, smarttabs: true, plusplus: true */ // 11
// 12
/*! @source http://purl.eligrey.com/github/FileSaver.js/blob/master/FileSaver.js */ // 13
// 14
var saveAs = saveAs = window.saveAs || (function(view) { // 15
"use strict"; // 16
// IE <10 is explicitly unsupported // 17
if (typeof navigator !== "undefined" && /MSIE [1-9]\./.test(navigator.userAgent)) { // 18
return; // 19
} // 20
var // 21
doc = view.document // 22
// only get URL when necessary in case Blob.js hasn't overridden it yet // 23
, get_URL = function() { // 24
return view.URL || view.webkitURL || view; // 25
} // 26
, save_link = doc.createElementNS("http://www.w3.org/1999/xhtml", "a") // 27
, can_use_save_link = "download" in save_link // 28
, click = function(node) { // 29
var event = doc.createEvent("MouseEvents"); // 30
event.initMouseEvent( // 31
"click", true, false, view, 0, 0, 0, 0, 0 // 32
, false, false, false, false, 0, null // 33
); // 34
node.dispatchEvent(event); // 35
} // 36
, webkit_req_fs = view.webkitRequestFileSystem // 37
, req_fs = view.requestFileSystem || webkit_req_fs || view.mozRequestFileSystem // 38
, throw_outside = function(ex) { // 39
(view.setImmediate || view.setTimeout)(function() { // 40
throw ex; // 41
}, 0); // 42
} // 43
, force_saveable_type = "application/octet-stream" // 44
, fs_min_size = 0 // 45
// See https://code.google.com/p/chromium/issues/detail?id=375297#c7 and // 46
// https://github.com/eligrey/FileSaver.js/commit/485930a#commitcomment-8768047 // 47
// for the reasoning behind the timeout and revocation flow // 48
, arbitrary_revoke_timeout = 500 // in ms // 49
, revoke = function(file) { // 50
var revoker = function() { // 51
if (typeof file === "string") { // file is an object URL // 52
get_URL().revokeObjectURL(file); // 53
} else { // file is a File // 54
file.remove(); // 55
} // 56
}; // 57
if (view.chrome) { // 58
revoker(); // 59
} else { // 60
setTimeout(revoker, arbitrary_revoke_timeout); // 61
} // 62
} // 63
, dispatch = function(filesaver, event_types, event) { // 64
event_types = [].concat(event_types); // 65
var i = event_types.length; // 66
while (i--) { // 67
var listener = filesaver["on" + event_types[i]]; // 68
if (typeof listener === "function") { // 69
try { // 70
listener.call(filesaver, event || filesaver); // 71
} catch (ex) { // 72
throw_outside(ex); // 73
} // 74
} // 75
} // 76
} // 77
, auto_bom = function(blob) { // 78
// prepend BOM for UTF-8 XML and text/* types (including HTML) // 79
if (/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) { // 80
return new Blob(["\ufeff", blob], {type: blob.type}); // 81
} // 82
return blob; // 83
} // 84
, FileSaver = function(blob, name) { // 85
blob = auto_bom(blob); // 86
// First try a.download, then web filesystem, then object URLs // 87
var // 88
filesaver = this // 89
, type = blob.type // 90
, blob_changed = false // 91
, object_url // 92
, target_view // 93
, dispatch_all = function() { // 94
dispatch(filesaver, "writestart progress write writeend".split(" ")); // 95
} // 96
// on any filesys errors revert to saving with object URLs // 97
, fs_error = function() { // 98
// don't create more object URLs than needed // 99
if (blob_changed || !object_url) { // 100
object_url = get_URL().createObjectURL(blob); // 101
} // 102
if (target_view) { // 103
target_view.location.href = object_url; // 104
} else { // 105
var new_tab = view.open(object_url, "_blank"); // 106
if (new_tab == undefined && typeof safari !== "undefined") { // 107
//Apple do not allow window.open, see http://bit.ly/1kZffRI // 108
view.location.href = object_url // 109
} // 110
} // 111
filesaver.readyState = filesaver.DONE; // 112
dispatch_all(); // 113
revoke(object_url); // 114
} // 115
, abortable = function(func) { // 116
return function() { // 117
if (filesaver.readyState !== filesaver.DONE) { // 118
return func.apply(this, arguments); // 119
} // 120
}; // 121
} // 122
, create_if_not_found = {create: true, exclusive: false} // 123
, slice // 124
; // 125
filesaver.readyState = filesaver.INIT; // 126
if (!name) { // 127
name = "download"; // 128
} // 129
if (can_use_save_link) { // 130
object_url = get_URL().createObjectURL(blob); // 131
save_link.href = object_url; // 132
save_link.download = name; // 133
click(save_link); // 134
filesaver.readyState = filesaver.DONE; // 135
dispatch_all(); // 136
revoke(object_url); // 137
return; // 138
} // 139
// Object and web filesystem URLs have a problem saving in Google Chrome when // 140
// viewed in a tab, so I force save with application/octet-stream // 141
// http://code.google.com/p/chromium/issues/detail?id=91158 // 142
// Update: Google errantly closed 91158, I submitted it again: // 143
// https://code.google.com/p/chromium/issues/detail?id=389642 // 144
if (view.chrome && type && type !== force_saveable_type) { // 145
slice = blob.slice || blob.webkitSlice; // 146
blob = slice.call(blob, 0, blob.size, force_saveable_type); // 147
blob_changed = true; // 148
} // 149
// Since I can't be sure that the guessed media type will trigger a download // 150
// in WebKit, I append .download to the filename. // 151
// https://bugs.webkit.org/show_bug.cgi?id=65440 // 152
if (webkit_req_fs && name !== "download") { // 153
name += ".download"; // 154
} // 155
if (type === force_saveable_type || webkit_req_fs) { // 156
target_view = view; // 157
} // 158
if (!req_fs) { // 159
fs_error(); // 160
return; // 161
} // 162
fs_min_size += blob.size; // 163
req_fs(view.TEMPORARY, fs_min_size, abortable(function(fs) { // 164
fs.root.getDirectory("saved", create_if_not_found, abortable(function(dir) { // 165
var save = function() { // 166
dir.getFile(name, create_if_not_found, abortable(function(file) { // 167
file.createWriter(abortable(function(writer) { // 168
writer.onwriteend = function(event) { // 169
target_view.location.href = file.toURL(); // 170
filesaver.readyState = filesaver.DONE; // 171
dispatch(filesaver, "writeend", event); // 172
revoke(file); // 173
}; // 174
writer.onerror = function() { // 175
var error = writer.error; // 176
if (error.code !== error.ABORT_ERR) { // 177
fs_error(); // 178
} // 179
}; // 180
"writestart progress write abort".split(" ").forEach(function(event) { // 181
writer["on" + event] = filesaver["on" + event]; // 182
}); // 183
writer.write(blob); // 184
filesaver.abort = function() { // 185
writer.abort(); // 186
filesaver.readyState = filesaver.DONE; // 187
}; // 188
filesaver.readyState = filesaver.WRITING; // 189
}), fs_error); // 190
}), fs_error); // 191
}; // 192
dir.getFile(name, {create: false}, abortable(function(file) { // 193
// delete file if it already exists // 194
file.remove(); // 195
save(); // 196
}), abortable(function(ex) { // 197
if (ex.code === ex.NOT_FOUND_ERR) { // 198
save(); // 199
} else { // 200
fs_error(); // 201
} // 202
})); // 203
}), fs_error); // 204
}), fs_error); // 205
} // 206
, FS_proto = FileSaver.prototype // 207
, saveAs = function(blob, name) { // 208
return new FileSaver(blob, name); // 209
} // 210
; // 211
// IE 10+ (native saveAs) // 212
if (typeof navigator !== "undefined" && navigator.msSaveOrOpenBlob) { // 213
return function(blob, name) { // 214
return navigator.msSaveOrOpenBlob(auto_bom(blob), name); // 215
}; // 216
} // 217
// 218
FS_proto.abort = function() { // 219
var filesaver = this; // 220
filesaver.readyState = filesaver.DONE; // 221
dispatch(filesaver, "abort"); // 222
}; // 223
FS_proto.readyState = FS_proto.INIT = 0; // 224
FS_proto.WRITING = 1; // 225
FS_proto.DONE = 2; // 226
// 227
FS_proto.error = // 228
FS_proto.onwritestart = // 229
FS_proto.onprogress = // 230
FS_proto.onwrite = // 231
FS_proto.onabort = // 232
FS_proto.onerror = // 233
FS_proto.onwriteend = // 234
null; // 235
// 236
return saveAs; // 237
}( // 238
typeof self !== "undefined" && self // 239
|| typeof window !== "undefined" && window // 240
|| this.content // 241
)); // 242
// `self` is undefined in Firefox for Android content script context // 243
// while `this` is nsIContentFrameMessageManager // 244
// with an attribute `content` that corresponds to the window // 245
// 246
if (typeof module !== "undefined" && module.exports) { // 247
module.exports.saveAs = saveAs = window.saveAs; // 248
} else if ((typeof define !== "undefined" && define !== null) && (define.amd != null)) { // 249
define([], function() { // 250
return saveAs; // 251
}); // 252
} // 253
// 254
window.saveAs = saveAs; // 255
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}).call(this);
(function () {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/silentcicero:jszip/package-init.js //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Browser environment // 1
if(typeof window !== 'undefined') { // 2
JSZip = (typeof window.JSZip !== 'undefined') ? window.JSZip : require('JSZip'); // 3
} // 4
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}).call(this);
//////////////////////////////////////////////////////////////////////////////////////////
}).call(this);
/* Exports */
Package._define("silentcicero:jszip", {
JSZip: JSZip
});
})();
Reference in New Issue View Git Blame Copy Permalink