-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathnifti-reader-min.js
executable file
·2063 lines (1989 loc) · 152 KB
/
nifti-reader-min.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
(function(f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this }
g.nifti = f() } })(function() {
var define, module, exports;
return function e(t, n, r) {
function s(o, u) { if (!n[o]) { if (!t[o]) { var a = typeof require == "function" && require; if (!u && a) return a(o, !0); if (i) return i(o, !0); var f = new Error("Cannot find module '" + o + "'"); throw f.code = "MODULE_NOT_FOUND", f } var l = n[o] = { exports: {} };
t[o][0].call(l.exports, function(e) { var n = t[o][1][e]; return s(n ? n : e) }, l, l.exports, e, t, n, r) } return n[o].exports } var i = typeof require == "function" && require; for (var o = 0; o < r.length; o++) s(r[o]); return s }({
1: [function(require, module, exports) { "use strict"; var assign = require("./lib/utils/common").assign; var deflate = require("./lib/deflate"); var inflate = require("./lib/inflate"); var constants = require("./lib/zlib/constants"); var pako = {};
assign(pako, deflate, inflate, constants);
module.exports = pako }, { "./lib/deflate": 2, "./lib/inflate": 3, "./lib/utils/common": 4, "./lib/zlib/constants": 7 }],
2: [function(require, module, exports) { "use strict"; var zlib_deflate = require("./zlib/deflate.js"); var utils = require("./utils/common"); var strings = require("./utils/strings"); var msg = require("./zlib/messages"); var zstream = require("./zlib/zstream"); var toString = Object.prototype.toString; var Z_NO_FLUSH = 0; var Z_FINISH = 4; var Z_OK = 0; var Z_STREAM_END = 1; var Z_SYNC_FLUSH = 2; var Z_DEFAULT_COMPRESSION = -1; var Z_DEFAULT_STRATEGY = 0; var Z_DEFLATED = 8; var Deflate = function(options) { this.options = utils.assign({ level: Z_DEFAULT_COMPRESSION, method: Z_DEFLATED, chunkSize: 16384, windowBits: 15, memLevel: 8, strategy: Z_DEFAULT_STRATEGY, to: "" }, options || {}); var opt = this.options; if (opt.raw && opt.windowBits > 0) { opt.windowBits = -opt.windowBits } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) { opt.windowBits += 16 }
this.err = 0;
this.msg = "";
this.ended = false;
this.chunks = [];
this.strm = new zstream;
this.strm.avail_out = 0; var status = zlib_deflate.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy); if (status !== Z_OK) { throw new Error(msg[status]) } if (opt.header) { zlib_deflate.deflateSetHeader(this.strm, opt.header) } };
Deflate.prototype.push = function(data, mode) { var strm = this.strm; var chunkSize = this.options.chunkSize; var status, _mode; if (this.ended) { return false }
_mode = mode === ~~mode ? mode : mode === true ? Z_FINISH : Z_NO_FLUSH; if (typeof data === "string") { strm.input = strings.string2buf(data) } else if (toString.call(data) === "[object ArrayBuffer]") { strm.input = new Uint8Array(data) } else { strm.input = data }
strm.next_in = 0;
strm.avail_in = strm.input.length;
do { if (strm.avail_out === 0) { strm.output = new utils.Buf8(chunkSize);
strm.next_out = 0;
strm.avail_out = chunkSize }
status = zlib_deflate.deflate(strm, _mode); if (status !== Z_STREAM_END && status !== Z_OK) { this.onEnd(status);
this.ended = true; return false } if (strm.avail_out === 0 || strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH)) { if (this.options.to === "string") { this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out))) } else { this.onData(utils.shrinkBuf(strm.output, strm.next_out)) } } } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END); if (_mode === Z_FINISH) { status = zlib_deflate.deflateEnd(this.strm);
this.onEnd(status);
this.ended = true; return status === Z_OK } if (_mode === Z_SYNC_FLUSH) { this.onEnd(Z_OK);
strm.avail_out = 0; return true } return true };
Deflate.prototype.onData = function(chunk) { this.chunks.push(chunk) };
Deflate.prototype.onEnd = function(status) { if (status === Z_OK) { if (this.options.to === "string") { this.result = this.chunks.join("") } else { this.result = utils.flattenChunks(this.chunks) } }
this.chunks = [];
this.err = status;
this.msg = this.strm.msg };
function deflate(input, options) { var deflator = new Deflate(options);
deflator.push(input, true); if (deflator.err) { throw deflator.msg } return deflator.result }
function deflateRaw(input, options) { options = options || {};
options.raw = true; return deflate(input, options) }
function gzip(input, options) { options = options || {};
options.gzip = true; return deflate(input, options) }
exports.Deflate = Deflate;
exports.deflate = deflate;
exports.deflateRaw = deflateRaw;
exports.gzip = gzip }, { "./utils/common": 4, "./utils/strings": 5, "./zlib/deflate.js": 9, "./zlib/messages": 14, "./zlib/zstream": 16 }],
3: [function(require, module, exports) { "use strict"; var zlib_inflate = require("./zlib/inflate.js"); var utils = require("./utils/common"); var strings = require("./utils/strings"); var c = require("./zlib/constants"); var msg = require("./zlib/messages"); var zstream = require("./zlib/zstream"); var gzheader = require("./zlib/gzheader"); var toString = Object.prototype.toString; var Inflate = function(options) { this.options = utils.assign({ chunkSize: 16384, windowBits: 0, to: "" }, options || {}); var opt = this.options; if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) { opt.windowBits = -opt.windowBits; if (opt.windowBits === 0) { opt.windowBits = -15 } } if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) { opt.windowBits += 32 } if (opt.windowBits > 15 && opt.windowBits < 48) { if ((opt.windowBits & 15) === 0) { opt.windowBits |= 15 } }
this.err = 0;
this.msg = "";
this.ended = false;
this.chunks = [];
this.strm = new zstream;
this.strm.avail_out = 0; var status = zlib_inflate.inflateInit2(this.strm, opt.windowBits); if (status !== c.Z_OK) { throw new Error(msg[status]) }
this.header = new gzheader;
zlib_inflate.inflateGetHeader(this.strm, this.header) };
Inflate.prototype.push = function(data, mode) { var strm = this.strm; var chunkSize = this.options.chunkSize; var status, _mode; var next_out_utf8, tail, utf8str; var allowBufError = false; if (this.ended) { return false }
_mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH; if (typeof data === "string") { strm.input = strings.binstring2buf(data) } else if (toString.call(data) === "[object ArrayBuffer]") { strm.input = new Uint8Array(data) } else { strm.input = data }
strm.next_in = 0;
strm.avail_in = strm.input.length;
do { if (strm.avail_out === 0) { strm.output = new utils.Buf8(chunkSize);
strm.next_out = 0;
strm.avail_out = chunkSize }
status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); if (status === c.Z_BUF_ERROR && allowBufError === true) { status = c.Z_OK;
allowBufError = false } if (status !== c.Z_STREAM_END && status !== c.Z_OK) { this.onEnd(status);
this.ended = true; return false } if (strm.next_out) { if (strm.avail_out === 0 || status === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) { if (this.options.to === "string") { next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
tail = strm.next_out - next_out_utf8;
utf8str = strings.buf2string(strm.output, next_out_utf8);
strm.next_out = tail;
strm.avail_out = chunkSize - tail; if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0) }
this.onData(utf8str) } else { this.onData(utils.shrinkBuf(strm.output, strm.next_out)) } } } if (strm.avail_in === 0 && strm.avail_out === 0) { allowBufError = true } } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END); if (status === c.Z_STREAM_END) { _mode = c.Z_FINISH } if (_mode === c.Z_FINISH) { status = zlib_inflate.inflateEnd(this.strm);
this.onEnd(status);
this.ended = true; return status === c.Z_OK } if (_mode === c.Z_SYNC_FLUSH) { this.onEnd(c.Z_OK);
strm.avail_out = 0; return true } return true };
Inflate.prototype.onData = function(chunk) { this.chunks.push(chunk) };
Inflate.prototype.onEnd = function(status) { if (status === c.Z_OK) { if (this.options.to === "string") { this.result = this.chunks.join("") } else { this.result = utils.flattenChunks(this.chunks) } }
this.chunks = [];
this.err = status;
this.msg = this.strm.msg };
function inflate(input, options) { var inflator = new Inflate(options);
inflator.push(input, true); if (inflator.err) { throw inflator.msg } return inflator.result }
function inflateRaw(input, options) { options = options || {};
options.raw = true; return inflate(input, options) }
exports.Inflate = Inflate;
exports.inflate = inflate;
exports.inflateRaw = inflateRaw;
exports.ungzip = inflate }, { "./utils/common": 4, "./utils/strings": 5, "./zlib/constants": 7, "./zlib/gzheader": 10, "./zlib/inflate.js": 12, "./zlib/messages": 14, "./zlib/zstream": 16 }],
4: [function(require, module, exports) { "use strict"; var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined";
exports.assign = function(obj) { var sources = Array.prototype.slice.call(arguments, 1); while (sources.length) { var source = sources.shift(); if (!source) { continue } if (typeof source !== "object") { throw new TypeError(source + "must be non-object") } for (var p in source) { if (source.hasOwnProperty(p)) { obj[p] = source[p] } } } return obj };
exports.shrinkBuf = function(buf, size) { if (buf.length === size) { return buf } if (buf.subarray) { return buf.subarray(0, size) }
buf.length = size; return buf }; var fnTyped = { arraySet: function(dest, src, src_offs, len, dest_offs) { if (src.subarray && dest.subarray) { dest.set(src.subarray(src_offs, src_offs + len), dest_offs); return } for (var i = 0; i < len; i++) { dest[dest_offs + i] = src[src_offs + i] } }, flattenChunks: function(chunks) { var i, l, len, pos, chunk, result;
len = 0; for (i = 0, l = chunks.length; i < l; i++) { len += chunks[i].length }
result = new Uint8Array(len);
pos = 0; for (i = 0, l = chunks.length; i < l; i++) { chunk = chunks[i];
result.set(chunk, pos);
pos += chunk.length } return result } }; var fnUntyped = { arraySet: function(dest, src, src_offs, len, dest_offs) { for (var i = 0; i < len; i++) { dest[dest_offs + i] = src[src_offs + i] } }, flattenChunks: function(chunks) { return [].concat.apply([], chunks) } };
exports.setTyped = function(on) { if (on) { exports.Buf8 = Uint8Array;
exports.Buf16 = Uint16Array;
exports.Buf32 = Int32Array;
exports.assign(exports, fnTyped) } else { exports.Buf8 = Array;
exports.Buf16 = Array;
exports.Buf32 = Array;
exports.assign(exports, fnUntyped) } };
exports.setTyped(TYPED_OK) }, {}],
5: [function(require, module, exports) { "use strict"; var utils = require("./common"); var STR_APPLY_OK = true; var STR_APPLY_UIA_OK = true; try { String.fromCharCode.apply(null, [0]) } catch (__) { STR_APPLY_OK = false } try { String.fromCharCode.apply(null, new Uint8Array(1)) } catch (__) { STR_APPLY_UIA_OK = false } var _utf8len = new utils.Buf8(256); for (var q = 0; q < 256; q++) { _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1 }
_utf8len[254] = _utf8len[254] = 1;
exports.string2buf = function(str) { var buf, c, c2, m_pos, i, str_len = str.length,
buf_len = 0; for (m_pos = 0; m_pos < str_len; m_pos++) { c = str.charCodeAt(m_pos); if ((c & 64512) === 55296 && m_pos + 1 < str_len) { c2 = str.charCodeAt(m_pos + 1); if ((c2 & 64512) === 56320) { c = 65536 + (c - 55296 << 10) + (c2 - 56320);
m_pos++ } }
buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4 }
buf = new utils.Buf8(buf_len); for (i = 0, m_pos = 0; i < buf_len; m_pos++) { c = str.charCodeAt(m_pos); if ((c & 64512) === 55296 && m_pos + 1 < str_len) { c2 = str.charCodeAt(m_pos + 1); if ((c2 & 64512) === 56320) { c = 65536 + (c - 55296 << 10) + (c2 - 56320);
m_pos++ } } if (c < 128) { buf[i++] = c } else if (c < 2048) { buf[i++] = 192 | c >>> 6;
buf[i++] = 128 | c & 63 } else if (c < 65536) { buf[i++] = 224 | c >>> 12;
buf[i++] = 128 | c >>> 6 & 63;
buf[i++] = 128 | c & 63 } else { buf[i++] = 240 | c >>> 18;
buf[i++] = 128 | c >>> 12 & 63;
buf[i++] = 128 | c >>> 6 & 63;
buf[i++] = 128 | c & 63 } } return buf };
function buf2binstring(buf, len) { if (len < 65537) { if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) { return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len)) } } var result = ""; for (var i = 0; i < len; i++) { result += String.fromCharCode(buf[i]) } return result }
exports.buf2binstring = function(buf) { return buf2binstring(buf, buf.length) };
exports.binstring2buf = function(str) { var buf = new utils.Buf8(str.length); for (var i = 0, len = buf.length; i < len; i++) { buf[i] = str.charCodeAt(i) } return buf };
exports.buf2string = function(buf, max) { var i, out, c, c_len; var len = max || buf.length; var utf16buf = new Array(len * 2); for (out = 0, i = 0; i < len;) { c = buf[i++]; if (c < 128) { utf16buf[out++] = c; continue }
c_len = _utf8len[c]; if (c_len > 4) { utf16buf[out++] = 65533;
i += c_len - 1; continue }
c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7; while (c_len > 1 && i < len) { c = c << 6 | buf[i++] & 63;
c_len-- } if (c_len > 1) { utf16buf[out++] = 65533; continue } if (c < 65536) { utf16buf[out++] = c } else { c -= 65536;
utf16buf[out++] = 55296 | c >> 10 & 1023;
utf16buf[out++] = 56320 | c & 1023 } } return buf2binstring(utf16buf, out) };
exports.utf8border = function(buf, max) { var pos;
max = max || buf.length; if (max > buf.length) { max = buf.length }
pos = max - 1; while (pos >= 0 && (buf[pos] & 192) === 128) { pos-- } if (pos < 0) { return max } if (pos === 0) { return max } return pos + _utf8len[buf[pos]] > max ? pos : max } }, { "./common": 4 }],
6: [function(require, module, exports) { "use strict";
function adler32(adler, buf, len, pos) { var s1 = adler & 65535 | 0,
s2 = adler >>> 16 & 65535 | 0,
n = 0; while (len !== 0) { n = len > 2e3 ? 2e3 : len;
len -= n;
do { s1 = s1 + buf[pos++] | 0;
s2 = s2 + s1 | 0 } while (--n);
s1 %= 65521;
s2 %= 65521 } return s1 | s2 << 16 | 0 }
module.exports = adler32 }, {}],
7: [function(require, module, exports) { module.exports = { Z_NO_FLUSH: 0, Z_PARTIAL_FLUSH: 1, Z_SYNC_FLUSH: 2, Z_FULL_FLUSH: 3, Z_FINISH: 4, Z_BLOCK: 5, Z_TREES: 6, Z_OK: 0, Z_STREAM_END: 1, Z_NEED_DICT: 2, Z_ERRNO: -1, Z_STREAM_ERROR: -2, Z_DATA_ERROR: -3, Z_BUF_ERROR: -5, Z_NO_COMPRESSION: 0, Z_BEST_SPEED: 1, Z_BEST_COMPRESSION: 9, Z_DEFAULT_COMPRESSION: -1, Z_FILTERED: 1, Z_HUFFMAN_ONLY: 2, Z_RLE: 3, Z_FIXED: 4, Z_DEFAULT_STRATEGY: 0, Z_BINARY: 0, Z_TEXT: 1, Z_UNKNOWN: 2, Z_DEFLATED: 8 } }, {}],
8: [function(require, module, exports) { "use strict";
function makeTable() { var c, table = []; for (var n = 0; n < 256; n++) { c = n; for (var k = 0; k < 8; k++) { c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1 }
table[n] = c } return table } var crcTable = makeTable();
function crc32(crc, buf, len, pos) { var t = crcTable,
end = pos + len;
crc = crc ^ -1; for (var i = pos; i < end; i++) { crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255] } return crc ^ -1 }
module.exports = crc32 }, {}],
9: [function(require, module, exports) {
"use strict";
var utils = require("../utils/common");
var trees = require("./trees");
var adler32 = require("./adler32");
var crc32 = require("./crc32");
var msg = require("./messages");
var Z_NO_FLUSH = 0;
var Z_PARTIAL_FLUSH = 1;
var Z_FULL_FLUSH = 3;
var Z_FINISH = 4;
var Z_BLOCK = 5;
var Z_OK = 0;
var Z_STREAM_END = 1;
var Z_STREAM_ERROR = -2;
var Z_DATA_ERROR = -3;
var Z_BUF_ERROR = -5;
var Z_DEFAULT_COMPRESSION = -1;
var Z_FILTERED = 1;
var Z_HUFFMAN_ONLY = 2;
var Z_RLE = 3;
var Z_FIXED = 4;
var Z_DEFAULT_STRATEGY = 0;
var Z_UNKNOWN = 2;
var Z_DEFLATED = 8;
var MAX_MEM_LEVEL = 9;
var MAX_WBITS = 15;
var DEF_MEM_LEVEL = 8;
var LENGTH_CODES = 29;
var LITERALS = 256;
var L_CODES = LITERALS + 1 + LENGTH_CODES;
var D_CODES = 30;
var BL_CODES = 19;
var HEAP_SIZE = 2 * L_CODES + 1;
var MAX_BITS = 15;
var MIN_MATCH = 3;
var MAX_MATCH = 258;
var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
var PRESET_DICT = 32;
var INIT_STATE = 42;
var EXTRA_STATE = 69;
var NAME_STATE = 73;
var COMMENT_STATE = 91;
var HCRC_STATE = 103;
var BUSY_STATE = 113;
var FINISH_STATE = 666;
var BS_NEED_MORE = 1;
var BS_BLOCK_DONE = 2;
var BS_FINISH_STARTED = 3;
var BS_FINISH_DONE = 4;
var OS_CODE = 3;
function err(strm, errorCode) { strm.msg = msg[errorCode]; return errorCode }
function rank(f) { return (f << 1) - (f > 4 ? 9 : 0) }
function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0 } }
function flush_pending(strm) { var s = strm.state; var len = s.pending; if (len > strm.avail_out) { len = strm.avail_out } if (len === 0) { return }
utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
strm.next_out += len;
s.pending_out += len;
strm.total_out += len;
strm.avail_out -= len;
s.pending -= len; if (s.pending === 0) { s.pending_out = 0 } }
function flush_block_only(s, last) { trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);
s.block_start = s.strstart;
flush_pending(s.strm) }
function put_byte(s, b) { s.pending_buf[s.pending++] = b }
function putShortMSB(s, b) { s.pending_buf[s.pending++] = b >>> 8 & 255;
s.pending_buf[s.pending++] = b & 255 }
function read_buf(strm, buf, start, size) { var len = strm.avail_in; if (len > size) { len = size } if (len === 0) { return 0 }
strm.avail_in -= len;
utils.arraySet(buf, strm.input, strm.next_in, len, start); if (strm.state.wrap === 1) { strm.adler = adler32(strm.adler, buf, len, start) } else if (strm.state.wrap === 2) { strm.adler = crc32(strm.adler, buf, len, start) }
strm.next_in += len;
strm.total_in += len; return len }
function longest_match(s, cur_match) { var chain_length = s.max_chain_length; var scan = s.strstart; var match; var len; var best_len = s.prev_length; var nice_match = s.nice_match; var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0; var _win = s.window; var wmask = s.w_mask; var prev = s.prev; var strend = s.strstart + MAX_MATCH; var scan_end1 = _win[scan + best_len - 1]; var scan_end = _win[scan + best_len]; if (s.prev_length >= s.good_match) { chain_length >>= 2 } if (nice_match > s.lookahead) { nice_match = s.lookahead }
do { match = cur_match; if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) { continue }
scan += 2;
match++;
do {} while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend);
len = MAX_MATCH - (strend - scan);
scan = strend - MAX_MATCH; if (len > best_len) { s.match_start = cur_match;
best_len = len; if (len >= nice_match) { break }
scan_end1 = _win[scan + best_len - 1];
scan_end = _win[scan + best_len] } } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); if (best_len <= s.lookahead) { return best_len } return s.lookahead }
function fill_window(s) { var _w_size = s.w_size; var p, n, m, more, str;
do { more = s.window_size - s.lookahead - s.strstart; if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
s.match_start -= _w_size;
s.strstart -= _w_size;
s.block_start -= _w_size;
n = s.hash_size;
p = n;
do { m = s.head[--p];
s.head[p] = m >= _w_size ? m - _w_size : 0 } while (--n);
n = _w_size;
p = n;
do { m = s.prev[--p];
s.prev[p] = m >= _w_size ? m - _w_size : 0 } while (--n);
more += _w_size } if (s.strm.avail_in === 0) { break }
n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
s.lookahead += n; if (s.lookahead + s.insert >= MIN_MATCH) { str = s.strstart - s.insert;
s.ins_h = s.window[str];
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask; while (s.insert) { s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
s.prev[str & s.w_mask] = s.head[s.ins_h];
s.head[s.ins_h] = str;
str++;
s.insert--; if (s.lookahead + s.insert < MIN_MATCH) { break } } } } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0) }
function deflate_stored(s, flush) { var max_block_size = 65535; if (max_block_size > s.pending_buf_size - 5) { max_block_size = s.pending_buf_size - 5 } for (;;) { if (s.lookahead <= 1) { fill_window(s); if (s.lookahead === 0 && flush === Z_NO_FLUSH) { return BS_NEED_MORE } if (s.lookahead === 0) { break } }
s.strstart += s.lookahead;
s.lookahead = 0; var max_start = s.block_start + max_block_size; if (s.strstart === 0 || s.strstart >= max_start) { s.lookahead = s.strstart - max_start;
s.strstart = max_start;
flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } }
s.insert = 0; if (flush === Z_FINISH) { flush_block_only(s, true); if (s.strm.avail_out === 0) { return BS_FINISH_STARTED } return BS_FINISH_DONE } if (s.strstart > s.block_start) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } return BS_NEED_MORE }
function deflate_fast(s, flush) { var hash_head; var bflush; for (;;) { if (s.lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { return BS_NEED_MORE } if (s.lookahead === 0) { break } }
hash_head = 0; if (s.lookahead >= MIN_MATCH) { s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
s.head[s.ins_h] = s.strstart } if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { s.match_length = longest_match(s, hash_head) } if (s.match_length >= MIN_MATCH) { bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
s.lookahead -= s.match_length; if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) { s.match_length--;
do { s.strstart++;
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
s.head[s.ins_h] = s.strstart } while (--s.match_length !== 0);
s.strstart++ } else { s.strstart += s.match_length;
s.match_length = 0;
s.ins_h = s.window[s.strstart];
s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask } } else { bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
s.lookahead--;
s.strstart++ } if (bflush) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } }
s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; if (flush === Z_FINISH) { flush_block_only(s, true); if (s.strm.avail_out === 0) { return BS_FINISH_STARTED } return BS_FINISH_DONE } if (s.last_lit) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } return BS_BLOCK_DONE }
function deflate_slow(s, flush) { var hash_head; var bflush; var max_insert; for (;;) { if (s.lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { return BS_NEED_MORE } if (s.lookahead === 0) { break } }
hash_head = 0; if (s.lookahead >= MIN_MATCH) { s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
s.head[s.ins_h] = s.strstart }
s.prev_length = s.match_length;
s.prev_match = s.match_start;
s.match_length = MIN_MATCH - 1; if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { s.match_length = longest_match(s, hash_head); if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) { s.match_length = MIN_MATCH - 1 } } if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { max_insert = s.strstart + s.lookahead - MIN_MATCH;
bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
s.lookahead -= s.prev_length - 1;
s.prev_length -= 2;
do { if (++s.strstart <= max_insert) { s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
s.head[s.ins_h] = s.strstart } } while (--s.prev_length !== 0);
s.match_available = 0;
s.match_length = MIN_MATCH - 1;
s.strstart++; if (bflush) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } } else if (s.match_available) { bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); if (bflush) { flush_block_only(s, false) }
s.strstart++;
s.lookahead--; if (s.strm.avail_out === 0) { return BS_NEED_MORE } } else { s.match_available = 1;
s.strstart++;
s.lookahead-- } } if (s.match_available) { bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
s.match_available = 0 }
s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; if (flush === Z_FINISH) { flush_block_only(s, true); if (s.strm.avail_out === 0) { return BS_FINISH_STARTED } return BS_FINISH_DONE } if (s.last_lit) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } return BS_BLOCK_DONE }
function deflate_rle(s, flush) { var bflush; var prev; var scan, strend; var _win = s.window; for (;;) { if (s.lookahead <= MAX_MATCH) { fill_window(s); if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { return BS_NEED_MORE } if (s.lookahead === 0) { break } }
s.match_length = 0; if (s.lookahead >= MIN_MATCH && s.strstart > 0) { scan = s.strstart - 1;
prev = _win[scan]; if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { strend = s.strstart + MAX_MATCH;
do {} while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend);
s.match_length = MAX_MATCH - (strend - scan); if (s.match_length > s.lookahead) { s.match_length = s.lookahead } } } if (s.match_length >= MIN_MATCH) { bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
s.lookahead -= s.match_length;
s.strstart += s.match_length;
s.match_length = 0 } else { bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
s.lookahead--;
s.strstart++ } if (bflush) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } }
s.insert = 0; if (flush === Z_FINISH) { flush_block_only(s, true); if (s.strm.avail_out === 0) { return BS_FINISH_STARTED } return BS_FINISH_DONE } if (s.last_lit) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } return BS_BLOCK_DONE }
function deflate_huff(s, flush) { var bflush; for (;;) { if (s.lookahead === 0) { fill_window(s); if (s.lookahead === 0) { if (flush === Z_NO_FLUSH) { return BS_NEED_MORE } break } }
s.match_length = 0;
bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
s.lookahead--;
s.strstart++; if (bflush) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } }
s.insert = 0; if (flush === Z_FINISH) { flush_block_only(s, true); if (s.strm.avail_out === 0) { return BS_FINISH_STARTED } return BS_FINISH_DONE } if (s.last_lit) { flush_block_only(s, false); if (s.strm.avail_out === 0) { return BS_NEED_MORE } } return BS_BLOCK_DONE }
var Config = function(good_length, max_lazy, nice_length, max_chain, func) { this.good_length = good_length;
this.max_lazy = max_lazy;
this.nice_length = nice_length;
this.max_chain = max_chain;
this.func = func };
var configuration_table;
configuration_table = [new Config(0, 0, 0, 0, deflate_stored), new Config(4, 4, 8, 4, deflate_fast), new Config(4, 5, 16, 8, deflate_fast), new Config(4, 6, 32, 32, deflate_fast), new Config(4, 4, 16, 16, deflate_slow), new Config(8, 16, 32, 32, deflate_slow), new Config(8, 16, 128, 128, deflate_slow), new Config(8, 32, 128, 256, deflate_slow), new Config(32, 128, 258, 1024, deflate_slow), new Config(32, 258, 258, 4096, deflate_slow)];
function lm_init(s) { s.window_size = 2 * s.w_size;
zero(s.head);
s.max_lazy_match = configuration_table[s.level].max_lazy;
s.good_match = configuration_table[s.level].good_length;
s.nice_match = configuration_table[s.level].nice_length;
s.max_chain_length = configuration_table[s.level].max_chain;
s.strstart = 0;
s.block_start = 0;
s.lookahead = 0;
s.insert = 0;
s.match_length = s.prev_length = MIN_MATCH - 1;
s.match_available = 0;
s.ins_h = 0 }
function DeflateState() { this.strm = null;
this.status = 0;
this.pending_buf = null;
this.pending_buf_size = 0;
this.pending_out = 0;
this.pending = 0;
this.wrap = 0;
this.gzhead = null;
this.gzindex = 0;
this.method = Z_DEFLATED;
this.last_flush = -1;
this.w_size = 0;
this.w_bits = 0;
this.w_mask = 0;
this.window = null;
this.window_size = 0;
this.prev = null;
this.head = null;
this.ins_h = 0;
this.hash_size = 0;
this.hash_bits = 0;
this.hash_mask = 0;
this.hash_shift = 0;
this.block_start = 0;
this.match_length = 0;
this.prev_match = 0;
this.match_available = 0;
this.strstart = 0;
this.match_start = 0;
this.lookahead = 0;
this.prev_length = 0;
this.max_chain_length = 0;
this.max_lazy_match = 0;
this.level = 0;
this.strategy = 0;
this.good_match = 0;
this.nice_match = 0;
this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2);
this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2);
this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2);
zero(this.dyn_ltree);
zero(this.dyn_dtree);
zero(this.bl_tree);
this.l_desc = null;
this.d_desc = null;
this.bl_desc = null;
this.bl_count = new utils.Buf16(MAX_BITS + 1);
this.heap = new utils.Buf16(2 * L_CODES + 1);
zero(this.heap);
this.heap_len = 0;
this.heap_max = 0;
this.depth = new utils.Buf16(2 * L_CODES + 1);
zero(this.depth);
this.l_buf = 0;
this.lit_bufsize = 0;
this.last_lit = 0;
this.d_buf = 0;
this.opt_len = 0;
this.static_len = 0;
this.matches = 0;
this.insert = 0;
this.bi_buf = 0;
this.bi_valid = 0 }
function deflateResetKeep(strm) { var s; if (!strm || !strm.state) { return err(strm, Z_STREAM_ERROR) }
strm.total_in = strm.total_out = 0;
strm.data_type = Z_UNKNOWN;
s = strm.state;
s.pending = 0;
s.pending_out = 0; if (s.wrap < 0) { s.wrap = -s.wrap }
s.status = s.wrap ? INIT_STATE : BUSY_STATE;
strm.adler = s.wrap === 2 ? 0 : 1;
s.last_flush = Z_NO_FLUSH;
trees._tr_init(s); return Z_OK }
function deflateReset(strm) { var ret = deflateResetKeep(strm); if (ret === Z_OK) { lm_init(strm.state) } return ret }
function deflateSetHeader(strm, head) { if (!strm || !strm.state) { return Z_STREAM_ERROR } if (strm.state.wrap !== 2) { return Z_STREAM_ERROR }
strm.state.gzhead = head; return Z_OK }
function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { if (!strm) { return Z_STREAM_ERROR } var wrap = 1; if (level === Z_DEFAULT_COMPRESSION) { level = 6 } if (windowBits < 0) { wrap = 0;
windowBits = -windowBits } else if (windowBits > 15) { wrap = 2;
windowBits -= 16 } if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { return err(strm, Z_STREAM_ERROR) } if (windowBits === 8) { windowBits = 9 } var s = new DeflateState;
strm.state = s;
s.strm = strm;
s.wrap = wrap;
s.gzhead = null;
s.w_bits = windowBits;
s.w_size = 1 << s.w_bits;
s.w_mask = s.w_size - 1;
s.hash_bits = memLevel + 7;
s.hash_size = 1 << s.hash_bits;
s.hash_mask = s.hash_size - 1;
s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
s.window = new utils.Buf8(s.w_size * 2);
s.head = new utils.Buf16(s.hash_size);
s.prev = new utils.Buf16(s.w_size);
s.lit_bufsize = 1 << memLevel + 6;
s.pending_buf_size = s.lit_bufsize * 4;
s.pending_buf = new utils.Buf8(s.pending_buf_size);
s.d_buf = s.lit_bufsize >> 1;
s.l_buf = (1 + 2) * s.lit_bufsize;
s.level = level;
s.strategy = strategy;
s.method = method; return deflateReset(strm) }
function deflateInit(strm, level) { return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY) }
function deflate(strm, flush) {
var old_flush, s;
var beg, val;
if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) { return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR }
s = strm.state;
if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z_FINISH) { return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR) }
s.strm = strm;
old_flush = s.last_flush;
s.last_flush = flush;
if (s.status === INIT_STATE) { if (s.wrap === 2) { strm.adler = 0;
put_byte(s, 31);
put_byte(s, 139);
put_byte(s, 8); if (!s.gzhead) { put_byte(s, 0);
put_byte(s, 0);
put_byte(s, 0);
put_byte(s, 0);
put_byte(s, 0);
put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
put_byte(s, OS_CODE);
s.status = BUSY_STATE } else { put_byte(s, (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16));
put_byte(s, s.gzhead.time & 255);
put_byte(s, s.gzhead.time >> 8 & 255);
put_byte(s, s.gzhead.time >> 16 & 255);
put_byte(s, s.gzhead.time >> 24 & 255);
put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
put_byte(s, s.gzhead.os & 255); if (s.gzhead.extra && s.gzhead.extra.length) { put_byte(s, s.gzhead.extra.length & 255);
put_byte(s, s.gzhead.extra.length >> 8 & 255) } if (s.gzhead.hcrc) { strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0) }
s.gzindex = 0;
s.status = EXTRA_STATE } } else { var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8; var level_flags = -1; if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { level_flags = 0 } else if (s.level < 6) { level_flags = 1 } else if (s.level === 6) { level_flags = 2 } else { level_flags = 3 }
header |= level_flags << 6; if (s.strstart !== 0) { header |= PRESET_DICT }
header += 31 - header % 31;
s.status = BUSY_STATE;
putShortMSB(s, header); if (s.strstart !== 0) { putShortMSB(s, strm.adler >>> 16);
putShortMSB(s, strm.adler & 65535) }
strm.adler = 1 } }
if (s.status === EXTRA_STATE) { if (s.gzhead.extra) { beg = s.pending; while (s.gzindex < (s.gzhead.extra.length & 65535)) { if (s.pending === s.pending_buf_size) { if (s.gzhead.hcrc && s.pending > beg) { strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg) }
flush_pending(strm);
beg = s.pending; if (s.pending === s.pending_buf_size) { break } }
put_byte(s, s.gzhead.extra[s.gzindex] & 255);
s.gzindex++ } if (s.gzhead.hcrc && s.pending > beg) { strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg) } if (s.gzindex === s.gzhead.extra.length) { s.gzindex = 0;
s.status = NAME_STATE } } else { s.status = NAME_STATE } }
if (s.status === NAME_STATE) { if (s.gzhead.name) { beg = s.pending;
do { if (s.pending === s.pending_buf_size) { if (s.gzhead.hcrc && s.pending > beg) { strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg) }
flush_pending(strm);
beg = s.pending; if (s.pending === s.pending_buf_size) { val = 1; break } } if (s.gzindex < s.gzhead.name.length) { val = s.gzhead.name.charCodeAt(s.gzindex++) & 255 } else { val = 0 }
put_byte(s, val) } while (val !== 0); if (s.gzhead.hcrc && s.pending > beg) { strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg) } if (val === 0) { s.gzindex = 0;
s.status = COMMENT_STATE } } else { s.status = COMMENT_STATE } }
if (s.status === COMMENT_STATE) { if (s.gzhead.comment) { beg = s.pending;
do { if (s.pending === s.pending_buf_size) { if (s.gzhead.hcrc && s.pending > beg) { strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg) }
flush_pending(strm);
beg = s.pending; if (s.pending === s.pending_buf_size) { val = 1; break } } if (s.gzindex < s.gzhead.comment.length) { val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255 } else { val = 0 }
put_byte(s, val) } while (val !== 0); if (s.gzhead.hcrc && s.pending > beg) { strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg) } if (val === 0) { s.status = HCRC_STATE } } else { s.status = HCRC_STATE } }
if (s.status === HCRC_STATE) { if (s.gzhead.hcrc) { if (s.pending + 2 > s.pending_buf_size) { flush_pending(strm) } if (s.pending + 2 <= s.pending_buf_size) { put_byte(s, strm.adler & 255);
put_byte(s, strm.adler >> 8 & 255);
strm.adler = 0;
s.status = BUSY_STATE } } else { s.status = BUSY_STATE } }
if (s.pending !== 0) { flush_pending(strm); if (strm.avail_out === 0) { s.last_flush = -1; return Z_OK } } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) { return err(strm, Z_BUF_ERROR) }
if (s.status === FINISH_STATE && strm.avail_in !== 0) { return err(strm, Z_BUF_ERROR) }
if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE) {
var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush);
if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { s.status = FINISH_STATE }
if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
if (strm.avail_out === 0) {
s.last_flush = -1
}
return Z_OK
}
if (bstate === BS_BLOCK_DONE) { if (flush === Z_PARTIAL_FLUSH) { trees._tr_align(s) } else if (flush !== Z_BLOCK) { trees._tr_stored_block(s, 0, 0, false); if (flush === Z_FULL_FLUSH) { zero(s.head); if (s.lookahead === 0) { s.strstart = 0;
s.block_start = 0;
s.insert = 0 } } }
flush_pending(strm); if (strm.avail_out === 0) { s.last_flush = -1; return Z_OK } }
}
if (flush !== Z_FINISH) { return Z_OK }
if (s.wrap <= 0) { return Z_STREAM_END }
if (s.wrap === 2) { put_byte(s, strm.adler & 255);
put_byte(s, strm.adler >> 8 & 255);
put_byte(s, strm.adler >> 16 & 255);
put_byte(s, strm.adler >> 24 & 255);
put_byte(s, strm.total_in & 255);
put_byte(s, strm.total_in >> 8 & 255);
put_byte(s, strm.total_in >> 16 & 255);
put_byte(s, strm.total_in >> 24 & 255) } else { putShortMSB(s, strm.adler >>> 16);
putShortMSB(s, strm.adler & 65535) }
flush_pending(strm);
if (s.wrap > 0) { s.wrap = -s.wrap }
return s.pending !== 0 ? Z_OK : Z_STREAM_END
}
function deflateEnd(strm) { var status; if (!strm || !strm.state) { return Z_STREAM_ERROR }
status = strm.state.status; if (status !== INIT_STATE && status !== EXTRA_STATE && status !== NAME_STATE && status !== COMMENT_STATE && status !== HCRC_STATE && status !== BUSY_STATE && status !== FINISH_STATE) { return err(strm, Z_STREAM_ERROR) }
strm.state = null; return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK }
exports.deflateInit = deflateInit;
exports.deflateInit2 = deflateInit2;
exports.deflateReset = deflateReset;
exports.deflateResetKeep = deflateResetKeep;
exports.deflateSetHeader = deflateSetHeader;
exports.deflate = deflate;
exports.deflateEnd = deflateEnd;
exports.deflateInfo = "pako deflate (from Nodeca project)"
}, { "../utils/common": 4, "./adler32": 6, "./crc32": 8, "./messages": 14, "./trees": 15 }],
10: [function(require, module, exports) { "use strict";
function GZheader() { this.text = 0;
this.time = 0;
this.xflags = 0;
this.os = 0;
this.extra = null;
this.extra_len = 0;
this.name = "";
this.comment = "";
this.hcrc = 0;
this.done = false }
module.exports = GZheader }, {}],
11: [function(require, module, exports) { "use strict"; var BAD = 30; var TYPE = 12;
module.exports = function inflate_fast(strm, start) { var state; var _in; var last; var _out; var beg; var end; var dmax; var wsize; var whave; var wnext; var s_window; var hold; var bits; var lcode; var dcode; var lmask; var dmask; var here; var op; var len; var dist; var from; var from_source; var input, output;
state = strm.state;
_in = strm.next_in;
input = strm.input;
last = _in + (strm.avail_in - 5);
_out = strm.next_out;
output = strm.output;
beg = _out - (start - strm.avail_out);
end = _out + (strm.avail_out - 257);
dmax = state.dmax;
wsize = state.wsize;
whave = state.whave;
wnext = state.wnext;
s_window = state.window;
hold = state.hold;
bits = state.bits;
lcode = state.lencode;
dcode = state.distcode;
lmask = (1 << state.lenbits) - 1;
dmask = (1 << state.distbits) - 1;
top: do { if (bits < 15) { hold += input[_in++] << bits;
bits += 8;
hold += input[_in++] << bits;
bits += 8 }
here = lcode[hold & lmask];
dolen: for (;;) { op = here >>> 24;
hold >>>= op;
bits -= op;
op = here >>> 16 & 255; if (op === 0) { output[_out++] = here & 65535 } else if (op & 16) { len = here & 65535;
op &= 15; if (op) { if (bits < op) { hold += input[_in++] << bits;
bits += 8 }
len += hold & (1 << op) - 1;
hold >>>= op;
bits -= op } if (bits < 15) { hold += input[_in++] << bits;
bits += 8;
hold += input[_in++] << bits;
bits += 8 }
here = dcode[hold & dmask];
dodist: for (;;) { op = here >>> 24;
hold >>>= op;
bits -= op;
op = here >>> 16 & 255; if (op & 16) { dist = here & 65535;
op &= 15; if (bits < op) { hold += input[_in++] << bits;
bits += 8; if (bits < op) { hold += input[_in++] << bits;
bits += 8 } }
dist += hold & (1 << op) - 1; if (dist > dmax) { strm.msg = "invalid distance too far back";
state.mode = BAD; break top }
hold >>>= op;
bits -= op;
op = _out - beg; if (dist > op) { op = dist - op; if (op > whave) { if (state.sane) { strm.msg = "invalid distance too far back";
state.mode = BAD; break top } }
from = 0;
from_source = s_window; if (wnext === 0) { from += wsize - op; if (op < len) { len -= op;
do { output[_out++] = s_window[from++] } while (--op);
from = _out - dist;
from_source = output } } else if (wnext < op) { from += wsize + wnext - op;
op -= wnext; if (op < len) { len -= op;
do { output[_out++] = s_window[from++] } while (--op);
from = 0; if (wnext < len) { op = wnext;
len -= op;
do { output[_out++] = s_window[from++] } while (--op);
from = _out - dist;
from_source = output } } } else { from += wnext - op; if (op < len) { len -= op;
do { output[_out++] = s_window[from++] } while (--op);
from = _out - dist;
from_source = output } } while (len > 2) { output[_out++] = from_source[from++];
output[_out++] = from_source[from++];
output[_out++] = from_source[from++];
len -= 3 } if (len) { output[_out++] = from_source[from++]; if (len > 1) { output[_out++] = from_source[from++] } } } else { from = _out - dist;
do { output[_out++] = output[from++];
output[_out++] = output[from++];
output[_out++] = output[from++];
len -= 3 } while (len > 2); if (len) { output[_out++] = output[from++]; if (len > 1) { output[_out++] = output[from++] } } } } else if ((op & 64) === 0) { here = dcode[(here & 65535) + (hold & (1 << op) - 1)]; continue dodist } else { strm.msg = "invalid distance code";
state.mode = BAD; break top } break } } else if ((op & 64) === 0) { here = lcode[(here & 65535) + (hold & (1 << op) - 1)]; continue dolen } else if (op & 32) { state.mode = TYPE; break top } else { strm.msg = "invalid literal/length code";
state.mode = BAD; break top } break } } while (_in < last && _out < end);
len = bits >> 3;
_in -= len;
bits -= len << 3;
hold &= (1 << bits) - 1;
strm.next_in = _in;
strm.next_out = _out;
strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
state.hold = hold;
state.bits = bits; return } }, {}],
12: [function(require, module, exports) { "use strict"; var utils = require("../utils/common"); var adler32 = require("./adler32"); var crc32 = require("./crc32"); var inflate_fast = require("./inffast"); var inflate_table = require("./inftrees"); var CODES = 0; var LENS = 1; var DISTS = 2; var Z_FINISH = 4; var Z_BLOCK = 5; var Z_TREES = 6; var Z_OK = 0; var Z_STREAM_END = 1; var Z_NEED_DICT = 2; var Z_STREAM_ERROR = -2; var Z_DATA_ERROR = -3; var Z_MEM_ERROR = -4; var Z_BUF_ERROR = -5; var Z_DEFLATED = 8; var HEAD = 1; var FLAGS = 2; var TIME = 3; var OS = 4; var EXLEN = 5; var EXTRA = 6; var NAME = 7; var COMMENT = 8; var HCRC = 9; var DICTID = 10; var DICT = 11; var TYPE = 12; var TYPEDO = 13; var STORED = 14; var COPY_ = 15; var COPY = 16; var TABLE = 17; var LENLENS = 18; var CODELENS = 19; var LEN_ = 20; var LEN = 21; var LENEXT = 22; var DIST = 23; var DISTEXT = 24; var MATCH = 25; var LIT = 26; var CHECK = 27; var LENGTH = 28; var DONE = 29; var BAD = 30; var MEM = 31; var SYNC = 32; var ENOUGH_LENS = 852; var ENOUGH_DISTS = 592; var MAX_WBITS = 15; var DEF_WBITS = MAX_WBITS;
function ZSWAP32(q) { return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24) }
function InflateState() { this.mode = 0;
this.last = false;
this.wrap = 0;
this.havedict = false;
this.flags = 0;
this.dmax = 0;
this.check = 0;
this.total = 0;
this.head = null;
this.wbits = 0;
this.wsize = 0;
this.whave = 0;
this.wnext = 0;
this.window = null;
this.hold = 0;
this.bits = 0;
this.length = 0;
this.offset = 0;
this.extra = 0;
this.lencode = null;
this.distcode = null;
this.lenbits = 0;
this.distbits = 0;
this.ncode = 0;
this.nlen = 0;
this.ndist = 0;
this.have = 0;
this.next = null;
this.lens = new utils.Buf16(320);
this.work = new utils.Buf16(288);
this.lendyn = null;
this.distdyn = null;
this.sane = 0;
this.back = 0;
this.was = 0 }
function inflateResetKeep(strm) { var state; if (!strm || !strm.state) { return Z_STREAM_ERROR }
state = strm.state;
strm.total_in = strm.total_out = state.total = 0;
strm.msg = ""; if (state.wrap) { strm.adler = state.wrap & 1 }
state.mode = HEAD;
state.last = 0;
state.havedict = 0;
state.dmax = 32768;
state.head = null;
state.hold = 0;
state.bits = 0;
state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
state.sane = 1;
state.back = -1; return Z_OK }
function inflateReset(strm) { var state; if (!strm || !strm.state) { return Z_STREAM_ERROR }
state = strm.state;
state.wsize = 0;
state.whave = 0;
state.wnext = 0; return inflateResetKeep(strm) }
function inflateReset2(strm, windowBits) { var wrap; var state; if (!strm || !strm.state) { return Z_STREAM_ERROR }
state = strm.state; if (windowBits < 0) { wrap = 0;
windowBits = -windowBits } else { wrap = (windowBits >> 4) + 1; if (windowBits < 48) { windowBits &= 15 } } if (windowBits && (windowBits < 8 || windowBits > 15)) { return Z_STREAM_ERROR } if (state.window !== null && state.wbits !== windowBits) { state.window = null }
state.wrap = wrap;
state.wbits = windowBits; return inflateReset(strm) }
function inflateInit2(strm, windowBits) { var ret; var state; if (!strm) { return Z_STREAM_ERROR }
state = new InflateState;
strm.state = state;
state.window = null;
ret = inflateReset2(strm, windowBits); if (ret !== Z_OK) { strm.state = null } return ret }
function inflateInit(strm) { return inflateInit2(strm, DEF_WBITS) } var virgin = true; var lenfix, distfix;
function fixedtables(state) { if (virgin) { var sym;
lenfix = new utils.Buf32(512);
distfix = new utils.Buf32(32);
sym = 0; while (sym < 144) { state.lens[sym++] = 8 } while (sym < 256) { state.lens[sym++] = 9 } while (sym < 280) { state.lens[sym++] = 7 } while (sym < 288) { state.lens[sym++] = 8 }
inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
sym = 0; while (sym < 32) { state.lens[sym++] = 5 }
inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
virgin = false }
state.lencode = lenfix;
state.lenbits = 9;
state.distcode = distfix;
state.distbits = 5 }
function updatewindow(strm, src, end, copy) { var dist; var state = strm.state; if (state.window === null) { state.wsize = 1 << state.wbits;
state.wnext = 0;
state.whave = 0;
state.window = new utils.Buf8(state.wsize) } if (copy >= state.wsize) { utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
state.wnext = 0;
state.whave = state.wsize } else { dist = state.wsize - state.wnext; if (dist > copy) { dist = copy }
utils.arraySet(state.window, src, end - copy, dist, state.wnext);
copy -= dist; if (copy) { utils.arraySet(state.window, src, end - copy, copy, 0);
state.wnext = copy;
state.whave = state.wsize } else { state.wnext += dist; if (state.wnext === state.wsize) { state.wnext = 0 } if (state.whave < state.wsize) { state.whave += dist } } } return 0 }
function inflate(strm, flush) { var state; var input, output; var next; var put; var have, left; var hold; var bits; var _in, _out; var copy; var from; var from_source; var here = 0; var here_bits, here_op, here_val; var last_bits, last_op, last_val; var len; var ret; var hbuf = new utils.Buf8(4); var opts; var n; var order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) { return Z_STREAM_ERROR }
state = strm.state; if (state.mode === TYPE) { state.mode = TYPEDO }
put = strm.next_out;
output = strm.output;
left = strm.avail_out;
next = strm.next_in;
input = strm.input;
have = strm.avail_in;
hold = state.hold;
bits = state.bits;
_in = have;
_out = left;
ret = Z_OK;
inf_leave: for (;;) { switch (state.mode) {
case HEAD:
if (state.wrap === 0) { state.mode = TYPEDO; break } while (bits < 16) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 } if (state.wrap & 2 && hold === 35615) { state.check = 0;
hbuf[0] = hold & 255;
hbuf[1] = hold >>> 8 & 255;
state.check = crc32(state.check, hbuf, 2, 0);
hold = 0;
bits = 0;
state.mode = FLAGS; break }
state.flags = 0; if (state.head) { state.head.done = false } if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) { strm.msg = "incorrect header check";
state.mode = BAD; break } if ((hold & 15) !== Z_DEFLATED) { strm.msg = "unknown compression method";
state.mode = BAD; break }
hold >>>= 4;
bits -= 4;
len = (hold & 15) + 8; if (state.wbits === 0) { state.wbits = len } else if (len > state.wbits) { strm.msg = "invalid window size";
state.mode = BAD; break }
state.dmax = 1 << len;
strm.adler = state.check = 1;
state.mode = hold & 512 ? DICTID : TYPE;
hold = 0;
bits = 0; break;
case FLAGS:
while (bits < 16) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 }
state.flags = hold; if ((state.flags & 255) !== Z_DEFLATED) { strm.msg = "unknown compression method";
state.mode = BAD; break } if (state.flags & 57344) { strm.msg = "unknown header flags set";
state.mode = BAD; break } if (state.head) { state.head.text = hold >> 8 & 1 } if (state.flags & 512) { hbuf[0] = hold & 255;
hbuf[1] = hold >>> 8 & 255;
state.check = crc32(state.check, hbuf, 2, 0) }
hold = 0;
bits = 0;
state.mode = TIME;
case TIME:
while (bits < 32) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 } if (state.head) { state.head.time = hold } if (state.flags & 512) { hbuf[0] = hold & 255;
hbuf[1] = hold >>> 8 & 255;
hbuf[2] = hold >>> 16 & 255;
hbuf[3] = hold >>> 24 & 255;
state.check = crc32(state.check, hbuf, 4, 0) }
hold = 0;
bits = 0;
state.mode = OS;
case OS:
while (bits < 16) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 } if (state.head) { state.head.xflags = hold & 255;
state.head.os = hold >> 8 } if (state.flags & 512) { hbuf[0] = hold & 255;
hbuf[1] = hold >>> 8 & 255;
state.check = crc32(state.check, hbuf, 2, 0) }
hold = 0;
bits = 0;
state.mode = EXLEN;
case EXLEN:
if (state.flags & 1024) { while (bits < 16) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 }
state.length = hold; if (state.head) { state.head.extra_len = hold } if (state.flags & 512) { hbuf[0] = hold & 255;
hbuf[1] = hold >>> 8 & 255;
state.check = crc32(state.check, hbuf, 2, 0) }
hold = 0;
bits = 0 } else if (state.head) { state.head.extra = null }
state.mode = EXTRA;
case EXTRA:
if (state.flags & 1024) { copy = state.length; if (copy > have) { copy = have } if (copy) { if (state.head) { len = state.head.extra_len - state.length; if (!state.head.extra) { state.head.extra = new Array(state.head.extra_len) }
utils.arraySet(state.head.extra, input, next, copy, len) } if (state.flags & 512) { state.check = crc32(state.check, input, copy, next) }
have -= copy;
next += copy;
state.length -= copy } if (state.length) { break inf_leave } }
state.length = 0;
state.mode = NAME;
case NAME:
if (state.flags & 2048) { if (have === 0) { break inf_leave }
copy = 0;
do { len = input[next + copy++]; if (state.head && len && state.length < 65536) { state.head.name += String.fromCharCode(len) } } while (len && copy < have); if (state.flags & 512) { state.check = crc32(state.check, input, copy, next) }
have -= copy;
next += copy; if (len) { break inf_leave } } else if (state.head) { state.head.name = null }
state.length = 0;
state.mode = COMMENT;
case COMMENT:
if (state.flags & 4096) { if (have === 0) { break inf_leave }
copy = 0;
do { len = input[next + copy++]; if (state.head && len && state.length < 65536) { state.head.comment += String.fromCharCode(len) } } while (len && copy < have); if (state.flags & 512) { state.check = crc32(state.check, input, copy, next) }
have -= copy;
next += copy; if (len) { break inf_leave } } else if (state.head) { state.head.comment = null }
state.mode = HCRC;
case HCRC:
if (state.flags & 512) { while (bits < 16) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 } if (hold !== (state.check & 65535)) { strm.msg = "header crc mismatch";
state.mode = BAD; break }
hold = 0;
bits = 0 } if (state.head) { state.head.hcrc = state.flags >> 9 & 1;
state.head.done = true }
strm.adler = state.check = 0;
state.mode = TYPE; break;
case DICTID:
while (bits < 32) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 }
strm.adler = state.check = ZSWAP32(hold);
hold = 0;
bits = 0;
state.mode = DICT;
case DICT:
if (state.havedict === 0) { strm.next_out = put;
strm.avail_out = left;
strm.next_in = next;
strm.avail_in = have;
state.hold = hold;
state.bits = bits; return Z_NEED_DICT }
strm.adler = state.check = 1;
state.mode = TYPE;
case TYPE:
if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave }
case TYPEDO:
if (state.last) { hold >>>= bits & 7;
bits -= bits & 7;
state.mode = CHECK; break } while (bits < 3) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 }
state.last = hold & 1;
hold >>>= 1;
bits -= 1; switch (hold & 3) {
case 0:
state.mode = STORED; break;
case 1:
fixedtables(state);
state.mode = LEN_; if (flush === Z_TREES) { hold >>>= 2;
bits -= 2; break inf_leave } break;
case 2:
state.mode = TABLE; break;
case 3:
strm.msg = "invalid block type";
state.mode = BAD }
hold >>>= 2;
bits -= 2; break;
case STORED:
hold >>>= bits & 7;
bits -= bits & 7; while (bits < 32) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 } if ((hold & 65535) !== (hold >>> 16 ^ 65535)) { strm.msg = "invalid stored block lengths";
state.mode = BAD; break }
state.length = hold & 65535;
hold = 0;
bits = 0;
state.mode = COPY_; if (flush === Z_TREES) { break inf_leave }
case COPY_:
state.mode = COPY;
case COPY:
copy = state.length; if (copy) { if (copy > have) { copy = have } if (copy > left) { copy = left } if (copy === 0) { break inf_leave }
utils.arraySet(output, input, next, copy, put);
have -= copy;
next += copy;
left -= copy;
put += copy;
state.length -= copy; break }
state.mode = TYPE; break;
case TABLE:
while (bits < 14) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 }
state.nlen = (hold & 31) + 257;
hold >>>= 5;
bits -= 5;
state.ndist = (hold & 31) + 1;
hold >>>= 5;
bits -= 5;
state.ncode = (hold & 15) + 4;
hold >>>= 4;
bits -= 4; if (state.nlen > 286 || state.ndist > 30) { strm.msg = "too many length or distance symbols";
state.mode = BAD; break }
state.have = 0;
state.mode = LENLENS;
case LENLENS:
while (state.have < state.ncode) { while (bits < 3) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 }
state.lens[order[state.have++]] = hold & 7;
hold >>>= 3;
bits -= 3 } while (state.have < 19) { state.lens[order[state.have++]] = 0 }
state.lencode = state.lendyn;
state.lenbits = 7;
opts = { bits: state.lenbits };
ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
state.lenbits = opts.bits; if (ret) { strm.msg = "invalid code lengths set";
state.mode = BAD; break }
state.have = 0;
state.mode = CODELENS;
case CODELENS:
while (state.have < state.nlen + state.ndist) { for (;;) { here = state.lencode[hold & (1 << state.lenbits) - 1];
here_bits = here >>> 24;
here_op = here >>> 16 & 255;
here_val = here & 65535; if (here_bits <= bits) { break } if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 } if (here_val < 16) { hold >>>= here_bits;
bits -= here_bits;
state.lens[state.have++] = here_val } else { if (here_val === 16) { n = here_bits + 2; while (bits < n) { if (have === 0) { break inf_leave }
have--;
hold += input[next++] << bits;
bits += 8 }
hold >>>= here_bits;
bits -= here_bits; if (state.have === 0) { strm.msg = "invalid bit length repeat";
state.mode = BAD; break }
len = state.lens[state.have - 1];
copy = 3 + (hold & 3);
hold >>>= 2;
bits -= 2 } else if (here_val === 17) { n = here_bits + 3; while (bits < n) { if (have === 0) { break inf_leave }
have--;