Skip to content

Instantly share code, notes, and snippets.

@umbertocerrato

umbertocerrato/djvu.js

Last active April 9, 2023 10:37
Show Gist options
  • Save umbertocerrato/7c7e37c92c62436e75ae16fc4b1526d3 to your computer and use it in GitHub Desktop.
Save umbertocerrato/7c7e37c92c62436e75ae16fc4b1526d3 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
djvu.js
var DjVu = (function () {
'use strict';
function DjVuScript() {
'use strict';
var DjVu = {
VERSION: '0.5.4',
IS_DEBUG: false,
setDebugMode: (flag) => DjVu.IS_DEBUG = flag
};
function pLimit(limit = 4) {
const queue = [];
let running = 0;
const runNext = async () => {
if (!queue.length || running >= limit) return;
const func = queue.shift();
try {
running++;
await func();
} finally {
running--;
runNext();
}
};
return func => new Promise((resolve, reject) => {
queue.push(() => func().then(resolve, reject));
runNext();
});
}
function loadFileViaXHR(url, responseType = 'arraybuffer') {
return new Promise((resolve, reject) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url);
xhr.responseType = responseType;
xhr.onload = (e) => resolve(xhr);
xhr.onerror = (e) => reject(xhr);
xhr.send();
});
}
const utf8Decoder = self.TextDecoder ? new self.TextDecoder() : {
decode(utf8array) {
const codePoints = utf8ToCodePoints(utf8array);
return String.fromCodePoint(...codePoints);
}
};
function createStringFromUtf8Array(utf8array) {
return utf8Decoder.decode(utf8array);
}
function utf8ToCodePoints(utf8array) {
var i, c;
var codePoints = [];
i = 0;
while (i < utf8array.length) {
c = utf8array[i++];
switch (c >> 4) {
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
codePoints.push(c);
break;
case 12: case 13:
codePoints.push(((c & 0x1F) << 6) | (utf8array[i++] & 0x3F));
break;
case 14:
codePoints.push(
((c & 0x0F) << 12) |
((utf8array[i++] & 0x3F) << 6) |
(utf8array[i++] & 0x3F)
);
break;
case 15:
codePoints.push(
((c & 0x07) << 18) |
((utf8array[i++] & 0x3F) << 12) |
((utf8array[i++] & 0x3F) << 6) |
(utf8array[i++] & 0x3F)
);
break;
}
}
return codePoints.map(codePoint => {
return codePoint > 0x10FFFF ? 120 : codePoint;
});
}
function codePointsToUtf8(codePoints) {
var utf8array = [];
codePoints.forEach(codePoint => {
if (codePoint < 0x80) {
utf8array.push(codePoint);
} else if (codePoint < 0x800) {
utf8array.push(0xC0 | (codePoint >> 6));
utf8array.push(0x80 | (codePoint & 0x3F));
} else if (codePoint < 0x10000) {
utf8array.push(0xE0 | (codePoint >> 12));
utf8array.push(0x80 | ((codePoint >> 6) & 0x3F));
utf8array.push(0x80 | (codePoint & 0x3F));
} else {
utf8array.push(0xF0 | (codePoint >> 18));
utf8array.push(0x80 | ((codePoint >> 12) & 0x3F));
utf8array.push(0x80 | ((codePoint >> 6) & 0x3F));
utf8array.push(0x80 | (codePoint & 0x3F));
}
});
return new Uint8Array(utf8array);
}
function stringToCodePoints(str) {
var codePoints = [];
for (var i = 0; i < str.length; i++) {
var code = str.codePointAt(i);
codePoints.push(code);
if (code > 65535) {
i++;
}
}
return codePoints;
}
const pageSize = 64 * 1024;
const growthLimit = 20 * 1024 * 1024 / pageSize;
class ByteStreamWriter {
constructor(length = 0) {
this.memory = new WebAssembly.Memory({ initial: Math.ceil(length / pageSize), maximum: 65536 });
this.assignBufferFromMemory();
this.offset = 0;
this.offsetMarks = {};
}
assignBufferFromMemory() {
this.buffer = this.memory.buffer;
this.viewer = new DataView(this.buffer);
}
reset() {
this.offset = 0;
this.offsetMarks = {};
}
saveOffsetMark(mark) {
this.offsetMarks[mark] = this.offset;
return this;
}
writeByte(byte) {
this.checkOffset(1);
this.viewer.setUint8(this.offset++, byte);
return this;
}
writeStr(str) {
this.writeArray(codePointsToUtf8(stringToCodePoints(str)));
return this;
}
writeInt32(val) {
this.checkOffset(4);
this.viewer.setInt32(this.offset, val);
this.offset += 4;
return this;
}
rewriteInt32(off, val) {
var xoff = off;
if (typeof (xoff) === 'string') {
xoff = this.offsetMarks[off];
this.offsetMarks[off] += 4;
}
this.viewer.setInt32(xoff, val);
}
rewriteSize(offmark) {
if (!this.offsetMarks[offmark]) throw new Error('Unexisting offset mark');
var xoff = this.offsetMarks[offmark];
this.viewer.setInt32(xoff, this.offset - xoff - 4);
}
getBuffer() {
if (this.offset === this.buffer.byteLength) {
return this.buffer;
}
return this.buffer.slice(0, this.offset);
}
checkOffset(requiredBytesNumber = 0) {
const bool = this.offset + requiredBytesNumber > this.buffer.byteLength;
if (bool) {
this._expand(requiredBytesNumber);
}
return bool;
}
_expand(requiredBytesNumber) {
this.memory.grow(Math.max(
Math.ceil(requiredBytesNumber / pageSize),
Math.min(this.memory.buffer.byteLength / pageSize, growthLimit)
));
this.assignBufferFromMemory();
}
jump(length) {
length = +length;
if (length > 0) {
this.checkOffset(length);
}
this.offset += length;
return this;
}
writeByteStream(bs) {
this.writeArray(bs.toUint8Array());
}
writeArray(arr) {
while (this.checkOffset(arr.length)) { }
new Uint8Array(this.buffer).set(arr, this.offset);
this.offset += arr.length;
}
writeBuffer(buffer) {
this.writeArray(new Uint8Array(buffer));
}
writeStrNT(str) {
this.writeStr(str);
this.writeByte(0);
}
writeInt16(val) {
this.checkOffset(2);
this.viewer.setInt16(this.offset, val);
this.offset += 2;
return this;
}
writeUint16(val) {
this.checkOffset(2);
this.viewer.setUint16(this.offset, val);
this.offset += 2;
return this;
}
writeInt24(val) {
this.writeByte((val >> 16) & 0xff)
.writeByte((val >> 8) & 0xff)
.writeByte(val & 0xff);
return this;
}
}
class ZPEncoder {
constructor(bsw) {
this.bsw = bsw || new ByteStreamWriter();
this.a = 0;
this.scount = 0;
this.byte = 0;
this.delay = 25;
this.subend = 0;
this.buffer = 0xffffff;
this.nrun = 0;
}
outbit(bit) {
if (this.delay > 0) {
if (this.delay < 0xff)
this.delay -= 1;
}
else {
this.byte = (this.byte << 1) | bit;
if (++this.scount == 8) {
this.bsw.writeByte(this.byte);
this.scount = 0;
this.byte = 0;
}
}
}
zemit(b) {
this.buffer = (this.buffer << 1) + b;
b = (this.buffer >> 24);
this.buffer = (this.buffer & 0xffffff);
switch (b) {
case 1:
this.outbit(1);
while (this.nrun-- > 0)
this.outbit(0);
this.nrun = 0;
break;
case 0xff:
this.outbit(0);
while (this.nrun-- > 0)
this.outbit(1);
this.nrun = 0;
break;
case 0:
this.nrun += 1;
break;
default:
throw new Exception('ZPEncoder::zemit() error!');
}
}
encode(bit, ctx, n) {
bit = +bit;
if (!ctx) {
return this._ptencode(bit, 0x8000 + (this.a >> 1));
}
var z = this.a + this.p[ctx[n]];
if (bit != (ctx[n] & 1)) {
var d = 0x6000 + ((z + this.a) >> 2);
if (z > d) {
z = d;
}
ctx[n] = this.dn[ctx[n]];
z = 0x10000 - z;
this.subend += z;
this.a += z;
} else if (z >= 0x8000) {
var d = 0x6000 + ((z + this.a) >> 2);
if (z > d) {
z = d;
}
if (this.a >= this.m[ctx[n]])
ctx[n] = this.up[ctx[n]];
this.a = z;
} else {
this.a = z;
return;
}
while (this.a >= 0x8000) {
this.zemit(1 - (this.subend >> 15));
this.subend = 0xffff & (this.subend << 1);
this.a = 0xffff & (this.a << 1);
}
}
IWencode(bit) {
this._ptencode(bit, 0x8000 + ((this.a + this.a + this.a) >> 3));
}
_ptencode(bit, z) {
if (bit) {
z = 0x10000 - z;
this.subend += z;
this.a += z;
} else {
this.a = z;
}
while (this.a >= 0x8000) {
this.zemit(1 - (this.subend >> 15));
this.subend = 0xffff & (this.subend << 1);
this.a = 0xffff & (this.a << 1);
}
}
eflush() {
if (this.subend > 0x8000)
this.subend = 0x10000;
else if (this.subend > 0)
this.subend = 0x8000;
while (this.buffer != 0xffffff || this.subend) {
this.zemit(1 - (this.subend >> 15));
this.subend = 0xffff & (this.subend << 1);
}
this.outbit(1);
while (this.nrun-- > 0)
this.outbit(0);
this.nrun = 0;
while (this.scount > 0)
this.outbit(1);
this.delay = 0xff;
}
}
class ZPDecoder {
constructor(bs) {
this.bs = bs;
this.a = 0x0000;
this.c = this.bs.byte();
this.c <<= 8;
var tmp = this.bs.byte();
this.c |= tmp;
this.z = 0;
this.d = 0;
this.f = Math.min(this.c, 0x7fff);
this.ffzt = new Int8Array(256);
for (var i = 0; i < 256; i++) {
this.ffzt[i] = 0;
for (var j = i; j & 0x80; j <<= 1)
this.ffzt[i] += 1;
}
this.delay = 25;
this.scount = 0;
this.buffer = 0;
this.preload();
}
preload() {
while (this.scount <= 24) {
var byte = this.bs.byte();
this.buffer = (this.buffer << 8) | byte;
this.scount += 8;
}
}
ffz(x) {
return (x >= 0xff00) ? (this.ffzt[x & 0xff] + 8) : (this.ffzt[(x >> 8) & 0xff]);
}
decode(ctx, n) {
if (!ctx) {
return this._ptdecode(0x8000 + (this.a >> 1));
}
this.b = ctx[n] & 1;
this.z = this.a + this.p[ctx[n]];
if (this.z <= this.f) {
this.a = this.z;
return this.b;
}
this.d = 0x6000 + ((this.a + this.z) >> 2);
if (this.z > this.d) {
this.z = this.d;
}
if (this.z > this.c) {
this.b = 1 - this.b;
this.z = 0x10000 - this.z;
this.a += this.z;
this.c += this.z;
ctx[n] = this.dn[ctx[n]];
var shift = this.ffz(this.a);
this.scount -= shift;
this.a = 0xffff & (this.a << shift);
this.c = 0xffff & (
(this.c << shift) | (this.buffer >> this.scount) & ((1 << shift) - 1)
);
}
else {
if (this.a >= this.m[ctx[n]]) {
ctx[n] = this.up[ctx[n]];
}
this.scount--;
this.a = 0xffff & (this.z << 1);
this.c = 0xffff & (
(this.c << 1) | ((this.buffer >> this.scount) & 1)
);
}
if (this.scount < 16)
this.preload();
this.f = Math.min(this.c, 0x7fff);
return this.b;
}
IWdecode() {
return this._ptdecode(0x8000 + ((this.a + this.a + this.a) >> 3));
}
_ptdecode(z) {
this.b = 0;
if (z > this.c) {
this.b = 1;
z = 0x10000 - z;
this.a += z;
this.c += z;
var shift = this.ffz(this.a);
this.scount -= shift;
this.a = 0xffff & (this.a << shift);
this.c = 0xffff & (
(this.c << shift) | (this.buffer >> this.scount) & ((1 << shift) - 1)
);
}
else {
this.b = 0;
this.scount--;
this.a = 0xffff & (z << 1);
this.c = 0xffff & (
(this.c << 1) | ((this.buffer >> this.scount) & 1)
);
}
if (this.scount < 16)
this.preload();
this.f = Math.min(this.c, 0x7fff);
return this.b;
}
}
ZPEncoder.prototype.p = ZPDecoder.prototype.p = Uint16Array.of(
0x8000, 0x8000, 0x8000, 0x6bbd, 0x6bbd, 0x5d45, 0x5d45, 0x51b9, 0x51b9, 0x4813,
0x4813, 0x3fd5, 0x3fd5, 0x38b1, 0x38b1, 0x3275, 0x3275, 0x2cfd, 0x2cfd, 0x2825,
0x2825, 0x23ab, 0x23ab, 0x1f87, 0x1f87, 0x1bbb, 0x1bbb, 0x1845, 0x1845, 0x1523,
0x1523, 0x1253, 0x1253, 0xfcf, 0xfcf, 0xd95, 0xd95, 0xb9d, 0xb9d, 0x9e3,
0x9e3, 0x861, 0x861, 0x711, 0x711, 0x5f1, 0x5f1, 0x4f9, 0x4f9, 0x425,
0x425, 0x371, 0x371, 0x2d9, 0x2d9, 0x259, 0x259, 0x1ed, 0x1ed, 0x193,
0x193, 0x149, 0x149, 0x10b, 0x10b, 0xd5, 0xd5, 0xa5, 0xa5, 0x7b,
0x7b, 0x57, 0x57, 0x3b, 0x3b, 0x23, 0x23, 0x13, 0x13, 0x7,
0x7, 0x1, 0x1, 0x5695, 0x24ee, 0x8000, 0xd30, 0x481a, 0x481, 0x3579,
0x17a, 0x24ef, 0x7b, 0x1978, 0x28, 0x10ca, 0xd, 0xb5d, 0x34, 0x78a,
0xa0, 0x50f, 0x117, 0x358, 0x1ea, 0x234, 0x144, 0x173, 0x234, 0xf5,
0x353, 0xa1, 0x5c5, 0x11a, 0x3cf, 0x1aa, 0x285, 0x286, 0x1ab, 0x3d3,
0x11a, 0x5c5, 0xba, 0x8ad, 0x7a, 0xccc, 0x1eb, 0x1302, 0x2e6, 0x1b81,
0x45e, 0x24ef, 0x690, 0x2865, 0x9de, 0x3987, 0xdc8, 0x2c99, 0x10ca, 0x3b5f,
0xb5d, 0x5695, 0x78a, 0x8000, 0x50f, 0x24ee, 0x358, 0xd30, 0x234, 0x481,
0x173, 0x17a, 0xf5, 0x7b, 0xa1, 0x28, 0x11a, 0xd, 0x1aa, 0x34,
0x286, 0xa0, 0x3d3, 0x117, 0x5c5, 0x1ea, 0x8ad, 0x144, 0xccc, 0x234,
0x1302, 0x353, 0x1b81, 0x5c5, 0x24ef, 0x3cf, 0x2b74, 0x285, 0x201d, 0x1ab,
0x1715, 0x11a, 0xfb7, 0xba, 0xa67, 0x1eb, 0x6e7, 0x2e6, 0x496, 0x45e,
0x30d, 0x690, 0x206, 0x9de, 0x155, 0xdc8, 0xe1, 0x2b74, 0x94, 0x201d,
0x188, 0x1715, 0x252, 0xfb7, 0x383, 0xa67, 0x547, 0x6e7, 0x7e2, 0x496,
0xbc0, 0x30d, 0x1178, 0x206, 0x19da, 0x155, 0x24ef, 0xe1, 0x320e, 0x94,
0x432a, 0x188, 0x447d, 0x252, 0x5ece, 0x383, 0x8000, 0x547, 0x481a, 0x7e2,
0x3579, 0xbc0, 0x24ef, 0x1178, 0x1978, 0x19da, 0x2865, 0x24ef, 0x3987, 0x320e,
0x2c99, 0x432a, 0x3b5f, 0x447d, 0x5695, 0x5ece, 0x8000, 0x8000, 0x5695, 0x481a, 0x481a
);
ZPEncoder.prototype.m = ZPDecoder.prototype.m = Uint16Array.of(
0x0, 0x0, 0x0, 0x10a5, 0x10a5, 0x1f28, 0x1f28, 0x2bd3, 0x2bd3, 0x36e3,
0x36e3, 0x408c, 0x408c, 0x48fd, 0x48fd, 0x505d, 0x505d, 0x56d0, 0x56d0, 0x5c71,
0x5c71, 0x615b, 0x615b, 0x65a5, 0x65a5, 0x6962, 0x6962, 0x6ca2, 0x6ca2, 0x6f74,
0x6f74, 0x71e6, 0x71e6, 0x7404, 0x7404, 0x75d6, 0x75d6, 0x7768, 0x7768, 0x78c2,
0x78c2, 0x79ea, 0x79ea, 0x7ae7, 0x7ae7, 0x7bbe, 0x7bbe, 0x7c75, 0x7c75, 0x7d0f,
0x7d0f, 0x7d91, 0x7d91, 0x7dfe, 0x7dfe, 0x7e5a, 0x7e5a, 0x7ea6, 0x7ea6, 0x7ee6,
0x7ee6, 0x7f1a, 0x7f1a, 0x7f45, 0x7f45, 0x7f6b, 0x7f6b, 0x7f8d, 0x7f8d, 0x7faa,
0x7faa, 0x7fc3, 0x7fc3, 0x7fd7, 0x7fd7, 0x7fe7, 0x7fe7, 0x7ff2, 0x7ff2, 0x7ffa,
0x7ffa, 0x7fff, 0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
);
ZPEncoder.prototype.up = ZPDecoder.prototype.up = Uint8Array.of(
84, 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, 81, 82, 9, 86, 5, 88, 89, 90, 91,
92, 93, 94, 95, 96, 97, 82, 99, 76, 101,
70, 103, 66, 105, 106, 107, 66, 109, 60, 111,
56, 69, 114, 65, 116, 61, 118, 57, 120, 53,
122, 49, 124, 43, 72, 39, 60, 33, 56, 29,
52, 23, 48, 23, 42, 137, 38, 21, 140, 15,
142, 9, 144, 141, 146, 147, 148, 149, 150, 151,
152, 153, 154, 155, 70, 157, 66, 81, 62, 75,
58, 69, 54, 65, 50, 167, 44, 65, 40, 59,
34, 55, 30, 175, 24, 177, 178, 179, 180, 181,
182, 183, 184, 69, 186, 59, 188, 55, 190, 51,
192, 47, 194, 41, 196, 37, 198, 199, 72, 201,
62, 203, 58, 205, 54, 207, 50, 209, 46, 211,
40, 213, 36, 215, 30, 217, 26, 219, 20, 71,
14, 61, 14, 57, 8, 53, 228, 49, 230, 45,
232, 39, 234, 35, 138, 29, 24, 25, 240, 19,
22, 13, 16, 13, 10, 7, 244, 249, 10, 89, 230
);
ZPEncoder.prototype.dn = ZPDecoder.prototype.dn = Uint8Array.of(
145, 4, 3, 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, 85, 226, 6, 176, 143, 138, 141,
112, 135, 104, 133, 100, 129, 98, 127, 72, 125,
102, 123, 60, 121, 110, 119, 108, 117, 54, 115,
48, 113, 134, 59, 132, 55, 130, 51, 128, 47,
126, 41, 62, 37, 66, 31, 54, 25, 50, 131,
46, 17, 40, 15, 136, 7, 32, 139, 172, 9,
170, 85, 168, 248, 166, 247, 164, 197, 162, 95,
160, 173, 158, 165, 156, 161, 60, 159, 56, 71,
52, 163, 48, 59, 42, 171, 38, 169, 32, 53,
26, 47, 174, 193, 18, 191, 222, 189, 218, 187,
216, 185, 214, 61, 212, 53, 210, 49, 208, 45,
206, 39, 204, 195, 202, 31, 200, 243, 64, 239,
56, 237, 52, 235, 48, 233, 44, 231, 38, 229,
34, 227, 28, 225, 22, 223, 16, 221, 220, 63,
8, 55, 224, 51, 2, 47, 87, 43, 246, 37,
244, 33, 238, 27, 236, 21, 16, 15, 8, 241,
242, 7, 10, 245, 2, 1, 83, 250, 2, 143, 246
);
class Bitmap {
constructor(width, height) {
var length = Math.ceil(width * height / 8);
this.height = height;
this.width = width;
this.innerArray = new Uint8Array(length);
}
getBits(i, j, bitNumber) {
if (!this.hasRow(i) || j >= this.width) {
return 0;
}
if (j < 0) {
bitNumber += j;
j = 0;
}
var tmp = i * this.width + j;
var index = tmp >> 3;
var bitIndex = tmp & 7;
var mask = 32768 >>> bitIndex;
var twoBytes = ((this.innerArray[index] << 8) | (this.innerArray[index + 1] || 0));
var existingBits = this.width - j;
var border = bitNumber < existingBits ? bitNumber : existingBits;
for (var k = 1; k < border; k++) {
mask |= 32768 >>> (bitIndex + k);
}
return (twoBytes & mask) >>> (16 - bitIndex - bitNumber);
}
get(i, j) {
if (!this.hasRow(i) || j < 0 || j >= this.width) {
return 0;
}
var tmp = i * this.width + j;
var index = tmp >> 3;
var bitIndex = tmp & 7;
var mask = 128 >> bitIndex;
return (this.innerArray[index] & mask) ? 1 : 0;
}
set(i, j) {
var tmp = i * this.width + j;
var index = tmp >> 3;
var bitIndex = tmp & 7;
var mask = 128 >> bitIndex;
this.innerArray[index] |= mask;
return;
}
hasRow(r) {
return r >= 0 && r < this.height;
}
removeEmptyEdges() {
var bottomShift = 0;
var topShift = 0;
var leftShift = 0;
var rightShift = 0;
main_cycle: for (var i = 0; i < this.height; i++) {
for (var j = 0; j < this.width; j++) {
if (this.get(i, j)) {
break main_cycle;
}
}
bottomShift++;
}
main_cycle: for (var i = this.height - 1; i >= 0; i--) {
for (var j = 0; j < this.width; j++) {
if (this.get(i, j)) {
break main_cycle;
}
}
topShift++;
}
main_cycle: for (var j = 0; j < this.width; j++) {
for (var i = 0; i < this.height; i++) {
if (this.get(i, j)) {
break main_cycle;
}
}
leftShift++;
}
main_cycle: for (var j = this.width - 1; j >= 0; j--) {
for (var i = 0; i < this.height; i++) {
if (this.get(i, j)) {
break main_cycle;
}
}
rightShift++;
}
if (topShift || bottomShift || leftShift || rightShift) {
var newWidth = this.width - leftShift - rightShift;
var newHeight = this.height - topShift - bottomShift;
var newBitMap = new Bitmap(newWidth, newHeight);
for (var i = bottomShift, p = 0; p < newHeight; p++ , i++) {
for (var j = leftShift, q = 0; q < newWidth; q++ , j++) {
if (this.get(i, j)) {
newBitMap.set(p, q);
}
}
}
return newBitMap;
}
return this;
}
}
class NumContext {
constructor() {
this.ctx = [0];
this._left = null;
this._right = null;
}
get left() {
if (!this._left) {
this._left = new NumContext();
}
return this._left;
}
get right() {
if (!this._right) {
this._right = new NumContext();
}
return this._right;
}
}
class Baseline {
constructor() {
this.arr = new Array(3);
this.fill(0);
this.index = -1;
}
add(val) {
if (++this.index === 3) {
this.index = 0;
}
this.arr[this.index] = val;
}
getVal() {
if (this.arr[0] >= this.arr[1] && this.arr[0] <= this.arr[2]
|| this.arr[0] <= this.arr[1] && this.arr[0] >= this.arr[2]) {
return this.arr[0];
}
else if (this.arr[1] >= this.arr[0] && this.arr[1] <= this.arr[2]
|| this.arr[1] <= this.arr[0] && this.arr[1] >= this.arr[2]) {
return this.arr[1];
} else {
return this.arr[2];
}
}
fill(val) {
this.arr[0] = this.arr[1] = this.arr[2] = val;
}
}
class DjVuError {
constructor(code, message, additionalData = null) {
this.code = code;
this.message = message;
if (additionalData) this.additionalData = additionalData;
}
}
class IncorrectFileFormatDjVuError extends DjVuError {
constructor() {
super(DjVuErrorCodes.INCORRECT_FILE_FORMAT, "The provided file is not a .djvu file!");
}
}
class NoSuchPageDjVuError extends DjVuError {
constructor(pageNumber) {
super(DjVuErrorCodes.NO_SUCH_PAGE, "There is no page with the number " + pageNumber + " !");
this.pageNumber = pageNumber;
}
}
class CorruptedFileDjVuError extends DjVuError {
constructor(message = "", data = null) {
super(DjVuErrorCodes.FILE_IS_CORRUPTED, "The file is corrupted! " + message, data);
}
}
class UnableToTransferDataDjVuError extends DjVuError {
constructor(tasks) {
super(DjVuErrorCodes.DATA_CANNOT_BE_TRANSFERRED,
"The data cannot be transferred from the worker to the main page! " +
"Perhaps, you requested a complex object like DjVuPage, but only simple objects can be transferred between workers."
);
this.tasks = tasks;
}
}
class IncorrectTaskDjVuError extends DjVuError {
constructor(task) {
super(DjVuErrorCodes.INCORRECT_TASK, "The task contains an incorrect sequence of functions!");
this.task = task;
}
}
class NoBaseUrlDjVuError extends DjVuError {
constructor() {
super(DjVuErrorCodes.NO_BASE_URL,
"The base URL is required for the indirect djvu to load components," +
" but no base URL was provided to the document constructor!"
);
}
}
function getErrorMessageByData(data) {
var message = '';
if (data.pageNumber) {
if (data.dependencyId) {
message = `A dependency ${data.dependencyId} for the page number ${data.pageNumber} can't be loaded!\n`;
} else {
message = `The page number ${data.pageNumber} can't be loaded!`;
}
} else if (data.dependencyId) {
message = `A dependency ${data.dependencyId} can't be loaded!\n`;
}
return message;
}
class UnsuccessfulRequestDjVuError extends DjVuError {
constructor(xhr, data = { pageNumber: null, dependencyId: null }) {
var message = getErrorMessageByData(data);
super(DjVuErrorCodes.UNSUCCESSFUL_REQUEST,
message + '\n' +
`The request to ${xhr.responseURL} wasn't successful.\n` +
`The response status is ${xhr.status}.\n` +
`The response status text is: "${xhr.statusText}".`
);
this.status = xhr.status;
this.statusText = xhr.statusText;
this.url = xhr.responseURL;
if (data.pageNumber) {
this.pageNumber = data.pageNumber;
}
if (data.dependencyId) {
this.dependencyId = data.dependencyId;
}
}
}
class NetworkDjVuError extends DjVuError {
constructor(data = { pageNumber: null, dependencyId: null, url: null }) {
super(DjVuErrorCodes.NETWORK_ERROR,
getErrorMessageByData(data) + '\n' +
"A network error occurred! Check your network connection!"
);
if (data.pageNumber) {
this.pageNumber = data.pageNumber;
}
if (data.dependencyId) {
this.dependencyId = data.dependencyId;
}
if (data.url) {
this.url = data.url;
}
}
}
const DjVuErrorCodes = Object.freeze({
FILE_IS_CORRUPTED: 'FILE_IS_CORRUPTED',
INCORRECT_FILE_FORMAT: 'INCORRECT_FILE_FORMAT',
NO_SUCH_PAGE: 'NO_SUCH_PAGE',
UNEXPECTED_ERROR: 'UNEXPECTED_ERROR',
DATA_CANNOT_BE_TRANSFERRED: 'DATA_CANNOT_BE_TRANSFERRED',
INCORRECT_TASK: 'INCORRECT_TASK',
NO_BASE_URL: 'NO_BASE_URL',
NETWORK_ERROR: 'NETWORK_ERROR',
UNSUCCESSFUL_REQUEST: 'UNSUCCESSFUL_REQUEST',
});
class IFFChunk {
constructor(bs) {
this.id = bs.readStr4();
this.length = bs.getInt32();
this.bs = bs;
}
toString() {
return this.id + " " + this.length + '\n';
}
}
class CompositeChunk extends IFFChunk {
constructor(bs) {
super(bs);
this.id += ':' + bs.readStr4();
}
toString(innerString = '') {
return super.toString() + ' ' + innerString.replace(/\n/g, '\n ') + '\n';
}
}
class ColorChunk extends IFFChunk {
constructor(bs) {
super(bs);
this.header = new ColorChunkDataHeader(bs);
}
toString() {
return this.id + " " + this.length + this.header.toString();
}
}
class INFOChunk extends IFFChunk {
constructor(bs) {
super(bs);
if (this.length < 5) {
throw new CorruptedFileDjVuError("The INFO chunk is shorter than 5 bytes!")
}
this.width = bs.getInt16();
this.height = bs.getInt16();
this.minver = bs.getInt8();
this.majver = this.length > 5 ? bs.getInt8() : 0;
if (this.length > 7) {
this.dpi = bs.getUint8();
this.dpi |= bs.getUint8() << 8;
} else {
this.dpi = 300;
}
this.gamma = this.length > 8 ? bs.getInt8() : 22;
this.flags = this.length > 9 ? bs.getInt8() : 0;
if (this.dpi < 25 || this.dpi > 6000) {
this.dpi = 300;
}
if (this.gamma < 3) {
this.gamma = 3;
}
if (this.gamma > 50) {
this.gamma = 50;
}
}
toString() {
var str = super.toString();
str += "{" + 'width:' + this.width + ', '
+ 'height:' + this.height + ', '
+ 'minver:' + this.minver + ', '
+ 'majver:' + this.majver + ', '
+ 'dpi:' + this.dpi + ', '
+ 'gamma:' + this.gamma + ', '
+ 'flags:' + this.flags + '}\n';
return str;
}
}
class ColorChunkDataHeader {
constructor(bs) {
this.serial = bs.getUint8();
this.slices = bs.getUint8();
if (!this.serial) {
this.majver = bs.getUint8();
this.grayscale = this.majver >> 7;
this.minver = bs.getUint8();
this.width = bs.getUint16();
this.height = bs.getUint16();
var byte = bs.getUint8();
this.delayInit = byte & 127;
if (!byte & 128) {
console.warn('Old image reconstruction should be applied!');
}
}
}
toString() {
return '\n' + JSON.stringify(this) + "\n";
}
}
class INCLChunk extends IFFChunk {
constructor(bs) {
super(bs);
this.ref = this.bs.readStrUTF();
}
toString() {
var str = super.toString();
str += "{Reference: " + this.ref + '}\n';
return str;
}
}
class CIDaChunk extends INCLChunk { }
class ErrorChunk {
constructor(id, e) {
this.id = id;
this.e = e;
}
toString() {
return `Error creating ${this.id}: ${this.e.toString()}\n`;
}
}
class JB2Codec extends IFFChunk {
constructor(bs) {
super(bs);
this.zp = new ZPDecoder(this.bs);
this.directBitmapCtx = new Uint8Array(1024);
this.refinementBitmapCtx = new Uint8Array(2048);
this.offsetTypeCtx = [0];
this.resetNumContexts();
}
resetNumContexts() {
this.recordTypeCtx = new NumContext();
this.imageSizeCtx = new NumContext();
this.symbolWidthCtx = new NumContext();
this.symbolHeightCtx = new NumContext();
this.inheritDictSizeCtx = new NumContext();
this.hoffCtx = new NumContext();
this.voffCtx = new NumContext();
this.shoffCtx = new NumContext();
this.svoffCtx = new NumContext();
this.symbolIndexCtx = new NumContext();
this.symbolHeightDiffCtx = new NumContext();
this.symbolWidthDiffCtx = new NumContext();
this.commentLengthCtx = new NumContext();
this.commentOctetCtx = new NumContext();
this.horizontalAbsLocationCtx = new NumContext();
this.verticalAbsLocationCtx = new NumContext();
}
decodeNum(low, high, numctx) {
var negative = false;
var cutoff;
cutoff = 0;
for (var phase = 1, range = 0xffffffff; range != 1;) {
var decision = (low >= cutoff) || ((high >= cutoff) && this.zp.decode(numctx.ctx, 0));
numctx = decision ? numctx.right : numctx.left;
switch (phase) {
case 1:
negative = !decision;
if (negative) {
var temp = - low - 1;
low = - high - 1;
high = temp;
}
phase = 2; cutoff = 1;
break;
case 2:
if (!decision) {
phase = 3;
range = (cutoff + 1) / 2;
if (range == 1)
cutoff = 0;
else
cutoff -= range / 2;
}
else {
cutoff += cutoff + 1;
}
break;
case 3:
range /= 2;
if (range != 1) {
if (!decision)
cutoff -= range / 2;
else
cutoff += range / 2;
}
else if (!decision) {
cutoff--;
}
break;
}
}
return (negative) ? (- cutoff - 1) : cutoff;
}
decodeBitmap(width, height) {
var bitmap = new Bitmap(width, height);
for (var i = height - 1; i >= 0; i--) {
for (var j = 0; j < width; j++) {
var ind = this.getCtxIndex(bitmap, i, j);
if (this.zp.decode(this.directBitmapCtx, ind)) { bitmap.set(i, j); } }
}
return bitmap;
}
getCtxIndex(bm, i, j) {
var index = 0;
var r = i + 2;
if (bm.hasRow(r)) {
index = (bm.getBits(r, j - 1, 3)) << 7;
}
r--;
if (bm.hasRow(r)) {
index |= bm.getBits(r, j - 2, 5) << 2;
}
index |= bm.getBits(i, j - 2, 2);
return index;
}
decodeBitmapRef(width, height, mbm) {
var cbm = new Bitmap(width, height);
var alignInfo = this.alignBitmaps(cbm, mbm);
for (var i = height - 1; i >= 0; i--) {
for (var j = 0; j < width; j++) {
this.zp.decode(this.refinementBitmapCtx,
this.getCtxIndexRef(cbm, mbm, alignInfo, i, j)) ? cbm.set(i, j) : 0;
}
}
return cbm;
}
getCtxIndexRef(cbm, mbm, alignInfo, i, j) {
var index = 0;
var r = i + 1;
if (cbm.hasRow(r)) {
index = cbm.getBits(r, j - 1, 3) << 8;
}
index |= cbm.get(i, j - 1) << 7;
r = i + alignInfo.rowshift + 1;
var c = j + alignInfo.colshift;
index |= mbm.hasRow(r) ? mbm.get(r, c) << 6 : 0;
r--;
if (mbm.hasRow(r)) {
index |= mbm.getBits(r, c - 1, 3) << 3;
}
r--;
if (mbm.hasRow(r)) {
index |= mbm.getBits(r, c - 1, 3);
}
return index;
}
alignBitmaps(cbm, mbm) {
var cwidth = cbm.width - 1;
var cheight = cbm.height - 1;
var crow, ccol, mrow, mcol;
crow = cheight >> 1;
ccol = cwidth >> 1;
mrow = (mbm.height - 1) >> 1;
mcol = (mbm.width - 1) >> 1;
return {
'rowshift': mrow - crow,
'colshift': mcol - ccol
};
}
decodeComment() {
var length = this.decodeNum(0, 262142, this.commentLengthCtx);
var comment = new Uint8Array(length);
for (var i = 0; i < length; comment[i++] = this.decodeNum(0, 255, this.commentOctetCtx)) { }
return comment;
}
drawBitmap(bm) {
var image = document.createElement('canvas')
.getContext('2d')
.createImageData(bm.width, bm.height);
for (var i = 0; i < bm.height; i++) {
for (var j = 0; j < bm.width; j++) {
var v = bm.get(i, j) ? 0 : 255;
var index = ((bm.height - i - 1) * bm.width + j) * 4;
image.data[index] = v;
image.data[index + 1] = v;
image.data[index + 2] = v;
image.data[index + 3] = 255;
}
}
Globals.drawImage(image);
}
}
class JB2Dict extends JB2Codec {
constructor(bs) {
super(bs);
this.dict = [];
this.isDecoded = false;
}
decode(djbz) {
if (this.isDecoded) {
return;
}
var type = this.decodeNum(0, 11, this.recordTypeCtx);
if (type == 9) {
var size = this.decodeNum(0, 262142, this.inheritDictSizeCtx);
djbz.decode();
this.dict = djbz.dict.slice(0, size);
type = this.decodeNum(0, 11, this.recordTypeCtx);
}
this.decodeNum(0, 262142, this.imageSizeCtx);
this.decodeNum(0, 262142, this.imageSizeCtx);
var flag = this.zp.decode([0], 0);
if (flag) {
throw new Error("Bad flag!!!");
}
type = this.decodeNum(0, 11, this.recordTypeCtx);
var width, widthdiff, heightdiff, symbolIndex;
var height;
var bm;
while (type !== 11) {
switch (type) {
case 2:
width = this.decodeNum(0, 262142, this.symbolWidthCtx);
height = this.decodeNum(0, 262142, this.symbolHeightCtx);
bm = this.decodeBitmap(width, height);
this.dict.push(bm);
break;
case 5:
symbolIndex = this.decodeNum(0, this.dict.length - 1, this.symbolIndexCtx);
widthdiff = this.decodeNum(-262143, 262142, this.symbolWidthDiffCtx);
heightdiff = this.decodeNum(-262143, 262142, this.symbolHeightDiffCtx);
var mbm = this.dict[symbolIndex];
var cbm = this.decodeBitmapRef(mbm.width + widthdiff, heightdiff + mbm.height, mbm);
this.dict.push(cbm.removeEmptyEdges());
break;
case 9:
console.log("RESET DICT");
this.resetNumContexts();
break;
case 10:
this.decodeComment();
break;
default:
throw new Error("Unsupported type in JB2Dict: " + type);
}
type = this.decodeNum(0, 11, this.recordTypeCtx);
if (type > 11) {
console.error("TYPE ERROR " + type);
break;
}
}
this.isDecoded = true;
}
}
class DjVuAnno extends IFFChunk { }
class DjViChunk extends CompositeChunk {
constructor(bs) {
super(bs);
this.innerChunk = null;
this.init();
}
init() {
while (!this.bs.isEmpty()) {
var id = this.bs.readStr4();
var length = this.bs.getInt32();
this.bs.jump(-8);
var chunkBs = this.bs.fork(length + 8);
this.bs.jump(8 + length + (length & 1 ? 1 : 0));
switch (id) {
case 'Djbz':
this.innerChunk = new JB2Dict(chunkBs);
break;
case 'ANTa':
case 'ANTz':
this.innerChunk = new DjVuAnno(chunkBs);
break;
default:
this.innerChunk = new IFFChunk(chunkBs);
console.error("Unsupported chunk inside the DJVI chunk: ", id);
break;
}
}
}
toString() {
return super.toString(this.innerChunk.toString());
}
}
class JB2Image extends JB2Codec {
constructor(bs) {
super(bs);
this.dict = [];
this.initialDictLength = 0;
this.blitList = [];
this.init();
}
addBlit(bitmap, x, y) {
this.blitList.push({ bitmap, x, y });
}
init() {
var type = this.decodeNum(0, 11, this.recordTypeCtx);
if (type == 9) {
this.initialDictLength = this.decodeNum(0, 262142, this.inheritDictSizeCtx);
type = this.decodeNum(0, 11, this.recordTypeCtx);
}
this.width = this.decodeNum(0, 262142, this.imageSizeCtx) || 200;
this.height = this.decodeNum(0, 262142, this.imageSizeCtx) || 200;
this.bitmap = false;
this.lastLeft = 0;
this.lastBottom = this.height - 1;
this.firstLeft = -1;
this.firstBottom = this.height - 1;
var flag = this.zp.decode([0], 0);
if (flag) {
throw new Error("Bad flag!!!");
}
this.baseline = new Baseline();
}
toString() {
var str = super.toString();
str += "{width: " + this.width + ", height: " + this.height + '}\n';
return str;
}
decode(djbz) {
if (this.initialDictLength) {
djbz.decode();
this.dict = djbz.dict.slice(0, this.initialDictLength);
}
var type = this.decodeNum(0, 11, this.recordTypeCtx);
var width;
var height, index;
var bm;
while (type !== 11 ) {
switch (type) {
case 1:
width = this.decodeNum(0, 262142, this.symbolWidthCtx);
height = this.decodeNum(0, 262142, this.symbolHeightCtx);
bm = this.decodeBitmap(width, height);
var coords = this.decodeSymbolCoords(bm.width, bm.height);
this.addBlit(bm, coords.x, coords.y);
this.dict.push(bm.removeEmptyEdges());
break;
case 2:
width = this.decodeNum(0, 262142, this.symbolWidthCtx);
height = this.decodeNum(0, 262142, this.symbolHeightCtx);
bm = this.decodeBitmap(width, height);
this.dict.push(bm.removeEmptyEdges());
break;
case 3:
width = this.decodeNum(0, 262142, this.symbolWidthCtx);
height = this.decodeNum(0, 262142, this.symbolHeightCtx);
bm = this.decodeBitmap(width, height);
var coords = this.decodeSymbolCoords(bm.width, bm.height);
this.addBlit(bm, coords.x, coords.y);
break;
case 4:
index = this.decodeNum(0, this.dict.length - 1, this.symbolIndexCtx);
var widthdiff = this.decodeNum(-262143, 262142, this.symbolWidthDiffCtx);
var heightdiff = this.decodeNum(-262143, 262142, this.symbolHeightDiffCtx);
var mbm = this.dict[index];
var cbm = this.decodeBitmapRef(mbm.width + widthdiff, heightdiff + mbm.height, mbm);
var coords = this.decodeSymbolCoords(cbm.width, cbm.height);
this.addBlit(cbm, coords.x, coords.y);
this.dict.push(cbm.removeEmptyEdges());
break;
case 5:
index = this.decodeNum(0, this.dict.length - 1, this.symbolIndexCtx);
widthdiff = this.decodeNum(-262143, 262142, this.symbolWidthDiffCtx);
heightdiff = this.decodeNum(-262143, 262142, this.symbolHeightDiffCtx);
var mbm = this.dict[index];
var cbm = this.decodeBitmapRef(mbm.width + widthdiff, heightdiff + mbm.height, mbm);
this.dict.push(cbm.removeEmptyEdges());
break;
case 6:
index = this.decodeNum(0, this.dict.length - 1, this.symbolIndexCtx);
var widthdiff = this.decodeNum(-262143, 262142, this.symbolWidthDiffCtx);
var heightdiff = this.decodeNum(-262143, 262142, this.symbolHeightDiffCtx);
var mbm = this.dict[index];
var cbm = this.decodeBitmapRef(mbm.width + widthdiff, heightdiff + mbm.height, mbm);
var coords = this.decodeSymbolCoords(cbm.width, cbm.height);
this.addBlit(cbm, coords.x, coords.y);
break;
case 7:
index = this.decodeNum(0, this.dict.length - 1, this.symbolIndexCtx);
bm = this.dict[index];
var coords = this.decodeSymbolCoords(bm.width, bm.height);
this.addBlit(bm, coords.x, coords.y);
break;
case 8:
width = this.decodeNum(0, 262142, this.symbolWidthCtx);
height = this.decodeNum(0, 262142, this.symbolHeightCtx);
bm = this.decodeBitmap(width, height);
var coords = this.decodeAbsoluteLocationCoords(bm.width, bm.height);
this.addBlit(bm, coords.x, coords.y);
break;
case 9:
console.log("RESET NUM CONTEXTS");
this.resetNumContexts();
break;
case 10:
this.decodeComment();
break;
default:
throw new Error("Unsupported type in JB2Image: " + type);
}
type = this.decodeNum(0, 11, this.recordTypeCtx);
if (type > 11) {
console.error("TYPE ERROR " + type);
break;
}
}
}
decodeAbsoluteLocationCoords(width, height) {
var left = this.decodeNum(1, this.width, this.horizontalAbsLocationCtx);
var top = this.decodeNum(1, this.height, this.verticalAbsLocationCtx);
return {
x: left,
y: top - height
}
}
decodeSymbolCoords(width, height) {
var flag = this.zp.decode(this.offsetTypeCtx, 0);
var horizontalOffsetCtx = flag ? this.hoffCtx : this.shoffCtx;
var verticalOffsetCtx = flag ? this.voffCtx : this.svoffCtx;
var horizontalOffset = this.decodeNum(-262143, 262142, horizontalOffsetCtx);
var verticalOffset = this.decodeNum(-262143, 262142, verticalOffsetCtx);
var x, y;
if (flag) {
x = this.firstLeft + horizontalOffset;
y = this.firstBottom + verticalOffset - height + 1;
this.firstLeft = x;
this.firstBottom = y;
this.baseline.fill(y);
}
else {
x = this.lastRight + horizontalOffset;
y = this.baseline.getVal() + verticalOffset;
}
this.baseline.add(y);
this.lastRight = x + width - 1;
return {
'x': x,
'y': y
};
}
copyToBitmap(bm, x, y) {
if (!this.bitmap) {
this.bitmap = new Bitmap(this.width, this.height);
}
for (var i = y, k = 0; k < bm.height; k++ , i++) {
for (var j = x, t = 0; t < bm.width; t++ , j++) {
if (bm.get(k, t)) {
this.bitmap.set(i, j);
}
}
}
}
getBitmap() {
if (!this.bitmap) {
this.blitList.forEach(blit => this.copyToBitmap(blit.bitmap, blit.x, blit.y));
}
return this.bitmap;
}
getMaskImage() {
var imageData = new ImageData(this.width, this.height);
var pixelArray = imageData.data;
var time = performance.now();
pixelArray.fill(255);
for (var blitIndex = 0; blitIndex < this.blitList.length; blitIndex++) {
var blit = this.blitList[blitIndex];
var bm = blit.bitmap;
for (var i = blit.y, k = 0; k < bm.height; k++ , i++) {
for (var j = blit.x, t = 0; t < bm.width; t++ , j++) {
if (bm.get(k, t)) {
var pixelIndex = ((this.height - i - 1) * this.width + j) * 4;
pixelArray[pixelIndex] = 0;
}
}
}
}
DjVu.IS_DEBUG && console.log("JB2Image mask image creating time = ", performance.now() - time);
return imageData;
}
getImage(palette = null, isMarkMaskPixels = false) {
if (palette && palette.getDataSize() !== this.blitList.length) {
palette = null;
}
var pixelArray = new Uint8ClampedArray(this.width * this.height * 4);
var time = performance.now();
pixelArray.fill(255);
var blackPixel = { r: 0, g: 0, b: 0 };
var alpha = isMarkMaskPixels ? 0 : 255;
for (var blitIndex = 0; blitIndex < this.blitList.length; blitIndex++) {
var blit = this.blitList[blitIndex];
var pixel = palette ? palette.getPixelByBlitIndex(blitIndex) : blackPixel;
var bm = blit.bitmap;
for (var i = blit.y, k = 0; k < bm.height; k++ , i++) {
for (var j = blit.x, t = 0; t < bm.width; t++ , j++) {
if (bm.get(k, t)) {
var pixelIndex = ((this.height - i - 1) * this.width + j) << 2;
pixelArray[pixelIndex] = pixel.r;
pixelArray[pixelIndex | 1] = pixel.g;
pixelArray[pixelIndex | 2] = pixel.b;
pixelArray[pixelIndex | 3] = alpha;
}
}
}
}
DjVu.IS_DEBUG && console.log("JB2Image creating time = ", performance.now() - time);
return new ImageData(pixelArray, this.width, this.height);
}
getImageFromBitmap() {
this.getBitmap();
var time = performance.now();
var image = new ImageData(this.width, this.height);
for (var i = 0; i < this.height; i++) {
for (var j = 0; j < this.width; j++) {
var v = this.bitmap.get(i, j) ? 0 : 255;
var index = ((this.height - i - 1) * this.width + j) * 4;
image.data[index] = v;
image.data[index + 1] = v;
image.data[index + 2] = v;
image.data[index + 3] = 255;
}
}
DjVu.IS_DEBUG && console.log("JB2Image creating time = ", performance.now() - time);
return image;
}
}
class ByteStream {
constructor(buffer, offsetx, length) {
this._buffer = buffer;
this.offsetx = offsetx || 0;
this.offset = 0;
this._length = length || buffer.byteLength;
if (this._length + offsetx > buffer.byteLength) {
this._length = buffer.byteLength - offsetx;
console.error("Incorrect length in ByteStream!");
}
this.viewer = new DataView(this._buffer, this.offsetx, this._length);
}
get length() { return this._length; }
get buffer() { return this._buffer; }
getUint8Array(length = this.remainingLength()) {
var off = this.offset;
this.offset += length;
return new Uint8Array(this._buffer, this.offsetx + off, length);
}
toUint8Array() {
return new Uint8Array(this._buffer, this.offsetx, this._length);
}
remainingLength() {
return this._length - this.offset;
}
reset() {
this.offset = 0;
}
byte() {
if (this.offset >= this._length) {
this.offset++;
return 0xff;
}
return this.viewer.getUint8(this.offset++);
}
getInt8() {
return this.viewer.getInt8(this.offset++);
}
getInt16() {
var tmp = this.viewer.getInt16(this.offset);
this.offset += 2;
return tmp;
}
getUint16() {
var tmp = this.viewer.getUint16(this.offset);
this.offset += 2;
return tmp;
}
getInt32() {
var tmp = this.viewer.getInt32(this.offset);
this.offset += 4;
return tmp;
}
getUint8() {
return this.viewer.getUint8(this.offset++);
}
getInt24() {
var uint = this.getUint24();
return (uint & 0x800000) ? (0xffffff - val + 1) * -1 : uint
}
getUint24() {
return (this.byte() << 16) | (this.byte() << 8) | this.byte();
}
jump(length) {
this.offset += length;
return this;
}
setOffset(offset) {
this.offset = offset;
}
readStr4() {
return String.fromCharCode(...this.getUint8Array(4));
}
readStrNT() {
var array = [];
var byte = this.getUint8();
while (byte) {
array.push(byte);
byte = this.getUint8();
}
return createStringFromUtf8Array(new Uint8Array(array));
}
readStrUTF(byteLength) {
return createStringFromUtf8Array(this.getUint8Array(byteLength));
}
fork(length = this.remainingLength()) {
return new ByteStream(this._buffer, this.offsetx + this.offset, length);
}
clone() {
return new ByteStream(this._buffer, this.offsetx, this._length);
}
isEmpty() {
return this.offset >= this._length;
}
}
class BZZDecoder {
constructor(zp) {
this.zp = zp;
this.maxblock = 4096;
this.FREQMAX = 4;
this.CTXIDS = 3;
this.ctx = new Uint8Array(300);
this.size = 0;
this.blocksize = 0;
this.data = null;
}
decode_raw(bits) {
var n = 1;
var m = (1 << bits);
while (n < m) {
var b = this.zp.decode();
n = (n << 1) | b;
}
return n - m;
}
decode_binary(ctxoff, bits) {
var n = 1;
var m = (1 << bits);
ctxoff--;
while (n < m) {
var b = this.zp.decode(this.ctx, ctxoff + n);
n = (n << 1) | b;
}
return n - m;
}
_decode() {
this.size = this.decode_raw(24);
if (!this.size) {
return 0;
}
if (this.size > this.maxblock * 1024) {
throw new Error("Too big block. Error");
}
if (this.blocksize < this.size) {
this.blocksize = this.size;
this.data = new Uint8Array(this.blocksize);
} else if (this.data == null) {
this.data = new Uint8Array(this.blocksize);
}
var fshift = 0;
if (this.zp.decode()) {
fshift++;
if (this.zp.decode()) {
fshift++;
}
}
var mtf = new Uint8Array(256);
for (var i = 0; i < 256; i++) {
mtf[i] = i;
}
var freq = new Array(this.FREQMAX);
for (var i = 0; i < this.FREQMAX; freq[i++] = 0);
var fadd = 4;
var mtfno = 3;
var markerpos = -1;
for (var i = 0; i < this.size; i++) {
var ctxid = this.CTXIDS - 1;
if (ctxid > mtfno) {
ctxid = mtfno;
}
var ctxoff = 0;
switch (0)
{
default:
if (this.zp.decode(this.ctx, ctxoff + ctxid) != 0) {
mtfno = 0;
this.data[i] = mtf[mtfno];
break;
}
ctxoff += this.CTXIDS;
if (this.zp.decode(this.ctx, ctxoff + ctxid) != 0) {
mtfno = 1;
this.data[i] = mtf[mtfno];
break;
}
ctxoff += this.CTXIDS;
if (this.zp.decode(this.ctx, ctxoff + 0) != 0) {
mtfno = 2 + this.decode_binary(ctxoff + 1, 1);
this.data[i] = mtf[mtfno];
break;
}
ctxoff += (1 + 1);
if (this.zp.decode(this.ctx, ctxoff + 0) != 0) {
mtfno = 4 + this.decode_binary(ctxoff + 1, 2);
this.data[i] = mtf[mtfno];
break;
}
ctxoff += (1 + 3);
if (this.zp.decode(this.ctx, ctxoff + 0) != 0) {
mtfno = 8 + this.decode_binary(ctxoff + 1, 3);
this.data[i] = mtf[mtfno];
break;
}
ctxoff += (1 + 7);
if (this.zp.decode(this.ctx, ctxoff + 0) != 0) {
mtfno = 16 + this.decode_binary(ctxoff + 1, 4);
this.data[i] = mtf[mtfno];
break;
}
ctxoff += (1 + 15);
if (this.zp.decode(this.ctx, ctxoff + 0) != 0) {
mtfno = 32 + this.decode_binary(ctxoff + 1, 5);
this.data[i] = mtf[mtfno];
break;
}
ctxoff += (1 + 31);
if (this.zp.decode(this.ctx, ctxoff + 0) != 0) {
mtfno = 64 + this.decode_binary(ctxoff + 1, 6);
this.data[i] = mtf[mtfno];
break;
}
ctxoff += (1 + 63);
if (this.zp.decode(this.ctx, ctxoff + 0) != 0) {
mtfno = 128 + this.decode_binary(ctxoff + 1, 7);
this.data[i] = mtf[mtfno];
break;
}
mtfno = 256;
this.data[i] = 0;
markerpos = i;
continue;
}
var k;
fadd = fadd + (fadd >> fshift);
if (fadd > 0x10000000) {
fadd >>= 24;
freq[0] >>= 24;
freq[1] >>= 24;
freq[2] >>= 24;
freq[3] >>= 24;
for (k = 4; k < this.FREQMAX; k++) {
freq[k] >>= 24;
}
}
var fc = fadd;
if (mtfno < this.FREQMAX) {
fc += freq[mtfno];
}
for (k = mtfno; k >= this.FREQMAX; k--) {
mtf[k] = mtf[k - 1];
}
for (; (k > 0) && ((0xffffffff & fc) >= (0xffffffff & freq[k - 1])); k--) {
mtf[k] = mtf[k - 1];
freq[k] = freq[k - 1];
}
mtf[k] = this.data[i];
freq[k] = fc;
}
if ((markerpos < 1) || (markerpos >= this.size)) {
throw new Error("BZZ byte stream is corrupted");
}
var pos = new Uint32Array(this.size);
for (var j = 0; j < this.size; pos[j++] = 0);
var count = new Array(256);
for (var i = 0; i < 256; count[i++] = 0);
for (var i = 0; i < markerpos; i++) {
var c = this.data[i];
pos[i] = (c << 24) | (count[0xff & c] & 0xffffff);
count[0xff & c]++;
}
for (var i = markerpos + 1; i < this.size; i++) {
var c = this.data[i];
pos[i] = (c << 24) | (count[0xff & c] & 0xffffff);
count[0xff & c]++;
}
var last = 1;
for (var i = 0; i < 256; i++) {
var tmp = count[i];
count[i] = last;
last += tmp;
}
var j = 0;
last = this.size - 1;
while (last > 0) {
var n = pos[j];
var c = pos[j] >> 24;
this.data[--last] = 0xff & c;
j = count[0xff & c] + (n & 0xffffff);
}
if (j != markerpos) {
throw new Error("BZZ byte stream is corrupted");
}
return this.size;
}
getByteStream() {
var bsw, size;
while (size = this._decode()) {
if (!bsw) {
bsw = new ByteStreamWriter(size - 1);
}
var arr = new Uint8Array(this.data.buffer, 0, size - 1);
bsw.writeArray(arr);
}
this.data = null;
return new ByteStream(bsw.getBuffer());
}
static decodeByteStream(bs) {
return new BZZDecoder(new ZPDecoder(bs)).getByteStream();
}
}
class DjVuPalette extends IFFChunk {
constructor(bs) {
var time = performance.now();
super(bs);
this.pixel = { r: 0, g: 0, b: 0 };
this.version = bs.getUint8();
if (this.version & 0x7f) {
throw "Bad Djvu Pallete version!";
}
this.palleteSize = bs.getInt16();
if (this.palleteSize < 0 || this.palleteSize > 65535) {
throw "Bad Djvu Pallete size!";
}
this.colorArray = bs.getUint8Array(this.palleteSize * 3);
if (this.version & 0x80) {
this.dataSize = bs.getInt24();
if (this.dataSize < 0) {
throw "Bad Djvu Pallete data size!";
}
var bsz = BZZDecoder.decodeByteStream(bs.fork());
this.colorIndices = new Int16Array(this.dataSize);
for (var i = 0; i < this.dataSize; i++) {
var index = bsz.getInt16();
if (index < 0 || index >= this.palleteSize) {
throw "Bad Djvu Pallete index! " + index;
}
this.colorIndices[i] = index;
}
}
DjVu.IS_DEBUG && console.log('DjvuPalette time ', performance.now() - time);
}
getDataSize() {
return this.dataSize;
}
getPixelByBlitIndex(index) {
var colorIndex = this.colorIndices[index] * 3;
this.pixel.r = this.colorArray[colorIndex + 2];
this.pixel.g = this.colorArray[colorIndex + 1];
this.pixel.b = this.colorArray[colorIndex];
return this.pixel;
}
toString() {
var str = super.toString();
str += "Pallete size: " + this.palleteSize + "\n";
str += "Data size: " + this.dataSize + "\n";
return str;
}
}
class IWCodecBaseClass {
constructor() {
this.quant_lo = Uint32Array.of(
0x004000, 0x008000, 0x008000, 0x010000, 0x010000,
0x010000, 0x010000, 0x010000, 0x010000, 0x010000,
0x010000, 0x010000, 0x020000, 0x020000, 0x020000, 0x020000
);
this.quant_hi = Uint32Array.of(
0, 0x020000, 0x020000, 0x040000, 0x040000,
0x040000, 0x080000, 0x040000, 0x040000, 0x080000
);
this.bucketstate = new Uint8Array(16);
this.coeffstate = new Array(16);
var buffer = new ArrayBuffer(256);
for (var i = 0; i < 16; i++) {
this.coeffstate[i] = new Uint8Array(buffer, i << 4, 16);
}
this.bbstate = 0;
this.decodeBucketCtx = new Uint8Array(1);
this.decodeCoefCtx = new Uint8Array(80);
this.activateCoefCtx = new Uint8Array(16);
this.inreaseCoefCtx = new Uint8Array(1);
this.curband = 0;
}
getBandBuckets(band) {
return this.bandBuckets[band];
}
is_null_slice() {
if (this.curband == 0)
{
var is_null = 1;
for (var i = 0; i < 16; i++) {
var threshold = this.quant_lo[i];
this.coeffstate[0][i] = 1;
if (threshold > 0 && threshold < 0x8000) {
this.coeffstate[0][i] = 8;
is_null = 0;
}
}
return is_null;
} else
{
var threshold = this.quant_hi[this.curband];
return (!(threshold > 0 && threshold < 0x8000));
}
}
finish_code_slice() {
this.quant_hi[this.curband] = this.quant_hi[this.curband] >> 1;
if (this.curband === 0) {
for (var i = 0; i < 16; i++)
this.quant_lo[i] = this.quant_lo[i] >> 1;
}
this.curband++;
if (this.curband === 10) {
this.curband = 0;
}
}
}
IWCodecBaseClass.prototype.ZERO = 1;
IWCodecBaseClass.prototype.ACTIVE = 2;
IWCodecBaseClass.prototype.NEW = 4;
IWCodecBaseClass.prototype.UNK = 8;
IWCodecBaseClass.prototype.zigzagRow = Uint8Array.of(0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 0, 0, 16, 16, 0, 0, 16, 16, 8, 8, 24, 24, 8, 8, 24, 24, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 4, 4, 20, 20, 4, 4, 20, 20, 12, 12, 28, 28, 12, 12, 28, 28, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 2, 2, 18, 18, 2, 2, 18, 18, 10, 10, 26, 26, 10, 10, 26, 26, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 6, 6, 22, 22, 6, 6, 22, 22, 14, 14, 30, 30, 14, 14, 30, 30, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 1, 1, 17, 17, 1, 1, 17, 17, 9, 9, 25, 25, 9, 9, 25, 25, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 5, 5, 21, 21, 5, 5, 21, 21, 13, 13, 29, 29, 13, 13, 29, 29, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 3, 3, 19, 19, 3, 3, 19, 19, 11, 11, 27, 27, 11, 11, 27, 27, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31, 7, 7, 23, 23, 7, 7, 23, 23, 15, 15, 31, 31, 15, 15, 31, 31);
IWCodecBaseClass.prototype.zigzagCol = Uint8Array.of(0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31, 0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 0, 16, 0, 16, 8, 24, 8, 24, 0, 16, 0, 16, 8, 24, 8, 24, 4, 20, 4, 20, 12, 28, 12, 28, 4, 20, 4, 20, 12, 28, 12, 28, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 2, 18, 2, 18, 10, 26, 10, 26, 2, 18, 2, 18, 10, 26, 10, 26, 6, 22, 6, 22, 14, 30, 14, 30, 6, 22, 6, 22, 14, 30, 14, 30, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 1, 17, 1, 17, 9, 25, 9, 25, 1, 17, 1, 17, 9, 25, 9, 25, 5, 21, 5, 21, 13, 29, 13, 29, 5, 21, 5, 21, 13, 29, 13, 29, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31, 3, 19, 3, 19, 11, 27, 11, 27, 3, 19, 3, 19, 11, 27, 11, 27, 7, 23, 7, 23, 15, 31, 15, 31, 7, 23, 7, 23, 15, 31, 15, 31);
IWCodecBaseClass.prototype.bandBuckets = [
{ from: 0, to: 0 },
{ from: 1, to: 1 },
{ from: 2, to: 2 },
{ from: 3, to: 3 },
{ from: 4, to: 7 },
{ from: 8, to: 11 },
{ from: 12, to: 15 },
{ from: 16, to: 31 },
{ from: 32, to: 47 },
{ from: 48, to: 63 }
];
function _normalize(val) {
val = (val + 32) >> 6;
if (val < -128) {
return -128;
} else if (val >= 128) {
return 127;
}
return val;
}
class LazyPixelmap {
constructor(ybytemap, cbbytemap, crbytemap) {
this.width = ybytemap.width;
this.yArray = ybytemap.array;
this.cbArray = cbbytemap ? cbbytemap.array : null;
this.crArray = crbytemap ? crbytemap.array : null;
this.writePixel = cbbytemap ? this.writeColoredPixel : this.writeGrayScalePixel;
}
writeGrayScalePixel(index, pixelArray, pixelIndex) {
const value = 127 - _normalize(this.yArray[index]);
pixelArray[pixelIndex] = value;
pixelArray[pixelIndex | 1] = value;
pixelArray[pixelIndex | 2] = value;
}
writeColoredPixel(index, pixelArray, pixelIndex) {
const y = _normalize(this.yArray[index]);
const b = _normalize(this.cbArray[index]);
const r = _normalize(this.crArray[index]);
const t2 = r + (r >> 1);
const t3 = y + 128 - (b >> 2);
pixelArray[pixelIndex] = y + 128 + t2;
pixelArray[pixelIndex | 1] = t3 - (t2 >> 1);
pixelArray[pixelIndex | 2] = t3 + (b << 1);
}
}
class LinearBytemap {
constructor(width, height) {
this.width = width;
this.array = new Int16Array(width * height);
}
get(i, j) {
return this.array[i * this.width + j];
}
set(i, j, val) {
this.array[i * this.width + j] = val;
}
sub(i, j, val) {
this.array[i * this.width + j] -= val;
}
add(i, j, val) {
this.array[i * this.width + j] += val;
}
}
class Bytemap extends Array {
constructor(width, height) {
super(height);
this.height = height;
this.width = width;
for (var i = 0; i < height; i++) {
this[i] = new Int16Array(width);
}
}
}
class Block {
constructor(buffer, offset, withBuckets = false) {
this.array = new Int16Array(buffer, offset, 1024);
if (withBuckets) {
this.buckets = new Array(64);
for (var i = 0; i < 64; i++) {
this.buckets[i] = new Int16Array(buffer, offset, 16);
offset += 32;
}
}
}
setBucketCoef(bucketNumber, index, value) {
this.array[(bucketNumber << 4) | index] = value;
}
getBucketCoef(bucketNumber, index) {
return this.array[(bucketNumber << 4) | index];
}
getCoef(n) {
return this.array[n];
}
setCoef(n, val) {
this.array[n] = val;
}
static createBlockArray(length) {
var blocks = new Array(length);
var buffer = new ArrayBuffer(length << 11);
for (var i = 0; i < length; i++) {
blocks[i] = new Block(buffer, i << 11);
}
return blocks;
}
}
class BlockMemoryManager {
constructor() {
this.buffer = null;
this.offset = 0;
this.retainedMemory = 0;
this.usedMemory = 0;
}
ensureBuffer() {
if (!this.buffer || this.offset >= this.buffer.byteLength) {
this.buffer = new ArrayBuffer(10 << 20);
this.offset = 0;
this.retainedMemory += this.buffer.byteLength;
}
return this.buffer;
}
allocateBucket() {
this.ensureBuffer();
const array = new Int16Array(this.buffer, this.offset, 16);
this.offset += 32;
this.usedMemory += 32;
return array;
}
}
class LazyBlock {
constructor(memoryManager) {
this.buckets = new Array(64);
this.mm = memoryManager;
}
setBucketCoef(bucketNumber, index, value) {
if (!this.buckets[bucketNumber]) {
this.buckets[bucketNumber] = this.mm.allocateBucket();
}
this.buckets[bucketNumber][index] = value;
}
getBucketCoef(bucketNumber, index) {
return this.buckets[bucketNumber] ? this.buckets[bucketNumber][index] : 0;
}
getCoef(n) {
return this.getBucketCoef(n >> 4, n & 15);
}
setCoef(n, val) {
return this.setBucketCoef(n >> 4, n & 15, val);
}
static createBlockArray(length) {
const mm = new BlockMemoryManager();
const blocks = new Array(length);
for (var i = 0; i < length; i++) {
blocks[i] = new LazyBlock(mm);
}
return blocks;
}
}
class IWDecoder extends IWCodecBaseClass {
constructor() {
super();
}
init(imageinfo) {
this.info = imageinfo;
var blockCount = Math.ceil(this.info.width / 32) * Math.ceil(this.info.height / 32);
this.blocks = LazyBlock.createBlockArray(blockCount);
}
decodeSlice(zp, imageinfo) {
if (!this.info) {
this.init(imageinfo);
}
this.zp = zp;
if (!this.is_null_slice()) {
this.blocks.forEach(block => {
this.preliminaryFlagComputation(block);
if (this.blockBandDecodingPass()) {
this.bucketDecodingPass(block, this.curband);
this.newlyActiveCoefficientDecodingPass(block, this.curband);
}
this.previouslyActiveCoefficientDecodingPass(block);
});
}
this.finish_code_slice();
}
previouslyActiveCoefficientDecodingPass(block) {
var boff = 0;
var step = this.quant_hi[this.curband];
var indices = this.getBandBuckets(this.curband);
for (var i = indices.from; i <= indices.to; i++, boff++) {
for (var j = 0; j < 16; j++) {
if (this.coeffstate[boff][j] & 2 ) {
if (!this.curband) {
step = this.quant_lo[j];
}
var des = 0;
var coef = block.getBucketCoef(i, j);
var absCoef = Math.abs(coef);
if (absCoef <= 3 * step) {
des = this.zp.decode(this.inreaseCoefCtx, 0);
absCoef += step >> 2;
} else {
des = this.zp.IWdecode();
}
if (des) {
absCoef += step >> 1;
} else {
absCoef += -step + (step >> 1);
}
block.setBucketCoef(i, j, coef < 0 ? -absCoef : absCoef);
}
}
}
}
newlyActiveCoefficientDecodingPass(block, band) {
var boff = 0;
var indices = this.getBandBuckets(band);
var step = this.quant_hi[this.curband];
for (var i = indices.from; i <= indices.to; i++, boff++) {
if (this.bucketstate[boff] & 4) {
var shift = 0;
if (this.bucketstate[boff] & 2) {
shift = 8;
}
var np = 0;
for (var j = 0; j < 16; j++) {
if (this.coeffstate[boff][j] & 8) {
np++;
}
}
for (var j = 0; j < 16; j++) {
if (this.coeffstate[boff][j] & 8) {
var ip = Math.min(7, np);
var des = this.zp.decode(this.activateCoefCtx, shift + ip);
if (des) {
var sign = this.zp.IWdecode() ? -1 : 1;
np = 0;
if (!this.curband) {
step = this.quant_lo[j];
}
block.setBucketCoef(i, j, sign * (step + (step >> 1) - (step >> 3)));
}
if (np) {
np--;
}
}
}
}
}
}
bucketDecodingPass(block, band) {
var indices = this.getBandBuckets(band);
var boff = 0;
for (var i = indices.from; i <= indices.to; i++, boff++) {
if (!(this.bucketstate[boff] & 8)) {
continue;
}
var n = 0;
if (band) {
var t = 4 * i;
for (var j = t; j < t + 4; j++) {
if (block.getCoef(j)) {
n++;
}
}
if (n === 4) {
n--;
}
}
if (this.bbstate & 2) {
n |= 4;
}
if (this.zp.decode(this.decodeCoefCtx, n + band * 8)) {
this.bucketstate[boff] |= 4;
}
}
}
blockBandDecodingPass() {
var indices = this.getBandBuckets(this.curband);
var bcount = indices.to - indices.from + 1;
if (bcount < 16 || (this.bbstate & 2)) {
this.bbstate |= 4 ;
} else if (this.bbstate & 8) {
if (this.zp.decode(this.decodeBucketCtx, 0)) {
this.bbstate |= 4;
}
}
return this.bbstate & 4;
}
preliminaryFlagComputation(block) {
this.bbstate = 0;
var bstatetmp = 0;
var indices = this.getBandBuckets(this.curband);
if (this.curband) {
var boff = 0;
for (var j = indices.from; j <= indices.to; j++, boff++) {
bstatetmp = 0;
for (var k = 0; k < 16; k++) {
if (block.getBucketCoef(j, k) === 0) {
this.coeffstate[boff][k] = 8;
} else {
this.coeffstate[boff][k] = 2;
}
bstatetmp |= this.coeffstate[boff][k];
}
this.bucketstate[boff] = bstatetmp;
this.bbstate |= bstatetmp;
}
} else {
for (var k = 0; k < 16; k++) {
if (this.coeffstate[0][k] !== 1) {
if (block.getBucketCoef(0, k) === 0) {
this.coeffstate[0][k] = 8;
} else {
this.coeffstate[0][k] = 2;
}
}
bstatetmp |= this.coeffstate[0][k];
}
this.bucketstate[0] = bstatetmp;
this.bbstate |= bstatetmp;
}
}
getBytemap() {
var time = performance.now();
var fullWidth = Math.ceil(this.info.width / 32) * 32;
var fullHeight = Math.ceil(this.info.height / 32) * 32;
var blockRows = Math.ceil(this.info.height / 32);
var blockCols = Math.ceil(this.info.width / 32);
var bm = new LinearBytemap(fullWidth, fullHeight);
for (var r = 0; r < blockRows; r++) {
for (var c = 0; c < blockCols; c++) {
var block = this.blocks[r * blockCols + c];
for (var i = 0; i < 1024; i++) {
bm.set(this.zigzagRow[i] + (r << 5), this.zigzagCol[i] + (c << 5), block.getCoef(i));
}
}
}
DjVu.IS_DEBUG && console.time("inverseTime");
this.inverseWaveletTransform(bm);
DjVu.IS_DEBUG && console.timeEnd("inverseTime");
DjVu.IS_DEBUG && console.log("getBytemap time = ", performance.now() - time);
return bm;
}
inverseWaveletTransform(bitmap) {
var height = this.info.height;
var width = this.info.width;
var a, c, kmax, k, i, border;
var prev3, prev1, next1, next3;
for (var s = 16, sDegree = 4; s !== 0; s >>= 1, sDegree--) {
kmax = (height - 1) >> sDegree;
border = kmax - 3;
for (i = 0; i < width; i += s) {
k = 0;
prev1 = 0; next1 = 0;
next3 = 1 > kmax ? 0 : bitmap.get(1 << sDegree, i);
for (k = 0; k <= kmax; k += 2) {
prev3 = prev1; prev1 = next1; next1 = next3;
next3 = (k + 3) > kmax ? 0 : bitmap.get((k + 3) << sDegree, i);
a = prev1 + next1;
c = prev3 + next3;
bitmap.sub(k << sDegree, i, ((a << 3) + a - c + 16) >> 5);
}
k = 1;
prev1 = bitmap.get((k - 1) << sDegree, i);
if (k + 1 <= kmax) {
next1 = bitmap.get((k + 1) << sDegree, i);
bitmap.add(k << sDegree, i, (prev1 + next1 + 1) >> 1);
} else {
bitmap.add(k << sDegree, i, prev1);
}
if (border >= 3) {
next3 = bitmap.get((k + 3) << sDegree, i);
}
for (k = 3; k <= border; k += 2) {
prev3 = prev1; prev1 = next1; next1 = next3;
next3 = bitmap.get((k + 3) << sDegree, i);
a = prev1 + next1;
bitmap.add(k << sDegree, i,
((a << 3) + a - (prev3 + next3) + 8) >> 4
);
}
for (; k <= kmax; k += 2) {
prev1 = next1; next1 = next3; next3 = 0;
if (k + 1 <= kmax) {
bitmap.add(k << sDegree, i, (prev1 + next1 + 1) >> 1);
} else {
bitmap.add(k << sDegree, i, prev1);
}
}
}
kmax = (width - 1) >> sDegree;
border = kmax - 3;
for (i = 0; i < height; i += s) {
k = 0;
prev1 = 0;
next1 = 0;
next3 = 1 > kmax ? 0 : bitmap.get(i, 1 << sDegree);
for (k = 0; k <= kmax; k += 2) {
prev3 = prev1; prev1 = next1; next1 = next3;
next3 = k + 3 > kmax ? 0 : bitmap.get(i, (k + 3) << sDegree);
a = prev1 + next1;
c = prev3 + next3;
bitmap.sub(i, k << sDegree, ((a << 3) + a - c + 16) >> 5);
}
k = 1;
prev1 = bitmap.get(i, (k - 1) << sDegree);
if (k + 1 <= kmax) {
next1 = bitmap.get(i, (k + 1) << sDegree);
bitmap.add(i, k << sDegree, (prev1 + next1 + 1) >> 1);
} else {
bitmap.add(i, k << sDegree, prev1);
}
if (border >= 3) {
next3 = bitmap.get(i, (k + 3) << sDegree);
}
for (k = 3; k <= border; k += 2) {
prev3 = prev1; prev1 = next1; next1 = next3;
next3 = bitmap.get(i, (k + 3) << sDegree);
a = prev1 + next1;
bitmap.add(i, k << sDegree,
((a << 3) + a - (prev3 + next3) + 8) >> 4
);
}
for (; k <= kmax; k += 2) {
prev1 = next1; next1 = next3; next3 = 0;
if (k + 1 <= kmax) {
bitmap.add(i, k << sDegree, (prev1 + next1 + 1) >> 1);
} else {
bitmap.add(i, k << sDegree, prev1);
}
}
}
}
}
}
class IWImage {
constructor() {
this.info = null;
this.pixelmap = null;
this.resetCodecs();
}
resetCodecs() {
this.ycodec = new IWDecoder();
this.crcodec = this.crcodec ? new IWDecoder() : null;
this.cbcodec = this.cbcodec ? new IWDecoder() : null;
this.cslice = 0;
}
decodeChunk(zp, header) {
if (!this.info) {
this.info = header;
if (!header.grayscale) {
this.crcodec = new IWDecoder();
this.cbcodec = new IWDecoder();
}
} else {
this.info.slices = header.slices;
}
for (var i = 0; i < this.info.slices; i++) {
this.cslice++;
this.ycodec.decodeSlice(zp, header);
if (this.crcodec && this.cbcodec && this.cslice > this.info.delayInit) {
this.cbcodec.decodeSlice(zp, header);
this.crcodec.decodeSlice(zp, header);
}
}
}
createPixelmap() {
var time = performance.now();
var ybitmap = this.ycodec.getBytemap();
var cbbitmap = this.cbcodec ? this.cbcodec.getBytemap() : null;
var crbitmap = this.crcodec ? this.crcodec.getBytemap() : null;
var pixelMapTime = performance.now();
this.pixelmap = new LazyPixelmap(ybitmap, cbbitmap, crbitmap);
DjVu.IS_DEBUG && console.log('Pixelmap constructor time = ', performance.now() - pixelMapTime);
DjVu.IS_DEBUG && console.log('IWImage.createPixelmap time = ', performance.now() - time);
this.resetCodecs();
}
getImage() {
const time = performance.now();
if (!this.pixelmap) this.createPixelmap();
const width = this.info.width;
const height = this.info.height;
const image = new ImageData(width, height);
const processRow = (i) => {
const rowOffset = i * this.pixelmap.width;
let pixelIndex = ((height - i - 1) * width) << 2;
for (let j = 0; j < width; j++) {
this.pixelmap.writePixel(rowOffset + j, image.data, pixelIndex);
image.data[pixelIndex | 3] = 255;
pixelIndex += 4;
}
};
for (let i = 0; i < height; i++) {
processRow(i);
}
DjVu.IS_DEBUG && console.log('IWImage.getImage time = ', performance.now() - time);
return image;
}
}
class DjVuText extends IFFChunk {
constructor(bs) {
super(bs);
this.isDecoded = false;
this.dbs = this.id === 'TXTz' ? null : this.bs;
}
decode() {
if (this.isDecoded) {
return;
}
if (!this.dbs) {
this.dbs = BZZDecoder.decodeByteStream(this.bs);
}
this.textLength = this.dbs.getInt24();
this.utf8array = this.dbs.getUint8Array(this.textLength);
this.version = this.dbs.getUint8();
if (this.version !== 1) {
console.warn("The version in " + this.id + " isn't equal to 1!");
}
this.pageZone = this.dbs.isEmpty() ? null : this.decodeZone();
this.isDecoded = true;
}
decodeZone(parent = null, prev = null) {
var type = this.dbs.getUint8();
var x = this.dbs.getUint16() - 0x8000;
var y = this.dbs.getUint16() - 0x8000;
var width = this.dbs.getUint16() - 0x8000;
var height = this.dbs.getUint16() - 0x8000;
var textStart = this.dbs.getUint16() - 0x8000;
var textLength = this.dbs.getInt24();
if (prev) {
if (type === 1 || type === 4 || type === 5 ) {
x = x + prev.x;
y = prev.y - (y + height);
} else
{
x = x + prev.x + prev.width;
y = y + prev.y;
}
textStart += prev.textStart + prev.textLength;
} else if (parent) {
x = x + parent.x;
y = parent.y + parent.height - (y + height);
textStart += parent.textStart;
}
var zone = { type, x, y, width, height, textStart, textLength };
var childrenCount = this.dbs.getInt24();
if (childrenCount) {
var children = new Array(childrenCount);
var childZone = null;
for (var i = 0; i < childrenCount; i++) {
childZone = this.decodeZone(zone, childZone);
children[i] = childZone;
}
zone.children = children;
}
return zone;
}
getText() {
this.decode();
this.text = this.text || createStringFromUtf8Array(this.utf8array);
return this.text;
}
getPageZone() {
this.decode();
return this.pageZone;
}
getNormalizedZones() {
this.decode();
if (!this.pageZone) {
return null;
}
if (this.normalizedZones) {
return this.normalizedZones;
}
this.normalizedZones = [];
var registry = {};
const process = (zone) => {
if (zone.children) {
zone.children.forEach(zone => process(zone));
} else {
var key = zone.x.toString() + zone.y + zone.width + zone.height;
var zoneText = createStringFromUtf8Array(this.utf8array.slice(zone.textStart, zone.textStart + zone.textLength));
if (registry[key]) {
registry[key].text += zoneText;
} else {
registry[key] = {
x: zone.x,
y: zone.y,
width: zone.width,
height: zone.height,
text: zoneText
};
this.normalizedZones.push(registry[key]);
}
}
};
process(this.pageZone);
return this.normalizedZones;
}
toString() {
this.decode();
var st = "Text length = " + this.textLength + "\n";
return super.toString() + st;
}
}
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function commonjsRequire () {
throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var browser = createCommonjsModule(function (module, exports) {
(function(f){{module.exports=f();}})(function(){return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof commonjsRequire=="function"&&commonjsRequire;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 commonjsRequire=="function"&&commonjsRequire;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
(function (Buffer){
let interlaceUtils = require("./interlace");
let pixelBppMapper = [
function () {},
function (pxData, data, pxPos, rawPos) {
if (rawPos === data.length) {
throw new Error("Ran out of data");
}
let pixel = data[rawPos];
pxData[pxPos] = pixel;
pxData[pxPos + 1] = pixel;
pxData[pxPos + 2] = pixel;
pxData[pxPos + 3] = 0xff;
},
function (pxData, data, pxPos, rawPos) {
if (rawPos + 1 >= data.length) {
throw new Error("Ran out of data");
}
let pixel = data[rawPos];
pxData[pxPos] = pixel;
pxData[pxPos + 1] = pixel;
pxData[pxPos + 2] = pixel;
pxData[pxPos + 3] = data[rawPos + 1];
},
function (pxData, data, pxPos, rawPos) {
if (rawPos + 2 >= data.length) {
throw new Error("Ran out of data");
}
pxData[pxPos] = data[rawPos];
pxData[pxPos + 1] = data[rawPos + 1];
pxData[pxPos + 2] = data[rawPos + 2];
pxData[pxPos + 3] = 0xff;
},
function (pxData, data, pxPos, rawPos) {
if (rawPos + 3 >= data.length) {
throw new Error("Ran out of data");
}
pxData[pxPos] = data[rawPos];
pxData[pxPos + 1] = data[rawPos + 1];
pxData[pxPos + 2] = data[rawPos + 2];
pxData[pxPos + 3] = data[rawPos + 3];
},
];
let pixelBppCustomMapper = [
function () {},
function (pxData, pixelData, pxPos, maxBit) {
let pixel = pixelData[0];
pxData[pxPos] = pixel;
pxData[pxPos + 1] = pixel;
pxData[pxPos + 2] = pixel;
pxData[pxPos + 3] = maxBit;
},
function (pxData, pixelData, pxPos) {
let pixel = pixelData[0];
pxData[pxPos] = pixel;
pxData[pxPos + 1] = pixel;
pxData[pxPos + 2] = pixel;
pxData[pxPos + 3] = pixelData[1];
},
function (pxData, pixelData, pxPos, maxBit) {
pxData[pxPos] = pixelData[0];
pxData[pxPos + 1] = pixelData[1];
pxData[pxPos + 2] = pixelData[2];
pxData[pxPos + 3] = maxBit;
},
function (pxData, pixelData, pxPos) {
pxData[pxPos] = pixelData[0];
pxData[pxPos + 1] = pixelData[1];
pxData[pxPos + 2] = pixelData[2];
pxData[pxPos + 3] = pixelData[3];
},
];
function bitRetriever(data, depth) {
let leftOver = [];
let i = 0;
function split() {
if (i === data.length) {
throw new Error("Ran out of data");
}
let byte = data[i];
i++;
let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;
switch (depth) {
default:
throw new Error("unrecognised depth");
case 16:
byte2 = data[i];
i++;
leftOver.push((byte << 8) + byte2);
break;
case 4:
byte2 = byte & 0x0f;
byte1 = byte >> 4;
leftOver.push(byte1, byte2);
break;
case 2:
byte4 = byte & 3;
byte3 = (byte >> 2) & 3;
byte2 = (byte >> 4) & 3;
byte1 = (byte >> 6) & 3;
leftOver.push(byte1, byte2, byte3, byte4);
break;
case 1:
byte8 = byte & 1;
byte7 = (byte >> 1) & 1;
byte6 = (byte >> 2) & 1;
byte5 = (byte >> 3) & 1;
byte4 = (byte >> 4) & 1;
byte3 = (byte >> 5) & 1;
byte2 = (byte >> 6) & 1;
byte1 = (byte >> 7) & 1;
leftOver.push(byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8);
break;
}
}
return {
get: function (count) {
while (leftOver.length < count) {
split();
}
let returner = leftOver.slice(0, count);
leftOver = leftOver.slice(count);
return returner;
},
resetAfterLine: function () {
leftOver.length = 0;
},
end: function () {
if (i !== data.length) {
throw new Error("extra data found");
}
},
};
}
function mapImage8Bit(image, pxData, getPxPos, bpp, data, rawPos) {
let imageWidth = image.width;
let imageHeight = image.height;
let imagePass = image.index;
for (let y = 0; y < imageHeight; y++) {
for (let x = 0; x < imageWidth; x++) {
let pxPos = getPxPos(x, y, imagePass);
pixelBppMapper[bpp](pxData, data, pxPos, rawPos);
rawPos += bpp;
}
}
return rawPos;
}
function mapImageCustomBit(image, pxData, getPxPos, bpp, bits, maxBit) {
let imageWidth = image.width;
let imageHeight = image.height;
let imagePass = image.index;
for (let y = 0; y < imageHeight; y++) {
for (let x = 0; x < imageWidth; x++) {
let pixelData = bits.get(bpp);
let pxPos = getPxPos(x, y, imagePass);
pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);
}
bits.resetAfterLine();
}
}
exports.dataToBitMap = function (data, bitmapInfo) {
let width = bitmapInfo.width;
let height = bitmapInfo.height;
let depth = bitmapInfo.depth;
let bpp = bitmapInfo.bpp;
let interlace = bitmapInfo.interlace;
let bits;
if (depth !== 8) {
bits = bitRetriever(data, depth);
}
let pxData;
if (depth <= 8) {
pxData = Buffer.alloc(width * height * 4);
} else {
pxData = new Uint16Array(width * height * 4);
}
let maxBit = Math.pow(2, depth) - 1;
let rawPos = 0;
let images;
let getPxPos;
if (interlace) {
images = interlaceUtils.getImagePasses(width, height);
getPxPos = interlaceUtils.getInterlaceIterator(width, height);
} else {
let nonInterlacedPxPos = 0;
getPxPos = function () {
let returner = nonInterlacedPxPos;
nonInterlacedPxPos += 4;
return returner;
};
images = [{ width: width, height: height }];
}
for (let imageIndex = 0; imageIndex < images.length; imageIndex++) {
if (depth === 8) {
rawPos = mapImage8Bit(
images[imageIndex],
pxData,
getPxPos,
bpp,
data,
rawPos
);
} else {
mapImageCustomBit(
images[imageIndex],
pxData,
getPxPos,
bpp,
bits,
maxBit
);
}
}
if (depth === 8) {
if (rawPos !== data.length) {
throw new Error("extra data found");
}
} else {
bits.end();
}
return pxData;
};
}).call(this,require("buffer").Buffer);
},{"./interlace":11,"buffer":28}],2:[function(require,module,exports){
(function (Buffer){
let constants = require("./constants");
module.exports = function (dataIn, width, height, options) {
let outHasAlpha =
[constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(
options.colorType
) !== -1;
if (options.colorType === options.inputColorType) {
let bigEndian = (function () {
let buffer = new ArrayBuffer(2);
new DataView(buffer).setInt16(0, 256, true );
return new Int16Array(buffer)[0] !== 256;
})();
if (options.bitDepth === 8 || (options.bitDepth === 16 && bigEndian)) {
return dataIn;
}
}
let data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);
let maxValue = 255;
let inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType];
if (inBpp === 4 && !options.inputHasAlpha) {
inBpp = 3;
}
let outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType];
if (options.bitDepth === 16) {
maxValue = 65535;
outBpp *= 2;
}
let outData = Buffer.alloc(width * height * outBpp);
let inIndex = 0;
let outIndex = 0;
let bgColor = options.bgColor || {};
if (bgColor.red === undefined) {
bgColor.red = maxValue;
}
if (bgColor.green === undefined) {
bgColor.green = maxValue;
}
if (bgColor.blue === undefined) {
bgColor.blue = maxValue;
}
function getRGBA() {
let red;
let green;
let blue;
let alpha = maxValue;
switch (options.inputColorType) {
case constants.COLORTYPE_COLOR_ALPHA:
alpha = data[inIndex + 3];
red = data[inIndex];
green = data[inIndex + 1];
blue = data[inIndex + 2];
break;
case constants.COLORTYPE_COLOR:
red = data[inIndex];
green = data[inIndex + 1];
blue = data[inIndex + 2];
break;
case constants.COLORTYPE_ALPHA:
alpha = data[inIndex + 1];
red = data[inIndex];
green = red;
blue = red;
break;
case constants.COLORTYPE_GRAYSCALE:
red = data[inIndex];
green = red;
blue = red;
break;
default:
throw new Error(
"input color type:" +
options.inputColorType +
" is not supported at present"
);
}
if (options.inputHasAlpha) {
if (!outHasAlpha) {
alpha /= maxValue;
red = Math.min(
Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0),
maxValue
);
green = Math.min(
Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0),
maxValue
);
blue = Math.min(
Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0),
maxValue
);
}
}
return { red: red, green: green, blue: blue, alpha: alpha };
}
for (let y = 0; y < height; y++) {
for (let x = 0; x < width; x++) {
let rgba = getRGBA();
switch (options.colorType) {
case constants.COLORTYPE_COLOR_ALPHA:
case constants.COLORTYPE_COLOR:
if (options.bitDepth === 8) {
outData[outIndex] = rgba.red;
outData[outIndex + 1] = rgba.green;
outData[outIndex + 2] = rgba.blue;
if (outHasAlpha) {
outData[outIndex + 3] = rgba.alpha;
}
} else {
outData.writeUInt16BE(rgba.red, outIndex);
outData.writeUInt16BE(rgba.green, outIndex + 2);
outData.writeUInt16BE(rgba.blue, outIndex + 4);
if (outHasAlpha) {
outData.writeUInt16BE(rgba.alpha, outIndex + 6);
}
}
break;
case constants.COLORTYPE_ALPHA:
case constants.COLORTYPE_GRAYSCALE: {
let grayscale = (rgba.red + rgba.green + rgba.blue) / 3;
if (options.bitDepth === 8) {
outData[outIndex] = grayscale;
if (outHasAlpha) {
outData[outIndex + 1] = rgba.alpha;
}
} else {
outData.writeUInt16BE(grayscale, outIndex);
if (outHasAlpha) {
outData.writeUInt16BE(rgba.alpha, outIndex + 2);
}
}
break;
}
default:
throw new Error("unrecognised color Type " + options.colorType);
}
inIndex += inBpp;
outIndex += outBpp;
}
}
return outData;
};
}).call(this,require("buffer").Buffer);
},{"./constants":4,"buffer":28}],3:[function(require,module,exports){
(function (process,Buffer){
let util = require("util");
let Stream = require("stream");
let ChunkStream = (module.exports = function () {
Stream.call(this);
this._buffers = [];
this._buffered = 0;
this._reads = [];
this._paused = false;
this._encoding = "utf8";
this.writable = true;
});
util.inherits(ChunkStream, Stream);
ChunkStream.prototype.read = function (length, callback) {
this._reads.push({
length: Math.abs(length),
allowLess: length < 0,
func: callback,
});
process.nextTick(
function () {
this._process();
if (this._paused && this._reads && this._reads.length > 0) {
this._paused = false;
this.emit("drain");
}
}.bind(this)
);
};
ChunkStream.prototype.write = function (data, encoding) {
if (!this.writable) {
this.emit("error", new Error("Stream not writable"));
return false;
}
let dataBuffer;
if (Buffer.isBuffer(data)) {
dataBuffer = data;
} else {
dataBuffer = Buffer.from(data, encoding || this._encoding);
}
this._buffers.push(dataBuffer);
this._buffered += dataBuffer.length;
this._process();
if (this._reads && this._reads.length === 0) {
this._paused = true;
}
return this.writable && !this._paused;
};
ChunkStream.prototype.end = function (data, encoding) {
if (data) {
this.write(data, encoding);
}
this.writable = false;
if (!this._buffers) {
return;
}
if (this._buffers.length === 0) {
this._end();
} else {
this._buffers.push(null);
this._process();
}
};
ChunkStream.prototype.destroySoon = ChunkStream.prototype.end;
ChunkStream.prototype._end = function () {
if (this._reads.length > 0) {
this.emit("error", new Error("Unexpected end of input"));
}
this.destroy();
};
ChunkStream.prototype.destroy = function () {
if (!this._buffers) {
return;
}
this.writable = false;
this._reads = null;
this._buffers = null;
this.emit("close");
};
ChunkStream.prototype._processReadAllowingLess = function (read) {
this._reads.shift();
let smallerBuf = this._buffers[0];
if (smallerBuf.length > read.length) {
this._buffered -= read.length;
this._buffers[0] = smallerBuf.slice(read.length);
read.func.call(this, smallerBuf.slice(0, read.length));
} else {
this._buffered -= smallerBuf.length;
this._buffers.shift();
read.func.call(this, smallerBuf);
}
};
ChunkStream.prototype._processRead = function (read) {
this._reads.shift();
let pos = 0;
let count = 0;
let data = Buffer.alloc(read.length);
while (pos < read.length) {
let buf = this._buffers[count++];
let len = Math.min(buf.length, read.length - pos);
buf.copy(data, pos, 0, len);
pos += len;
if (len !== buf.length) {
this._buffers[--count] = buf.slice(len);
}
}
if (count > 0) {
this._buffers.splice(0, count);
}
this._buffered -= read.length;
read.func.call(this, data);
};
ChunkStream.prototype._process = function () {
try {
while (this._buffered > 0 && this._reads && this._reads.length > 0) {
let read = this._reads[0];
if (read.allowLess) {
this._processReadAllowingLess(read);
} else if (this._buffered >= read.length) {
this._processRead(read);
} else {
break;
}
}
if (this._buffers && !this.writable) {
this._end();
}
} catch (ex) {
this.emit("error", ex);
}
};
}).call(this,require('_process'),require("buffer").Buffer);
},{"_process":47,"buffer":28,"stream":63,"util":67}],4:[function(require,module,exports){
module.exports = {
PNG_SIGNATURE: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
TYPE_IHDR: 0x49484452,
TYPE_IEND: 0x49454e44,
TYPE_IDAT: 0x49444154,
TYPE_PLTE: 0x504c5445,
TYPE_tRNS: 0x74524e53,
TYPE_gAMA: 0x67414d41,
COLORTYPE_GRAYSCALE: 0,
COLORTYPE_PALETTE: 1,
COLORTYPE_COLOR: 2,
COLORTYPE_ALPHA: 4,
COLORTYPE_PALETTE_COLOR: 3,
COLORTYPE_COLOR_ALPHA: 6,
COLORTYPE_TO_BPP_MAP: {
0: 1,
2: 3,
3: 1,
4: 2,
6: 4,
},
GAMMA_DIVISION: 100000,
};
},{}],5:[function(require,module,exports){
let crcTable = [];
(function () {
for (let i = 0; i < 256; i++) {
let currentCrc = i;
for (let j = 0; j < 8; j++) {
if (currentCrc & 1) {
currentCrc = 0xedb88320 ^ (currentCrc >>> 1);
} else {
currentCrc = currentCrc >>> 1;
}
}
crcTable[i] = currentCrc;
}
})();
let CrcCalculator = (module.exports = function () {
this._crc = -1;
});
CrcCalculator.prototype.write = function (data) {
for (let i = 0; i < data.length; i++) {
this._crc = crcTable[(this._crc ^ data[i]) & 0xff] ^ (this._crc >>> 8);
}
return true;
};
CrcCalculator.prototype.crc32 = function () {
return this._crc ^ -1;
};
CrcCalculator.crc32 = function (buf) {
let crc = -1;
for (let i = 0; i < buf.length; i++) {
crc = crcTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
}
return crc ^ -1;
};
},{}],6:[function(require,module,exports){
(function (Buffer){
let paethPredictor = require("./paeth-predictor");
function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {
for (let x = 0; x < byteWidth; x++) {
rawData[rawPos + x] = pxData[pxPos + x];
}
}
function filterSumNone(pxData, pxPos, byteWidth) {
let sum = 0;
let length = pxPos + byteWidth;
for (let i = pxPos; i < length; i++) {
sum += Math.abs(pxData[i]);
}
return sum;
}
function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
for (let x = 0; x < byteWidth; x++) {
let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
let val = pxData[pxPos + x] - left;
rawData[rawPos + x] = val;
}
}
function filterSumSub(pxData, pxPos, byteWidth, bpp) {
let sum = 0;
for (let x = 0; x < byteWidth; x++) {
let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
let val = pxData[pxPos + x] - left;
sum += Math.abs(val);
}
return sum;
}
function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {
for (let x = 0; x < byteWidth; x++) {
let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
let val = pxData[pxPos + x] - up;
rawData[rawPos + x] = val;
}
}
function filterSumUp(pxData, pxPos, byteWidth) {
let sum = 0;
let length = pxPos + byteWidth;
for (let x = pxPos; x < length; x++) {
let up = pxPos > 0 ? pxData[x - byteWidth] : 0;
let val = pxData[x] - up;
sum += Math.abs(val);
}
return sum;
}
function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
for (let x = 0; x < byteWidth; x++) {
let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
let val = pxData[pxPos + x] - ((left + up) >> 1);
rawData[rawPos + x] = val;
}
}
function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
let sum = 0;
for (let x = 0; x < byteWidth; x++) {
let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
let val = pxData[pxPos + x] - ((left + up) >> 1);
sum += Math.abs(val);
}
return sum;
}
function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
for (let x = 0; x < byteWidth; x++) {
let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
let upleft =
pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
rawData[rawPos + x] = val;
}
}
function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
let sum = 0;
for (let x = 0; x < byteWidth; x++) {
let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
let upleft =
pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
sum += Math.abs(val);
}
return sum;
}
let filters = {
0: filterNone,
1: filterSub,
2: filterUp,
3: filterAvg,
4: filterPaeth,
};
let filterSums = {
0: filterSumNone,
1: filterSumSub,
2: filterSumUp,
3: filterSumAvg,
4: filterSumPaeth,
};
module.exports = function (pxData, width, height, options, bpp) {
let filterTypes;
if (!("filterType" in options) || options.filterType === -1) {
filterTypes = [0, 1, 2, 3, 4];
} else if (typeof options.filterType === "number") {
filterTypes = [options.filterType];
} else {
throw new Error("unrecognised filter types");
}
if (options.bitDepth === 16) {
bpp *= 2;
}
let byteWidth = width * bpp;
let rawPos = 0;
let pxPos = 0;
let rawData = Buffer.alloc((byteWidth + 1) * height);
let sel = filterTypes[0];
for (let y = 0; y < height; y++) {
if (filterTypes.length > 1) {
let min = Infinity;
for (let i = 0; i < filterTypes.length; i++) {
let sum = filterSums[filterTypes[i]](pxData, pxPos, byteWidth, bpp);
if (sum < min) {
sel = filterTypes[i];
min = sum;
}
}
}
rawData[rawPos] = sel;
rawPos++;
filters[sel](pxData, pxPos, byteWidth, rawData, rawPos, bpp);
rawPos += byteWidth;
pxPos += byteWidth;
}
return rawData;
};
}).call(this,require("buffer").Buffer);
},{"./paeth-predictor":15,"buffer":28}],7:[function(require,module,exports){
(function (Buffer){
let util = require("util");
let ChunkStream = require("./chunkstream");
let Filter = require("./filter-parse");
let FilterAsync = (module.exports = function (bitmapInfo) {
ChunkStream.call(this);
let buffers = [];
let that = this;
this._filter = new Filter(bitmapInfo, {
read: this.read.bind(this),
write: function (buffer) {
buffers.push(buffer);
},
complete: function () {
that.emit("complete", Buffer.concat(buffers));
},
});
this._filter.start();
});
util.inherits(FilterAsync, ChunkStream);
}).call(this,require("buffer").Buffer);
},{"./chunkstream":3,"./filter-parse":9,"buffer":28,"util":67}],8:[function(require,module,exports){
(function (Buffer){
let SyncReader = require("./sync-reader");
let Filter = require("./filter-parse");
exports.process = function (inBuffer, bitmapInfo) {
let outBuffers = [];
let reader = new SyncReader(inBuffer);
let filter = new Filter(bitmapInfo, {
read: reader.read.bind(reader),
write: function (bufferPart) {
outBuffers.push(bufferPart);
},
complete: function () {},
});
filter.start();
reader.process();
return Buffer.concat(outBuffers);
};
}).call(this,require("buffer").Buffer);
},{"./filter-parse":9,"./sync-reader":22,"buffer":28}],9:[function(require,module,exports){
(function (Buffer){
let interlaceUtils = require("./interlace");
let paethPredictor = require("./paeth-predictor");
function getByteWidth(width, bpp, depth) {
let byteWidth = width * bpp;
if (depth !== 8) {
byteWidth = Math.ceil(byteWidth / (8 / depth));
}
return byteWidth;
}
let Filter = (module.exports = function (bitmapInfo, dependencies) {
let width = bitmapInfo.width;
let height = bitmapInfo.height;
let interlace = bitmapInfo.interlace;
let bpp = bitmapInfo.bpp;
let depth = bitmapInfo.depth;
this.read = dependencies.read;
this.write = dependencies.write;
this.complete = dependencies.complete;
this._imageIndex = 0;
this._images = [];
if (interlace) {
let passes = interlaceUtils.getImagePasses(width, height);
for (let i = 0; i < passes.length; i++) {
this._images.push({
byteWidth: getByteWidth(passes[i].width, bpp, depth),
height: passes[i].height,
lineIndex: 0,
});
}
} else {
this._images.push({
byteWidth: getByteWidth(width, bpp, depth),
height: height,
lineIndex: 0,
});
}
if (depth === 8) {
this._xComparison = bpp;
} else if (depth === 16) {
this._xComparison = bpp * 2;
} else {
this._xComparison = 1;
}
});
Filter.prototype.start = function () {
this.read(
this._images[this._imageIndex].byteWidth + 1,
this._reverseFilterLine.bind(this)
);
};
Filter.prototype._unFilterType1 = function (
rawData,
unfilteredLine,
byteWidth
) {
let xComparison = this._xComparison;
let xBiggerThan = xComparison - 1;
for (let x = 0; x < byteWidth; x++) {
let rawByte = rawData[1 + x];
let f1Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
unfilteredLine[x] = rawByte + f1Left;
}
};
Filter.prototype._unFilterType2 = function (
rawData,
unfilteredLine,
byteWidth
) {
let lastLine = this._lastLine;
for (let x = 0; x < byteWidth; x++) {
let rawByte = rawData[1 + x];
let f2Up = lastLine ? lastLine[x] : 0;
unfilteredLine[x] = rawByte + f2Up;
}
};
Filter.prototype._unFilterType3 = function (
rawData,
unfilteredLine,
byteWidth
) {
let xComparison = this._xComparison;
let xBiggerThan = xComparison - 1;
let lastLine = this._lastLine;
for (let x = 0; x < byteWidth; x++) {
let rawByte = rawData[1 + x];
let f3Up = lastLine ? lastLine[x] : 0;
let f3Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
let f3Add = Math.floor((f3Left + f3Up) / 2);
unfilteredLine[x] = rawByte + f3Add;
}
};
Filter.prototype._unFilterType4 = function (
rawData,
unfilteredLine,
byteWidth
) {
let xComparison = this._xComparison;
let xBiggerThan = xComparison - 1;
let lastLine = this._lastLine;
for (let x = 0; x < byteWidth; x++) {
let rawByte = rawData[1 + x];
let f4Up = lastLine ? lastLine[x] : 0;
let f4Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
let f4UpLeft = x > xBiggerThan && lastLine ? lastLine[x - xComparison] : 0;
let f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);
unfilteredLine[x] = rawByte + f4Add;
}
};
Filter.prototype._reverseFilterLine = function (rawData) {
let filter = rawData[0];
let unfilteredLine;
let currentImage = this._images[this._imageIndex];
let byteWidth = currentImage.byteWidth;
if (filter === 0) {
unfilteredLine = rawData.slice(1, byteWidth + 1);
} else {
unfilteredLine = Buffer.alloc(byteWidth);
switch (filter) {
case 1:
this._unFilterType1(rawData, unfilteredLine, byteWidth);
break;
case 2:
this._unFilterType2(rawData, unfilteredLine, byteWidth);
break;
case 3:
this._unFilterType3(rawData, unfilteredLine, byteWidth);
break;
case 4:
this._unFilterType4(rawData, unfilteredLine, byteWidth);
break;
default:
throw new Error("Unrecognised filter type - " + filter);
}
}
this.write(unfilteredLine);
currentImage.lineIndex++;
if (currentImage.lineIndex >= currentImage.height) {
this._lastLine = null;
this._imageIndex++;
currentImage = this._images[this._imageIndex];
} else {
this._lastLine = unfilteredLine;
}
if (currentImage) {
this.read(currentImage.byteWidth + 1, this._reverseFilterLine.bind(this));
} else {
this._lastLine = null;
this.complete();
}
};
}).call(this,require("buffer").Buffer);
},{"./interlace":11,"./paeth-predictor":15,"buffer":28}],10:[function(require,module,exports){
(function (Buffer){
function dePalette(indata, outdata, width, height, palette) {
let pxPos = 0;
for (let y = 0; y < height; y++) {
for (let x = 0; x < width; x++) {
let color = palette[indata[pxPos]];
if (!color) {
throw new Error("index " + indata[pxPos] + " not in palette");
}
for (let i = 0; i < 4; i++) {
outdata[pxPos + i] = color[i];
}
pxPos += 4;
}
}
}
function replaceTransparentColor(indata, outdata, width, height, transColor) {
let pxPos = 0;
for (let y = 0; y < height; y++) {
for (let x = 0; x < width; x++) {
let makeTrans = false;
if (transColor.length === 1) {
if (transColor[0] === indata[pxPos]) {
makeTrans = true;
}
} else if (
transColor[0] === indata[pxPos] &&
transColor[1] === indata[pxPos + 1] &&
transColor[2] === indata[pxPos + 2]
) {
makeTrans = true;
}
if (makeTrans) {
for (let i = 0; i < 4; i++) {
outdata[pxPos + i] = 0;
}
}
pxPos += 4;
}
}
}
function scaleDepth(indata, outdata, width, height, depth) {
let maxOutSample = 255;
let maxInSample = Math.pow(2, depth) - 1;
let pxPos = 0;
for (let y = 0; y < height; y++) {
for (let x = 0; x < width; x++) {
for (let i = 0; i < 4; i++) {
outdata[pxPos + i] = Math.floor(
(indata[pxPos + i] * maxOutSample) / maxInSample + 0.5
);
}
pxPos += 4;
}
}
}
module.exports = function (indata, imageData) {
let depth = imageData.depth;
let width = imageData.width;
let height = imageData.height;
let colorType = imageData.colorType;
let transColor = imageData.transColor;
let palette = imageData.palette;
let outdata = indata;
if (colorType === 3) {
dePalette(indata, outdata, width, height, palette);
} else {
if (transColor) {
replaceTransparentColor(indata, outdata, width, height, transColor);
}
if (depth !== 8) {
if (depth === 16) {
outdata = Buffer.alloc(width * height * 4);
}
scaleDepth(indata, outdata, width, height, depth);
}
}
return outdata;
};
}).call(this,require("buffer").Buffer);
},{"buffer":28}],11:[function(require,module,exports){
let imagePasses = [
{
x: [0],
y: [0],
},
{
x: [4],
y: [0],
},
{
x: [0, 4],
y: [4],
},
{
x: [2, 6],
y: [0, 4],
},
{
x: [0, 2, 4, 6],
y: [2, 6],
},
{
x: [1, 3, 5, 7],
y: [0, 2, 4, 6],
},
{
x: [0, 1, 2, 3, 4, 5, 6, 7],
y: [1, 3, 5, 7],
},
];
exports.getImagePasses = function (width, height) {
let images = [];
let xLeftOver = width % 8;
let yLeftOver = height % 8;
let xRepeats = (width - xLeftOver) / 8;
let yRepeats = (height - yLeftOver) / 8;
for (let i = 0; i < imagePasses.length; i++) {
let pass = imagePasses[i];
let passWidth = xRepeats * pass.x.length;
let passHeight = yRepeats * pass.y.length;
for (let j = 0; j < pass.x.length; j++) {
if (pass.x[j] < xLeftOver) {
passWidth++;
} else {
break;
}
}
for (let j = 0; j < pass.y.length; j++) {
if (pass.y[j] < yLeftOver) {
passHeight++;
} else {
break;
}
}
if (passWidth > 0 && passHeight > 0) {
images.push({ width: passWidth, height: passHeight, index: i });
}
}
return images;
};
exports.getInterlaceIterator = function (width) {
return function (x, y, pass) {
let outerXLeftOver = x % imagePasses[pass].x.length;
let outerX =
((x - outerXLeftOver) / imagePasses[pass].x.length) * 8 +
imagePasses[pass].x[outerXLeftOver];
let outerYLeftOver = y % imagePasses[pass].y.length;
let outerY =
((y - outerYLeftOver) / imagePasses[pass].y.length) * 8 +
imagePasses[pass].y[outerYLeftOver];
return outerX * 4 + outerY * width * 4;
};
};
},{}],12:[function(require,module,exports){
(function (Buffer){
let util = require("util");
let Stream = require("stream");
let constants = require("./constants");
let Packer = require("./packer");
let PackerAsync = (module.exports = function (opt) {
Stream.call(this);
let options = opt || {};
this._packer = new Packer(options);
this._deflate = this._packer.createDeflate();
this.readable = true;
});
util.inherits(PackerAsync, Stream);
PackerAsync.prototype.pack = function (data, width, height, gamma) {
this.emit("data", Buffer.from(constants.PNG_SIGNATURE));
this.emit("data", this._packer.packIHDR(width, height));
if (gamma) {
this.emit("data", this._packer.packGAMA(gamma));
}
let filteredData = this._packer.filterData(data, width, height);
this._deflate.on("error", this.emit.bind(this, "error"));
this._deflate.on(
"data",
function (compressedData) {
this.emit("data", this._packer.packIDAT(compressedData));
}.bind(this)
);
this._deflate.on(
"end",
function () {
this.emit("data", this._packer.packIEND());
this.emit("end");
}.bind(this)
);
this._deflate.end(filteredData);
};
}).call(this,require("buffer").Buffer);
},{"./constants":4,"./packer":14,"buffer":28,"stream":63,"util":67}],13:[function(require,module,exports){
(function (Buffer){
let hasSyncZlib = true;
let zlib = require("zlib");
if (!zlib.deflateSync) {
hasSyncZlib = false;
}
let constants = require("./constants");
let Packer = require("./packer");
module.exports = function (metaData, opt) {
if (!hasSyncZlib) {
throw new Error(
"To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0"
);
}
let options = opt || {};
let packer = new Packer(options);
let chunks = [];
chunks.push(Buffer.from(constants.PNG_SIGNATURE));
chunks.push(packer.packIHDR(metaData.width, metaData.height));
if (metaData.gamma) {
chunks.push(packer.packGAMA(metaData.gamma));
}
let filteredData = packer.filterData(
metaData.data,
metaData.width,
metaData.height
);
let compressedData = zlib.deflateSync(
filteredData,
packer.getDeflateOptions()
);
filteredData = null;
if (!compressedData || !compressedData.length) {
throw new Error("bad png - invalid compressed data response");
}
chunks.push(packer.packIDAT(compressedData));
chunks.push(packer.packIEND());
return Buffer.concat(chunks);
};
}).call(this,require("buffer").Buffer);
},{"./constants":4,"./packer":14,"buffer":28,"zlib":27}],14:[function(require,module,exports){
(function (Buffer){
let constants = require("./constants");
let CrcStream = require("./crc");
let bitPacker = require("./bitpacker");
let filter = require("./filter-pack");
let zlib = require("zlib");
let Packer = (module.exports = function (options) {
this._options = options;
options.deflateChunkSize = options.deflateChunkSize || 32 * 1024;
options.deflateLevel =
options.deflateLevel != null ? options.deflateLevel : 9;
options.deflateStrategy =
options.deflateStrategy != null ? options.deflateStrategy : 3;
options.inputHasAlpha =
options.inputHasAlpha != null ? options.inputHasAlpha : true;
options.deflateFactory = options.deflateFactory || zlib.createDeflate;
options.bitDepth = options.bitDepth || 8;
options.colorType =
typeof options.colorType === "number"
? options.colorType
: constants.COLORTYPE_COLOR_ALPHA;
options.inputColorType =
typeof options.inputColorType === "number"
? options.inputColorType
: constants.COLORTYPE_COLOR_ALPHA;
if (
[
constants.COLORTYPE_GRAYSCALE,
constants.COLORTYPE_COLOR,
constants.COLORTYPE_COLOR_ALPHA,
constants.COLORTYPE_ALPHA,
].indexOf(options.colorType) === -1
) {
throw new Error(
"option color type:" + options.colorType + " is not supported at present"
);
}
if (
[
constants.COLORTYPE_GRAYSCALE,
constants.COLORTYPE_COLOR,
constants.COLORTYPE_COLOR_ALPHA,
constants.COLORTYPE_ALPHA,
].indexOf(options.inputColorType) === -1
) {
throw new Error(
"option input color type:" +
options.inputColorType +
" is not supported at present"
);
}
if (options.bitDepth !== 8 && options.bitDepth !== 16) {
throw new Error(
"option bit depth:" + options.bitDepth + " is not supported at present"
);
}
});
Packer.prototype.getDeflateOptions = function () {
return {
chunkSize: this._options.deflateChunkSize,
level: this._options.deflateLevel,
strategy: this._options.deflateStrategy,
};
};
Packer.prototype.createDeflate = function () {
return this._options.deflateFactory(this.getDeflateOptions());
};
Packer.prototype.filterData = function (data, width, height) {
let packedData = bitPacker(data, width, height, this._options);
let bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];
let filteredData = filter(packedData, width, height, this._options, bpp);
return filteredData;
};
Packer.prototype._packChunk = function (type, data) {
let len = data ? data.length : 0;
let buf = Buffer.alloc(len + 12);
buf.writeUInt32BE(len, 0);
buf.writeUInt32BE(type, 4);
if (data) {
data.copy(buf, 8);
}
buf.writeInt32BE(
CrcStream.crc32(buf.slice(4, buf.length - 4)),
buf.length - 4
);
return buf;
};
Packer.prototype.packGAMA = function (gamma) {
let buf = Buffer.alloc(4);
buf.writeUInt32BE(Math.floor(gamma * constants.GAMMA_DIVISION), 0);
return this._packChunk(constants.TYPE_gAMA, buf);
};
Packer.prototype.packIHDR = function (width, height) {
let buf = Buffer.alloc(13);
buf.writeUInt32BE(width, 0);
buf.writeUInt32BE(height, 4);
buf[8] = this._options.bitDepth;
buf[9] = this._options.colorType;
buf[10] = 0;
buf[11] = 0;
buf[12] = 0;
return this._packChunk(constants.TYPE_IHDR, buf);
};
Packer.prototype.packIDAT = function (data) {
return this._packChunk(constants.TYPE_IDAT, data);
};
Packer.prototype.packIEND = function () {
return this._packChunk(constants.TYPE_IEND, null);
};
}).call(this,require("buffer").Buffer);
},{"./bitpacker":2,"./constants":4,"./crc":5,"./filter-pack":6,"buffer":28,"zlib":27}],15:[function(require,module,exports){
module.exports = function paethPredictor(left, above, upLeft) {
let paeth = left + above - upLeft;
let pLeft = Math.abs(paeth - left);
let pAbove = Math.abs(paeth - above);
let pUpLeft = Math.abs(paeth - upLeft);
if (pLeft <= pAbove && pLeft <= pUpLeft) {
return left;
}
if (pAbove <= pUpLeft) {
return above;
}
return upLeft;
};
},{}],16:[function(require,module,exports){
let util = require("util");
let zlib = require("zlib");
let ChunkStream = require("./chunkstream");
let FilterAsync = require("./filter-parse-async");
let Parser = require("./parser");
let bitmapper = require("./bitmapper");
let formatNormaliser = require("./format-normaliser");
let ParserAsync = (module.exports = function (options) {
ChunkStream.call(this);
this._parser = new Parser(options, {
read: this.read.bind(this),
error: this._handleError.bind(this),
metadata: this._handleMetaData.bind(this),
gamma: this.emit.bind(this, "gamma"),
palette: this._handlePalette.bind(this),
transColor: this._handleTransColor.bind(this),
finished: this._finished.bind(this),
inflateData: this._inflateData.bind(this),
simpleTransparency: this._simpleTransparency.bind(this),
headersFinished: this._headersFinished.bind(this),
});
this._options = options;
this.writable = true;
this._parser.start();
});
util.inherits(ParserAsync, ChunkStream);
ParserAsync.prototype._handleError = function (err) {
this.emit("error", err);
this.writable = false;
this.destroy();
if (this._inflate && this._inflate.destroy) {
this._inflate.destroy();
}
if (this._filter) {
this._filter.destroy();
this._filter.on("error", function () {});
}
this.errord = true;
};
ParserAsync.prototype._inflateData = function (data) {
if (!this._inflate) {
if (this._bitmapInfo.interlace) {
this._inflate = zlib.createInflate();
this._inflate.on("error", this.emit.bind(this, "error"));
this._filter.on("complete", this._complete.bind(this));
this._inflate.pipe(this._filter);
} else {
let rowSize =
((this._bitmapInfo.width *
this._bitmapInfo.bpp *
this._bitmapInfo.depth +
7) >>
3) +
1;
let imageSize = rowSize * this._bitmapInfo.height;
let chunkSize = Math.max(imageSize, zlib.Z_MIN_CHUNK);
this._inflate = zlib.createInflate({ chunkSize: chunkSize });
let leftToInflate = imageSize;
let emitError = this.emit.bind(this, "error");
this._inflate.on("error", function (err) {
if (!leftToInflate) {
return;
}
emitError(err);
});
this._filter.on("complete", this._complete.bind(this));
let filterWrite = this._filter.write.bind(this._filter);
this._inflate.on("data", function (chunk) {
if (!leftToInflate) {
return;
}
if (chunk.length > leftToInflate) {
chunk = chunk.slice(0, leftToInflate);
}
leftToInflate -= chunk.length;
filterWrite(chunk);
});
this._inflate.on("end", this._filter.end.bind(this._filter));
}
}
this._inflate.write(data);
};
ParserAsync.prototype._handleMetaData = function (metaData) {
this._metaData = metaData;
this._bitmapInfo = Object.create(metaData);
this._filter = new FilterAsync(this._bitmapInfo);
};
ParserAsync.prototype._handleTransColor = function (transColor) {
this._bitmapInfo.transColor = transColor;
};
ParserAsync.prototype._handlePalette = function (palette) {
this._bitmapInfo.palette = palette;
};
ParserAsync.prototype._simpleTransparency = function () {
this._metaData.alpha = true;
};
ParserAsync.prototype._headersFinished = function () {
this.emit("metadata", this._metaData);
};
ParserAsync.prototype._finished = function () {
if (this.errord) {
return;
}
if (!this._inflate) {
this.emit("error", "No Inflate block");
} else {
this._inflate.end();
}
};
ParserAsync.prototype._complete = function (filteredData) {
if (this.errord) {
return;
}
let normalisedBitmapData;
try {
let bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);
normalisedBitmapData = formatNormaliser(bitmapData, this._bitmapInfo);
bitmapData = null;
} catch (ex) {
this._handleError(ex);
return;
}
this.emit("parsed", normalisedBitmapData);
};
},{"./bitmapper":1,"./chunkstream":3,"./filter-parse-async":7,"./format-normaliser":10,"./parser":18,"util":67,"zlib":27}],17:[function(require,module,exports){
(function (Buffer){
let hasSyncZlib = true;
let zlib = require("zlib");
let inflateSync = require("./sync-inflate");
if (!zlib.deflateSync) {
hasSyncZlib = false;
}
let SyncReader = require("./sync-reader");
let FilterSync = require("./filter-parse-sync");
let Parser = require("./parser");
let bitmapper = require("./bitmapper");
let formatNormaliser = require("./format-normaliser");
module.exports = function (buffer, options) {
if (!hasSyncZlib) {
throw new Error(
"To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0"
);
}
let err;
function handleError(_err_) {
err = _err_;
}
let metaData;
function handleMetaData(_metaData_) {
metaData = _metaData_;
}
function handleTransColor(transColor) {
metaData.transColor = transColor;
}
function handlePalette(palette) {
metaData.palette = palette;
}
function handleSimpleTransparency() {
metaData.alpha = true;
}
let gamma;
function handleGamma(_gamma_) {
gamma = _gamma_;
}
let inflateDataList = [];
function handleInflateData(inflatedData) {
inflateDataList.push(inflatedData);
}
let reader = new SyncReader(buffer);
let parser = new Parser(options, {
read: reader.read.bind(reader),
error: handleError,
metadata: handleMetaData,
gamma: handleGamma,
palette: handlePalette,
transColor: handleTransColor,
inflateData: handleInflateData,
simpleTransparency: handleSimpleTransparency,
});
parser.start();
reader.process();
if (err) {
throw err;
}
let inflateData = Buffer.concat(inflateDataList);
inflateDataList.length = 0;
let inflatedData;
if (metaData.interlace) {
inflatedData = zlib.inflateSync(inflateData);
} else {
let rowSize =
((metaData.width * metaData.bpp * metaData.depth + 7) >> 3) + 1;
let imageSize = rowSize * metaData.height;
inflatedData = inflateSync(inflateData, {
chunkSize: imageSize,
maxLength: imageSize,
});
}
inflateData = null;
if (!inflatedData || !inflatedData.length) {
throw new Error("bad png - invalid inflate data response");
}
let unfilteredData = FilterSync.process(inflatedData, metaData);
inflateData = null;
let bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData);
unfilteredData = null;
let normalisedBitmapData = formatNormaliser(bitmapData, metaData);
metaData.data = normalisedBitmapData;
metaData.gamma = gamma || 0;
return metaData;
};
}).call(this,require("buffer").Buffer);
},{"./bitmapper":1,"./filter-parse-sync":8,"./format-normaliser":10,"./parser":18,"./sync-inflate":21,"./sync-reader":22,"buffer":28,"zlib":27}],18:[function(require,module,exports){
(function (Buffer){
let constants = require("./constants");
let CrcCalculator = require("./crc");
let Parser = (module.exports = function (options, dependencies) {
this._options = options;
options.checkCRC = options.checkCRC !== false;
this._hasIHDR = false;
this._hasIEND = false;
this._emittedHeadersFinished = false;
this._palette = [];
this._colorType = 0;
this._chunks = {};
this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this);
this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this);
this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this);
this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this);
this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this);
this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this);
this.read = dependencies.read;
this.error = dependencies.error;
this.metadata = dependencies.metadata;
this.gamma = dependencies.gamma;
this.transColor = dependencies.transColor;
this.palette = dependencies.palette;
this.parsed = dependencies.parsed;
this.inflateData = dependencies.inflateData;
this.finished = dependencies.finished;
this.simpleTransparency = dependencies.simpleTransparency;
this.headersFinished = dependencies.headersFinished || function () {};
});
Parser.prototype.start = function () {
this.read(constants.PNG_SIGNATURE.length, this._parseSignature.bind(this));
};
Parser.prototype._parseSignature = function (data) {
let signature = constants.PNG_SIGNATURE;
for (let i = 0; i < signature.length; i++) {
if (data[i] !== signature[i]) {
this.error(new Error("Invalid file signature"));
return;
}
}
this.read(8, this._parseChunkBegin.bind(this));
};
Parser.prototype._parseChunkBegin = function (data) {
let length = data.readUInt32BE(0);
let type = data.readUInt32BE(4);
let name = "";
for (let i = 4; i < 8; i++) {
name += String.fromCharCode(data[i]);
}
let ancillary = Boolean(data[4] & 0x20);
if (!this._hasIHDR && type !== constants.TYPE_IHDR) {
this.error(new Error("Expected IHDR on beggining"));
return;
}
this._crc = new CrcCalculator();
this._crc.write(Buffer.from(name));
if (this._chunks[type]) {
return this._chunks[type](length);
}
if (!ancillary) {
this.error(new Error("Unsupported critical chunk type " + name));
return;
}
this.read(length + 4, this._skipChunk.bind(this));
};
Parser.prototype._skipChunk = function () {
this.read(8, this._parseChunkBegin.bind(this));
};
Parser.prototype._handleChunkEnd = function () {
this.read(4, this._parseChunkEnd.bind(this));
};
Parser.prototype._parseChunkEnd = function (data) {
let fileCrc = data.readInt32BE(0);
let calcCrc = this._crc.crc32();
if (this._options.checkCRC && calcCrc !== fileCrc) {
this.error(new Error("Crc error - " + fileCrc + " - " + calcCrc));
return;
}
if (!this._hasIEND) {
this.read(8, this._parseChunkBegin.bind(this));
}
};
Parser.prototype._handleIHDR = function (length) {
this.read(length, this._parseIHDR.bind(this));
};
Parser.prototype._parseIHDR = function (data) {
this._crc.write(data);
let width = data.readUInt32BE(0);
let height = data.readUInt32BE(4);
let depth = data[8];
let colorType = data[9];
let compr = data[10];
let filter = data[11];
let interlace = data[12];
if (
depth !== 8 &&
depth !== 4 &&
depth !== 2 &&
depth !== 1 &&
depth !== 16
) {
this.error(new Error("Unsupported bit depth " + depth));
return;
}
if (!(colorType in constants.COLORTYPE_TO_BPP_MAP)) {
this.error(new Error("Unsupported color type"));
return;
}
if (compr !== 0) {
this.error(new Error("Unsupported compression method"));
return;
}
if (filter !== 0) {
this.error(new Error("Unsupported filter method"));
return;
}
if (interlace !== 0 && interlace !== 1) {
this.error(new Error("Unsupported interlace method"));
return;
}
this._colorType = colorType;
let bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];
this._hasIHDR = true;
this.metadata({
width: width,
height: height,
depth: depth,
interlace: Boolean(interlace),
palette: Boolean(colorType & constants.COLORTYPE_PALETTE),
color: Boolean(colorType & constants.COLORTYPE_COLOR),
alpha: Boolean(colorType & constants.COLORTYPE_ALPHA),
bpp: bpp,
colorType: colorType,
});
this._handleChunkEnd();
};
Parser.prototype._handlePLTE = function (length) {
this.read(length, this._parsePLTE.bind(this));
};
Parser.prototype._parsePLTE = function (data) {
this._crc.write(data);
let entries = Math.floor(data.length / 3);
for (let i = 0; i < entries; i++) {
this._palette.push([data[i * 3], data[i * 3 + 1], data[i * 3 + 2], 0xff]);
}
this.palette(this._palette);
this._handleChunkEnd();
};
Parser.prototype._handleTRNS = function (length) {
this.simpleTransparency();
this.read(length, this._parseTRNS.bind(this));
};
Parser.prototype._parseTRNS = function (data) {
this._crc.write(data);
if (this._colorType === constants.COLORTYPE_PALETTE_COLOR) {
if (this._palette.length === 0) {
this.error(new Error("Transparency chunk must be after palette"));
return;
}
if (data.length > this._palette.length) {
this.error(new Error("More transparent colors than palette size"));
return;
}
for (let i = 0; i < data.length; i++) {
this._palette[i][3] = data[i];
}
this.palette(this._palette);
}
if (this._colorType === constants.COLORTYPE_GRAYSCALE) {
this.transColor([data.readUInt16BE(0)]);
}
if (this._colorType === constants.COLORTYPE_COLOR) {
this.transColor([
data.readUInt16BE(0),
data.readUInt16BE(2),
data.readUInt16BE(4),
]);
}
this._handleChunkEnd();
};
Parser.prototype._handleGAMA = function (length) {
this.read(length, this._parseGAMA.bind(this));
};
Parser.prototype._parseGAMA = function (data) {
this._crc.write(data);
this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION);
this._handleChunkEnd();
};
Parser.prototype._handleIDAT = function (length) {
if (!this._emittedHeadersFinished) {
this._emittedHeadersFinished = true;
this.headersFinished();
}
this.read(-length, this._parseIDAT.bind(this, length));
};
Parser.prototype._parseIDAT = function (length, data) {
this._crc.write(data);
if (
this._colorType === constants.COLORTYPE_PALETTE_COLOR &&
this._palette.length === 0
) {
throw new Error("Expected palette not found");
}
this.inflateData(data);
let leftOverLength = length - data.length;
if (leftOverLength > 0) {
this._handleIDAT(leftOverLength);
} else {
this._handleChunkEnd();
}
};
Parser.prototype._handleIEND = function (length) {
this.read(length, this._parseIEND.bind(this));
};
Parser.prototype._parseIEND = function (data) {
this._crc.write(data);
this._hasIEND = true;
this._handleChunkEnd();
if (this.finished) {
this.finished();
}
};
}).call(this,require("buffer").Buffer);
},{"./constants":4,"./crc":5,"buffer":28}],19:[function(require,module,exports){
let parse = require("./parser-sync");
let pack = require("./packer-sync");
exports.read = function (buffer, options) {
return parse(buffer, options || {});
};
exports.write = function (png, options) {
return pack(png, options);
};
},{"./packer-sync":13,"./parser-sync":17}],20:[function(require,module,exports){
(function (process,Buffer){
let util = require("util");
let Stream = require("stream");
let Parser = require("./parser-async");
let Packer = require("./packer-async");
let PNGSync = require("./png-sync");
let PNG = (exports.PNG = function (options) {
Stream.call(this);
options = options || {};
this.width = options.width | 0;
this.height = options.height | 0;
this.data =
this.width > 0 && this.height > 0
? Buffer.alloc(4 * this.width * this.height)
: null;
if (options.fill && this.data) {
this.data.fill(0);
}
this.gamma = 0;
this.readable = this.writable = true;
this._parser = new Parser(options);
this._parser.on("error", this.emit.bind(this, "error"));
this._parser.on("close", this._handleClose.bind(this));
this._parser.on("metadata", this._metadata.bind(this));
this._parser.on("gamma", this._gamma.bind(this));
this._parser.on(
"parsed",
function (data) {
this.data = data;
this.emit("parsed", data);
}.bind(this)
);
this._packer = new Packer(options);
this._packer.on("data", this.emit.bind(this, "data"));
this._packer.on("end", this.emit.bind(this, "end"));
this._parser.on("close", this._handleClose.bind(this));
this._packer.on("error", this.emit.bind(this, "error"));
});
util.inherits(PNG, Stream);
PNG.sync = PNGSync;
PNG.prototype.pack = function () {
if (!this.data || !this.data.length) {
this.emit("error", "No data provided");
return this;
}
process.nextTick(
function () {
this._packer.pack(this.data, this.width, this.height, this.gamma);
}.bind(this)
);
return this;
};
PNG.prototype.parse = function (data, callback) {
if (callback) {
let onParsed, onError;
onParsed = function (parsedData) {
this.removeListener("error", onError);
this.data = parsedData;
callback(null, this);
}.bind(this);
onError = function (err) {
this.removeListener("parsed", onParsed);
callback(err, null);
}.bind(this);
this.once("parsed", onParsed);
this.once("error", onError);
}
this.end(data);
return this;
};
PNG.prototype.write = function (data) {
this._parser.write(data);
return true;
};
PNG.prototype.end = function (data) {
this._parser.end(data);
};
PNG.prototype._metadata = function (metadata) {
this.width = metadata.width;
this.height = metadata.height;
this.emit("metadata", metadata);
};
PNG.prototype._gamma = function (gamma) {
this.gamma = gamma;
};
PNG.prototype._handleClose = function () {
if (!this._parser.writable && !this._packer.readable) {
this.emit("close");
}
};
PNG.bitblt = function (src, dst, srcX, srcY, width, height, deltaX, deltaY) {
srcX |= 0;
srcY |= 0;
width |= 0;
height |= 0;
deltaX |= 0;
deltaY |= 0;
if (
srcX > src.width ||
srcY > src.height ||
srcX + width > src.width ||
srcY + height > src.height
) {
throw new Error("bitblt reading outside image");
}
if (
deltaX > dst.width ||
deltaY > dst.height ||
deltaX + width > dst.width ||
deltaY + height > dst.height
) {
throw new Error("bitblt writing outside image");
}
for (let y = 0; y < height; y++) {
src.data.copy(
dst.data,
((deltaY + y) * dst.width + deltaX) << 2,
((srcY + y) * src.width + srcX) << 2,
((srcY + y) * src.width + srcX + width) << 2
);
}
};
PNG.prototype.bitblt = function (
dst,
srcX,
srcY,
width,
height,
deltaX,
deltaY
) {
PNG.bitblt(this, dst, srcX, srcY, width, height, deltaX, deltaY);
return this;
};
PNG.adjustGamma = function (src) {
if (src.gamma) {
for (let y = 0; y < src.height; y++) {
for (let x = 0; x < src.width; x++) {
let idx = (src.width * y + x) << 2;
for (let i = 0; i < 3; i++) {
let sample = src.data[idx + i] / 255;
sample = Math.pow(sample, 1 / 2.2 / src.gamma);
src.data[idx + i] = Math.round(sample * 255);
}
}
}
src.gamma = 0;
}
};
PNG.prototype.adjustGamma = function () {
PNG.adjustGamma(this);
};
}).call(this,require('_process'),require("buffer").Buffer);
},{"./packer-async":12,"./parser-async":16,"./png-sync":19,"_process":47,"buffer":28,"stream":63,"util":67}],21:[function(require,module,exports){
(function (process,Buffer){
let assert = require("assert").ok;
let zlib = require("zlib");
let util = require("util");
let kMaxLength = require("buffer").kMaxLength;
function Inflate(opts) {
if (!(this instanceof Inflate)) {
return new Inflate(opts);
}
if (opts && opts.chunkSize < zlib.Z_MIN_CHUNK) {
opts.chunkSize = zlib.Z_MIN_CHUNK;
}
zlib.Inflate.call(this, opts);
this._offset = this._offset === undefined ? this._outOffset : this._offset;
this._buffer = this._buffer || this._outBuffer;
if (opts && opts.maxLength != null) {
this._maxLength = opts.maxLength;
}
}
function createInflate(opts) {
return new Inflate(opts);
}
function _close(engine, callback) {
if (callback) {
process.nextTick(callback);
}
if (!engine._handle) {
return;
}
engine._handle.close();
engine._handle = null;
}
Inflate.prototype._processChunk = function (chunk, flushFlag, asyncCb) {
if (typeof asyncCb === "function") {
return zlib.Inflate._processChunk.call(this, chunk, flushFlag, asyncCb);
}
let self = this;
let availInBefore = chunk && chunk.length;
let availOutBefore = this._chunkSize - this._offset;
let leftToInflate = this._maxLength;
let inOff = 0;
let buffers = [];
let nread = 0;
let error;
this.on("error", function (err) {
error = err;
});
function handleChunk(availInAfter, availOutAfter) {
if (self._hadError) {
return;
}
let have = availOutBefore - availOutAfter;
assert(have >= 0, "have should not go down");
if (have > 0) {
let out = self._buffer.slice(self._offset, self._offset + have);
self._offset += have;
if (out.length > leftToInflate) {
out = out.slice(0, leftToInflate);
}
buffers.push(out);
nread += out.length;
leftToInflate -= out.length;
if (leftToInflate === 0) {
return false;
}
}
if (availOutAfter === 0 || self._offset >= self._chunkSize) {
availOutBefore = self._chunkSize;
self._offset = 0;
self._buffer = Buffer.allocUnsafe(self._chunkSize);
}
if (availOutAfter === 0) {
inOff += availInBefore - availInAfter;
availInBefore = availInAfter;
return true;
}
return false;
}
assert(this._handle, "zlib binding closed");
let res;
do {
res = this._handle.writeSync(
flushFlag,
chunk,
inOff,
availInBefore,
this._buffer,
this._offset,
availOutBefore
);
res = res || this._writeState;
} while (!this._hadError && handleChunk(res[0], res[1]));
if (this._hadError) {
throw error;
}
if (nread >= kMaxLength) {
_close(this);
throw new RangeError(
"Cannot create final Buffer. It would be larger than 0x" +
kMaxLength.toString(16) +
" bytes"
);
}
let buf = Buffer.concat(buffers, nread);
_close(this);
return buf;
};
util.inherits(Inflate, zlib.Inflate);
function zlibBufferSync(engine, buffer) {
if (typeof buffer === "string") {
buffer = Buffer.from(buffer);
}
if (!(buffer instanceof Buffer)) {
throw new TypeError("Not a string or buffer");
}
let flushFlag = engine._finishFlushFlag;
if (flushFlag == null) {
flushFlag = zlib.Z_FINISH;
}
return engine._processChunk(buffer, flushFlag);
}
function inflateSync(buffer, opts) {
return zlibBufferSync(new Inflate(opts), buffer);
}
module.exports = exports = inflateSync;
exports.Inflate = Inflate;
exports.createInflate = createInflate;
exports.inflateSync = inflateSync;
}).call(this,require('_process'),require("buffer").Buffer);
},{"_process":47,"assert":23,"buffer":28,"util":67,"zlib":27}],22:[function(require,module,exports){
let SyncReader = (module.exports = function (buffer) {
this._buffer = buffer;
this._reads = [];
});
SyncReader.prototype.read = function (length, callback) {
this._reads.push({
length: Math.abs(length),
allowLess: length < 0,
func: callback,
});
};
SyncReader.prototype.process = function () {
while (this._reads.length > 0 && this._buffer.length) {
let read = this._reads[0];
if (
this._buffer.length &&
(this._buffer.length >= read.length || read.allowLess)
) {
this._reads.shift();
let buf = this._buffer;
this._buffer = buf.slice(read.length);
read.func.call(this, buf.slice(0, read.length));
} else {
break;
}
}
if (this._reads.length > 0) {
return new Error("There are some read requests waitng on finished stream");
}
if (this._buffer.length > 0) {
return new Error("unrecognised content at end of stream");
}
};
},{}],23:[function(require,module,exports){
(function (global){
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <[email protected]> <http://feross.org>
* @license MIT
*/
function compare(a, b) {
if (a === b) {
return 0;
}
var x = a.length;
var y = b.length;
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
if (a[i] !== b[i]) {
x = a[i];
y = b[i];
break;
}
}
if (x < y) {
return -1;
}
if (y < x) {
return 1;
}
return 0;
}
function isBuffer(b) {
if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
return global.Buffer.isBuffer(b);
}
return !!(b != null && b._isBuffer);
}
var util = require('util/');
var hasOwn = Object.prototype.hasOwnProperty;
var pSlice = Array.prototype.slice;
var functionsHaveNames = (function () {
return function foo() {}.name === 'foo';
}());
function pToString (obj) {
return Object.prototype.toString.call(obj);
}
function isView(arrbuf) {
if (isBuffer(arrbuf)) {
return false;
}
if (typeof global.ArrayBuffer !== 'function') {
return false;
}
if (typeof ArrayBuffer.isView === 'function') {
return ArrayBuffer.isView(arrbuf);
}
if (!arrbuf) {
return false;
}
if (arrbuf instanceof DataView) {
return true;
}
if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
return true;
}
return false;
}
var assert = module.exports = ok;
var regex = /\s*function\s+([^\(\s]*)\s*/;
function getName(func) {
if (!util.isFunction(func)) {
return;
}
if (functionsHaveNames) {
return func.name;
}
var str = func.toString();
var match = str.match(regex);
return match && match[1];
}
assert.AssertionError = function AssertionError(options) {
this.name = 'AssertionError';
this.actual = options.actual;
this.expected = options.expected;
this.operator = options.operator;
if (options.message) {
this.message = options.message;
this.generatedMessage = false;
} else {
this.message = getMessage(this);
this.generatedMessage = true;
}
var stackStartFunction = options.stackStartFunction || fail;
if (Error.captureStackTrace) {
Error.captureStackTrace(this, stackStartFunction);
} else {
var err = new Error();
if (err.stack) {
var out = err.stack;
var fn_name = getName(stackStartFunction);
var idx = out.indexOf('\n' + fn_name);
if (idx >= 0) {
var next_line = out.indexOf('\n', idx + 1);
out = out.substring(next_line + 1);
}
this.stack = out;
}
}
};
util.inherits(assert.AssertionError, Error);
function truncate(s, n) {
if (typeof s === 'string') {
return s.length < n ? s : s.slice(0, n);
} else {
return s;
}
}
function inspect(something) {
if (functionsHaveNames || !util.isFunction(something)) {
return util.inspect(something);
}
var rawname = getName(something);
var name = rawname ? ': ' + rawname : '';
return '[Function' + name + ']';
}
function getMessage(self) {
return truncate(inspect(self.actual), 128) + ' ' +
self.operator + ' ' +
truncate(inspect(self.expected), 128);
}
function fail(actual, expected, message, operator, stackStartFunction) {
throw new assert.AssertionError({
message: message,
actual: actual,
expected: expected,
operator: operator,
stackStartFunction: stackStartFunction
});
}
assert.fail = fail;
function ok(value, message) {
if (!value) fail(value, true, message, '==', assert.ok);
}
assert.ok = ok;
assert.equal = function equal(actual, expected, message) {
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
};
assert.notEqual = function notEqual(actual, expected, message) {
if (actual == expected) {
fail(actual, expected, message, '!=', assert.notEqual);
}
};
assert.deepEqual = function deepEqual(actual, expected, message) {
if (!_deepEqual(actual, expected, false)) {
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
}
};
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
if (!_deepEqual(actual, expected, true)) {
fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
}
};
function _deepEqual(actual, expected, strict, memos) {
if (actual === expected) {
return true;
} else if (isBuffer(actual) && isBuffer(expected)) {
return compare(actual, expected) === 0;
} else if (util.isDate(actual) && util.isDate(expected)) {
return actual.getTime() === expected.getTime();
} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
return actual.source === expected.source &&
actual.global === expected.global &&
actual.multiline === expected.multiline &&
actual.lastIndex === expected.lastIndex &&
actual.ignoreCase === expected.ignoreCase;
} else if ((actual === null || typeof actual !== 'object') &&
(expected === null || typeof expected !== 'object')) {
return strict ? actual === expected : actual == expected;
} else if (isView(actual) && isView(expected) &&
pToString(actual) === pToString(expected) &&
!(actual instanceof Float32Array ||
actual instanceof Float64Array)) {
return compare(new Uint8Array(actual.buffer),
new Uint8Array(expected.buffer)) === 0;
} else if (isBuffer(actual) !== isBuffer(expected)) {
return false;
} else {
memos = memos || {actual: [], expected: []};
var actualIndex = memos.actual.indexOf(actual);
if (actualIndex !== -1) {
if (actualIndex === memos.expected.indexOf(expected)) {
return true;
}
}
memos.actual.push(actual);
memos.expected.push(expected);
return objEquiv(actual, expected, strict, memos);
}
}
function isArguments(object) {
return Object.prototype.toString.call(object) == '[object Arguments]';
}
function objEquiv(a, b, strict, actualVisitedObjects) {
if (a === null || a === undefined || b === null || b === undefined)
return false;
if (util.isPrimitive(a) || util.isPrimitive(b))
return a === b;
if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
return false;
var aIsArgs = isArguments(a);
var bIsArgs = isArguments(b);
if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
return false;
if (aIsArgs) {
a = pSlice.call(a);
b = pSlice.call(b);
return _deepEqual(a, b, strict);
}
var ka = objectKeys(a);
var kb = objectKeys(b);
var key, i;
if (ka.length !== kb.length)
return false;
ka.sort();
kb.sort();
for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] !== kb[i])
return false;
}
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
return false;
}
return true;
}
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
if (_deepEqual(actual, expected, false)) {
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
}
};
assert.notDeepStrictEqual = notDeepStrictEqual;
function notDeepStrictEqual(actual, expected, message) {
if (_deepEqual(actual, expected, true)) {
fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
}
}
assert.strictEqual = function strictEqual(actual, expected, message) {
if (actual !== expected) {
fail(actual, expected, message, '===', assert.strictEqual);
}
};
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
if (actual === expected) {
fail(actual, expected, message, '!==', assert.notStrictEqual);
}
};
function expectedException(actual, expected) {
if (!actual || !expected) {
return false;
}
if (Object.prototype.toString.call(expected) == '[object RegExp]') {
return expected.test(actual);
}
try {
if (actual instanceof expected) {
return true;
}
} catch (e) {
}
if (Error.isPrototypeOf(expected)) {
return false;
}
return expected.call({}, actual) === true;
}
function _tryBlock(block) {
var error;
try {
block();
} catch (e) {
error = e;
}
return error;
}
function _throws(shouldThrow, block, expected, message) {
var actual;
if (typeof block !== 'function') {
throw new TypeError('"block" argument must be a function');
}
if (typeof expected === 'string') {
message = expected;
expected = null;
}
actual = _tryBlock(block);
message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
(message ? ' ' + message : '.');
if (shouldThrow && !actual) {
fail(actual, expected, 'Missing expected exception' + message);
}
var userProvidedMessage = typeof message === 'string';
var isUnwantedException = !shouldThrow && util.isError(actual);
var isUnexpectedException = !shouldThrow && actual && !expected;
if ((isUnwantedException &&
userProvidedMessage &&
expectedException(actual, expected)) ||
isUnexpectedException) {
fail(actual, expected, 'Got unwanted exception' + message);
}
if ((shouldThrow && actual && expected &&
!expectedException(actual, expected)) || (!shouldThrow && actual)) {
throw actual;
}
}
assert.throws = function(block, error, message) {
_throws(true, block, error, message);
};
assert.doesNotThrow = function(block, error, message) {
_throws(false, block, error, message);
};
assert.ifError = function(err) { if (err) throw err; };
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) {
if (hasOwn.call(obj, key)) keys.push(key);
}
return keys;
};
}).call(this,typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
},{"util/":67}],24:[function(require,module,exports){
exports.byteLength = byteLength;
exports.toByteArray = toByteArray;
exports.fromByteArray = fromByteArray;
var lookup = [];
var revLookup = [];
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i];
revLookup[code.charCodeAt(i)] = i;
}
revLookup['-'.charCodeAt(0)] = 62;
revLookup['_'.charCodeAt(0)] = 63;
function placeHoldersCount (b64) {
var len = b64.length;
if (len % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
}
function byteLength (b64) {
return (b64.length * 3 / 4) - placeHoldersCount(b64)
}
function toByteArray (b64) {
var i, l, tmp, placeHolders, arr;
var len = b64.length;
placeHolders = placeHoldersCount(b64);
arr = new Arr((len * 3 / 4) - placeHolders);
l = placeHolders > 0 ? len - 4 : len;
var L = 0;
for (i = 0; i < l; i += 4) {
tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)];
arr[L++] = (tmp >> 16) & 0xFF;
arr[L++] = (tmp >> 8) & 0xFF;
arr[L++] = tmp & 0xFF;
}
if (placeHolders === 2) {
tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);
arr[L++] = tmp & 0xFF;
} else if (placeHolders === 1) {
tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2);
arr[L++] = (tmp >> 8) & 0xFF;
arr[L++] = tmp & 0xFF;
}
return arr
}
function tripletToBase64 (num) {
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
}
function encodeChunk (uint8, start, end) {
var tmp;
var output = [];
for (var i = start; i < end; i += 3) {
tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
output.push(tripletToBase64(tmp));
}
return output.join('')
}
function fromByteArray (uint8) {
var tmp;
var len = uint8.length;
var extraBytes = len % 3;
var output = '';
var parts = [];
var maxChunkLength = 16383;
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));
}
if (extraBytes === 1) {
tmp = uint8[len - 1];
output += lookup[tmp >> 2];
output += lookup[(tmp << 4) & 0x3F];
output += '==';
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
output += lookup[tmp >> 10];
output += lookup[(tmp >> 4) & 0x3F];
output += lookup[(tmp << 2) & 0x3F];
output += '=';
}
parts.push(output);
return parts.join('')
}
},{}],25:[function(require,module,exports){
},{}],26:[function(require,module,exports){
(function (process,Buffer){
var assert = require('assert');
var Zstream = require('pako/lib/zlib/zstream');
var zlib_deflate = require('pako/lib/zlib/deflate.js');
var zlib_inflate = require('pako/lib/zlib/inflate.js');
var constants = require('pako/lib/zlib/constants');
for (var key in constants) {
exports[key] = constants[key];
}
exports.NONE = 0;
exports.DEFLATE = 1;
exports.INFLATE = 2;
exports.GZIP = 3;
exports.GUNZIP = 4;
exports.DEFLATERAW = 5;
exports.INFLATERAW = 6;
exports.UNZIP = 7;
var GZIP_HEADER_ID1 = 0x1f;
var GZIP_HEADER_ID2 = 0x8b;
function Zlib(mode) {
if (typeof mode !== 'number' || mode < exports.DEFLATE || mode > exports.UNZIP) {
throw new TypeError('Bad argument');
}
this.dictionary = null;
this.err = 0;
this.flush = 0;
this.init_done = false;
this.level = 0;
this.memLevel = 0;
this.mode = mode;
this.strategy = 0;
this.windowBits = 0;
this.write_in_progress = false;
this.pending_close = false;
this.gzip_id_bytes_read = 0;
}
Zlib.prototype.close = function () {
if (this.write_in_progress) {
this.pending_close = true;
return;
}
this.pending_close = false;
assert(this.init_done, 'close before init');
assert(this.mode <= exports.UNZIP);
if (this.mode === exports.DEFLATE || this.mode === exports.GZIP || this.mode === exports.DEFLATERAW) {
zlib_deflate.deflateEnd(this.strm);
} else if (this.mode === exports.INFLATE || this.mode === exports.GUNZIP || this.mode === exports.INFLATERAW || this.mode === exports.UNZIP) {
zlib_inflate.inflateEnd(this.strm);
}
this.mode = exports.NONE;
this.dictionary = null;
};
Zlib.prototype.write = function (flush, input, in_off, in_len, out, out_off, out_len) {
return this._write(true, flush, input, in_off, in_len, out, out_off, out_len);
};
Zlib.prototype.writeSync = function (flush, input, in_off, in_len, out, out_off, out_len) {
return this._write(false, flush, input, in_off, in_len, out, out_off, out_len);
};
Zlib.prototype._write = function (async, flush, input, in_off, in_len, out, out_off, out_len) {
assert.equal(arguments.length, 8);
assert(this.init_done, 'write before init');
assert(this.mode !== exports.NONE, 'already finalized');
assert.equal(false, this.write_in_progress, 'write already in progress');
assert.equal(false, this.pending_close, 'close is pending');
this.write_in_progress = true;
assert.equal(false, flush === undefined, 'must provide flush value');
this.write_in_progress = true;
if (flush !== exports.Z_NO_FLUSH && flush !== exports.Z_PARTIAL_FLUSH && flush !== exports.Z_SYNC_FLUSH && flush !== exports.Z_FULL_FLUSH && flush !== exports.Z_FINISH && flush !== exports.Z_BLOCK) {
throw new Error('Invalid flush value');
}
if (input == null) {
input = Buffer.alloc(0);
in_len = 0;
in_off = 0;
}
this.strm.avail_in = in_len;
this.strm.input = input;
this.strm.next_in = in_off;
this.strm.avail_out = out_len;
this.strm.output = out;
this.strm.next_out = out_off;
this.flush = flush;
if (!async) {
this._process();
if (this._checkError()) {
return this._afterSync();
}
return;
}
var self = this;
process.nextTick(function () {
self._process();
self._after();
});
return this;
};
Zlib.prototype._afterSync = function () {
var avail_out = this.strm.avail_out;
var avail_in = this.strm.avail_in;
this.write_in_progress = false;
return [avail_in, avail_out];
};
Zlib.prototype._process = function () {
var next_expected_header_byte = null;
switch (this.mode) {
case exports.DEFLATE:
case exports.GZIP:
case exports.DEFLATERAW:
this.err = zlib_deflate.deflate(this.strm, this.flush);
break;
case exports.UNZIP:
if (this.strm.avail_in > 0) {
next_expected_header_byte = this.strm.next_in;
}
switch (this.gzip_id_bytes_read) {
case 0:
if (next_expected_header_byte === null) {
break;
}
if (this.strm.input[next_expected_header_byte] === GZIP_HEADER_ID1) {
this.gzip_id_bytes_read = 1;
next_expected_header_byte++;
if (this.strm.avail_in === 1) {
break;
}
} else {
this.mode = exports.INFLATE;
break;
}
case 1:
if (next_expected_header_byte === null) {
break;
}
if (this.strm.input[next_expected_header_byte] === GZIP_HEADER_ID2) {
this.gzip_id_bytes_read = 2;
this.mode = exports.GUNZIP;
} else {
this.mode = exports.INFLATE;
}
break;
default:
throw new Error('invalid number of gzip magic number bytes read');
}
case exports.INFLATE:
case exports.GUNZIP:
case exports.INFLATERAW:
this.err = zlib_inflate.inflate(this.strm, this.flush
);if (this.err === exports.Z_NEED_DICT && this.dictionary) {
this.err = zlib_inflate.inflateSetDictionary(this.strm, this.dictionary);
if (this.err === exports.Z_OK) {
this.err = zlib_inflate.inflate(this.strm, this.flush);
} else if (this.err === exports.Z_DATA_ERROR) {
this.err = exports.Z_NEED_DICT;
}
}
while (this.strm.avail_in > 0 && this.mode === exports.GUNZIP && this.err === exports.Z_STREAM_END && this.strm.next_in[0] !== 0x00) {
this.reset();
this.err = zlib_inflate.inflate(this.strm, this.flush);
}
break;
default:
throw new Error('Unknown mode ' + this.mode);
}
};
Zlib.prototype._checkError = function () {
switch (this.err) {
case exports.Z_OK:
case exports.Z_BUF_ERROR:
if (this.strm.avail_out !== 0 && this.flush === exports.Z_FINISH) {
this._error('unexpected end of file');
return false;
}
break;
case exports.Z_STREAM_END:
break;
case exports.Z_NEED_DICT:
if (this.dictionary == null) {
this._error('Missing dictionary');
} else {
this._error('Bad dictionary');
}
return false;
default:
this._error('Zlib error');
return false;
}
return true;
};
Zlib.prototype._after = function () {
if (!this._checkError()) {
return;
}
var avail_out = this.strm.avail_out;
var avail_in = this.strm.avail_in;
this.write_in_progress = false;
this.callback(avail_in, avail_out);
if (this.pending_close) {
this.close();
}
};
Zlib.prototype._error = function (message) {
if (this.strm.msg) {
message = this.strm.msg;
}
this.onerror(message, this.err
);this.write_in_progress = false;
if (this.pending_close) {
this.close();
}
};
Zlib.prototype.init = function (windowBits, level, memLevel, strategy, dictionary) {
assert(arguments.length === 4 || arguments.length === 5, 'init(windowBits, level, memLevel, strategy, [dictionary])');
assert(windowBits >= 8 && windowBits <= 15, 'invalid windowBits');
assert(level >= -1 && level <= 9, 'invalid compression level');
assert(memLevel >= 1 && memLevel <= 9, 'invalid memlevel');
assert(strategy === exports.Z_FILTERED || strategy === exports.Z_HUFFMAN_ONLY || strategy === exports.Z_RLE || strategy === exports.Z_FIXED || strategy === exports.Z_DEFAULT_STRATEGY, 'invalid strategy');
this._init(level, windowBits, memLevel, strategy, dictionary);
this._setDictionary();
};
Zlib.prototype.params = function () {
throw new Error('deflateParams Not supported');
};
Zlib.prototype.reset = function () {
this._reset();
this._setDictionary();
};
Zlib.prototype._init = function (level, windowBits, memLevel, strategy, dictionary) {
this.level = level;
this.windowBits = windowBits;
this.memLevel = memLevel;
this.strategy = strategy;
this.flush = exports.Z_NO_FLUSH;
this.err = exports.Z_OK;
if (this.mode === exports.GZIP || this.mode === exports.GUNZIP) {
this.windowBits += 16;
}
if (this.mode === exports.UNZIP) {
this.windowBits += 32;
}
if (this.mode === exports.DEFLATERAW || this.mode === exports.INFLATERAW) {
this.windowBits = -1 * this.windowBits;
}
this.strm = new Zstream();
switch (this.mode) {
case exports.DEFLATE:
case exports.GZIP:
case exports.DEFLATERAW:
this.err = zlib_deflate.deflateInit2(this.strm, this.level, exports.Z_DEFLATED, this.windowBits, this.memLevel, this.strategy);
break;
case exports.INFLATE:
case exports.GUNZIP:
case exports.INFLATERAW:
case exports.UNZIP:
this.err = zlib_inflate.inflateInit2(this.strm, this.windowBits);
break;
default:
throw new Error('Unknown mode ' + this.mode);
}
if (this.err !== exports.Z_OK) {
this._error('Init error');
}
this.dictionary = dictionary;
this.write_in_progress = false;
this.init_done = true;
};
Zlib.prototype._setDictionary = function () {
if (this.dictionary == null) {
return;
}
this.err = exports.Z_OK;
switch (this.mode) {
case exports.DEFLATE:
case exports.DEFLATERAW:
this.err = zlib_deflate.deflateSetDictionary(this.strm, this.dictionary);
break;
}
if (this.err !== exports.Z_OK) {
this._error('Failed to set dictionary');
}
};
Zlib.prototype._reset = function () {
this.err = exports.Z_OK;
switch (this.mode) {
case exports.DEFLATE:
case exports.DEFLATERAW:
case exports.GZIP:
this.err = zlib_deflate.deflateReset(this.strm);
break;
case exports.INFLATE:
case exports.INFLATERAW:
case exports.GUNZIP:
this.err = zlib_inflate.inflateReset(this.strm);
break;
}
if (this.err !== exports.Z_OK) {
this._error('Failed to reset stream');
}
};
exports.Zlib = Zlib;
}).call(this,require('_process'),require("buffer").Buffer);
},{"_process":47,"assert":23,"buffer":28,"pako/lib/zlib/constants":37,"pako/lib/zlib/deflate.js":39,"pako/lib/zlib/inflate.js":41,"pako/lib/zlib/zstream":45}],27:[function(require,module,exports){
(function (process){
var Buffer = require('buffer').Buffer;
var Transform = require('stream').Transform;
var binding = require('./binding');
var util = require('util');
var assert = require('assert').ok;
var kMaxLength = require('buffer').kMaxLength;
var kRangeErrorMessage = 'Cannot create final Buffer. It would be larger ' + 'than 0x' + kMaxLength.toString(16) + ' bytes';
binding.Z_MIN_WINDOWBITS = 8;
binding.Z_MAX_WINDOWBITS = 15;
binding.Z_DEFAULT_WINDOWBITS = 15;
binding.Z_MIN_CHUNK = 64;
binding.Z_MAX_CHUNK = Infinity;
binding.Z_DEFAULT_CHUNK = 16 * 1024;
binding.Z_MIN_MEMLEVEL = 1;
binding.Z_MAX_MEMLEVEL = 9;
binding.Z_DEFAULT_MEMLEVEL = 8;
binding.Z_MIN_LEVEL = -1;
binding.Z_MAX_LEVEL = 9;
binding.Z_DEFAULT_LEVEL = binding.Z_DEFAULT_COMPRESSION;
var bkeys = Object.keys(binding);
for (var bk = 0; bk < bkeys.length; bk++) {
var bkey = bkeys[bk];
if (bkey.match(/^Z/)) {
Object.defineProperty(exports, bkey, {
enumerable: true, value: binding[bkey], writable: false
});
}
}
var codes = {
Z_OK: binding.Z_OK,
Z_STREAM_END: binding.Z_STREAM_END,
Z_NEED_DICT: binding.Z_NEED_DICT,
Z_ERRNO: binding.Z_ERRNO,
Z_STREAM_ERROR: binding.Z_STREAM_ERROR,
Z_DATA_ERROR: binding.Z_DATA_ERROR,
Z_MEM_ERROR: binding.Z_MEM_ERROR,
Z_BUF_ERROR: binding.Z_BUF_ERROR,
Z_VERSION_ERROR: binding.Z_VERSION_ERROR
};
var ckeys = Object.keys(codes);
for (var ck = 0; ck < ckeys.length; ck++) {
var ckey = ckeys[ck];
codes[codes[ckey]] = ckey;
}
Object.defineProperty(exports, 'codes', {
enumerable: true, value: Object.freeze(codes), writable: false
});
exports.Deflate = Deflate;
exports.Inflate = Inflate;
exports.Gzip = Gzip;
exports.Gunzip = Gunzip;
exports.DeflateRaw = DeflateRaw;
exports.InflateRaw = InflateRaw;
exports.Unzip = Unzip;
exports.createDeflate = function (o) {
return new Deflate(o);
};
exports.createInflate = function (o) {
return new Inflate(o);
};
exports.createDeflateRaw = function (o) {
return new DeflateRaw(o);
};
exports.createInflateRaw = function (o) {
return new InflateRaw(o);
};
exports.createGzip = function (o) {
return new Gzip(o);
};
exports.createGunzip = function (o) {
return new Gunzip(o);
};
exports.createUnzip = function (o) {
return new Unzip(o);
};
exports.deflate = function (buffer, opts, callback) {
if (typeof opts === 'function') {
callback = opts;
opts = {};
}
return zlibBuffer(new Deflate(opts), buffer, callback);
};
exports.deflateSync = function (buffer, opts) {
return zlibBufferSync(new Deflate(opts), buffer);
};
exports.gzip = function (buffer, opts, callback) {
if (typeof opts === 'function') {
callback = opts;
opts = {};
}
return zlibBuffer(new Gzip(opts), buffer, callback);
};
exports.gzipSync = function (buffer, opts) {
return zlibBufferSync(new Gzip(opts), buffer);
};
exports.deflateRaw = function (buffer, opts, callback) {
if (typeof opts === 'function') {
callback = opts;
opts = {};
}
return zlibBuffer(new DeflateRaw(opts), buffer, callback);
};
exports.deflateRawSync = function (buffer, opts) {
return zlibBufferSync(new DeflateRaw(opts), buffer);
};
exports.unzip = function (buffer, opts, callback) {
if (typeof opts === 'function') {
callback = opts;
opts = {};
}
return zlibBuffer(new Unzip(opts), buffer, callback);
};
exports.unzipSync = function (buffer, opts) {
return zlibBufferSync(new Unzip(opts), buffer);
};
exports.inflate = function (buffer, opts, callback) {
if (typeof opts === 'function') {
callback = opts;
opts = {};
}
return zlibBuffer(new Inflate(opts), buffer, callback);
};
exports.inflateSync = function (buffer, opts) {
return zlibBufferSync(new Inflate(opts), buffer);
};
exports.gunzip = function (buffer, opts, callback) {
if (typeof opts === 'function') {
callback = opts;
opts = {};
}
return zlibBuffer(new Gunzip(opts), buffer, callback);
};
exports.gunzipSync = function (buffer, opts) {
return zlibBufferSync(new Gunzip(opts), buffer);
};
exports.inflateRaw = function (buffer, opts, callback) {
if (typeof opts === 'function') {
callback = opts;
opts = {};
}
return zlibBuffer(new InflateRaw(opts), buffer, callback);
};
exports.inflateRawSync = function (buffer, opts) {
return zlibBufferSync(new InflateRaw(opts), buffer);
};
function zlibBuffer(engine, buffer, callback) {
var buffers = [];
var nread = 0;
engine.on('error', onError);
engine.on('end', onEnd);
engine.end(buffer);
flow();
function flow() {
var chunk;
while (null !== (chunk = engine.read())) {
buffers.push(chunk);
nread += chunk.length;
}
engine.once('readable', flow);
}
function onError(err) {
engine.removeListener('end', onEnd);
engine.removeListener('readable', flow);
callback(err);
}
function onEnd() {
var buf;
var err = null;
if (nread >= kMaxLength) {
err = new RangeError(kRangeErrorMessage);
} else {
buf = Buffer.concat(buffers, nread);
}
buffers = [];
engine.close();
callback(err, buf);
}
}
function zlibBufferSync(engine, buffer) {
if (typeof buffer === 'string') buffer = Buffer.from(buffer);
if (!Buffer.isBuffer(buffer)) throw new TypeError('Not a string or buffer');
var flushFlag = engine._finishFlushFlag;
return engine._processChunk(buffer, flushFlag);
}
function Deflate(opts) {
if (!(this instanceof Deflate)) return new Deflate(opts);
Zlib.call(this, opts, binding.DEFLATE);
}
function Inflate(opts) {
if (!(this instanceof Inflate)) return new Inflate(opts);
Zlib.call(this, opts, binding.INFLATE);
}
function Gzip(opts) {
if (!(this instanceof Gzip)) return new Gzip(opts);
Zlib.call(this, opts, binding.GZIP);
}
function Gunzip(opts) {
if (!(this instanceof Gunzip)) return new Gunzip(opts);
Zlib.call(this, opts, binding.GUNZIP);
}
function DeflateRaw(opts) {
if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
Zlib.call(this, opts, binding.DEFLATERAW);
}
function InflateRaw(opts) {
if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
Zlib.call(this, opts, binding.INFLATERAW);
}
function Unzip(opts) {
if (!(this instanceof Unzip)) return new Unzip(opts);
Zlib.call(this, opts, binding.UNZIP);
}
function isValidFlushFlag(flag) {
return flag === binding.Z_NO_FLUSH || flag === binding.Z_PARTIAL_FLUSH || flag === binding.Z_SYNC_FLUSH || flag === binding.Z_FULL_FLUSH || flag === binding.Z_FINISH || flag === binding.Z_BLOCK;
}
function Zlib(opts, mode) {
var _this = this;
this._opts = opts = opts || {};
this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK;
Transform.call(this, opts);
if (opts.flush && !isValidFlushFlag(opts.flush)) {
throw new Error('Invalid flush flag: ' + opts.flush);
}
if (opts.finishFlush && !isValidFlushFlag(opts.finishFlush)) {
throw new Error('Invalid flush flag: ' + opts.finishFlush);
}
this._flushFlag = opts.flush || binding.Z_NO_FLUSH;
this._finishFlushFlag = typeof opts.finishFlush !== 'undefined' ? opts.finishFlush : binding.Z_FINISH;
if (opts.chunkSize) {
if (opts.chunkSize < exports.Z_MIN_CHUNK || opts.chunkSize > exports.Z_MAX_CHUNK) {
throw new Error('Invalid chunk size: ' + opts.chunkSize);
}
}
if (opts.windowBits) {
if (opts.windowBits < exports.Z_MIN_WINDOWBITS || opts.windowBits > exports.Z_MAX_WINDOWBITS) {
throw new Error('Invalid windowBits: ' + opts.windowBits);
}
}
if (opts.level) {
if (opts.level < exports.Z_MIN_LEVEL || opts.level > exports.Z_MAX_LEVEL) {
throw new Error('Invalid compression level: ' + opts.level);
}
}
if (opts.memLevel) {
if (opts.memLevel < exports.Z_MIN_MEMLEVEL || opts.memLevel > exports.Z_MAX_MEMLEVEL) {
throw new Error('Invalid memLevel: ' + opts.memLevel);
}
}
if (opts.strategy) {
if (opts.strategy != exports.Z_FILTERED && opts.strategy != exports.Z_HUFFMAN_ONLY && opts.strategy != exports.Z_RLE && opts.strategy != exports.Z_FIXED && opts.strategy != exports.Z_DEFAULT_STRATEGY) {
throw new Error('Invalid strategy: ' + opts.strategy);
}
}
if (opts.dictionary) {
if (!Buffer.isBuffer(opts.dictionary)) {
throw new Error('Invalid dictionary: it should be a Buffer instance');
}
}
this._handle = new binding.Zlib(mode);
var self = this;
this._hadError = false;
this._handle.onerror = function (message, errno) {
_close(self);
self._hadError = true;
var error = new Error(message);
error.errno = errno;
error.code = exports.codes[errno];
self.emit('error', error);
};
var level = exports.Z_DEFAULT_COMPRESSION;
if (typeof opts.level === 'number') level = opts.level;
var strategy = exports.Z_DEFAULT_STRATEGY;
if (typeof opts.strategy === 'number') strategy = opts.strategy;
this._handle.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS, level, opts.memLevel || exports.Z_DEFAULT_MEMLEVEL, strategy, opts.dictionary);
this._buffer = Buffer.allocUnsafe(this._chunkSize);
this._offset = 0;
this._level = level;
this._strategy = strategy;
this.once('end', this.close);
Object.defineProperty(this, '_closed', {
get: function () {
return !_this._handle;
},
configurable: true,
enumerable: true
});
}
util.inherits(Zlib, Transform);
Zlib.prototype.params = function (level, strategy, callback) {
if (level < exports.Z_MIN_LEVEL || level > exports.Z_MAX_LEVEL) {
throw new RangeError('Invalid compression level: ' + level);
}
if (strategy != exports.Z_FILTERED && strategy != exports.Z_HUFFMAN_ONLY && strategy != exports.Z_RLE && strategy != exports.Z_FIXED && strategy != exports.Z_DEFAULT_STRATEGY) {
throw new TypeError('Invalid strategy: ' + strategy);
}
if (this._level !== level || this._strategy !== strategy) {
var self = this;
this.flush(binding.Z_SYNC_FLUSH, function () {
assert(self._handle, 'zlib binding closed');
self._handle.params(level, strategy);
if (!self._hadError) {
self._level = level;
self._strategy = strategy;
if (callback) callback();
}
});
} else {
process.nextTick(callback);
}
};
Zlib.prototype.reset = function () {
assert(this._handle, 'zlib binding closed');
return this._handle.reset();
};
Zlib.prototype._flush = function (callback) {
this._transform(Buffer.alloc(0), '', callback);
};
Zlib.prototype.flush = function (kind, callback) {
var _this2 = this;
var ws = this._writableState;
if (typeof kind === 'function' || kind === undefined && !callback) {
callback = kind;
kind = binding.Z_FULL_FLUSH;
}
if (ws.ended) {
if (callback) process.nextTick(callback);
} else if (ws.ending) {
if (callback) this.once('end', callback);
} else if (ws.needDrain) {
if (callback) {
this.once('drain', function () {
return _this2.flush(kind, callback);
});
}
} else {
this._flushFlag = kind;
this.write(Buffer.alloc(0), '', callback);
}
};
Zlib.prototype.close = function (callback) {
_close(this, callback);
process.nextTick(emitCloseNT, this);
};
function _close(engine, callback) {
if (callback) process.nextTick(callback);
if (!engine._handle) return;
engine._handle.close();
engine._handle = null;
}
function emitCloseNT(self) {
self.emit('close');
}
Zlib.prototype._transform = function (chunk, encoding, cb) {
var flushFlag;
var ws = this._writableState;
var ending = ws.ending || ws.ended;
var last = ending && (!chunk || ws.length === chunk.length);
if (chunk !== null && !Buffer.isBuffer(chunk)) return cb(new Error('invalid input'));
if (!this._handle) return cb(new Error('zlib binding closed'));
if (last) flushFlag = this._finishFlushFlag;else {
flushFlag = this._flushFlag;
if (chunk.length >= ws.length) {
this._flushFlag = this._opts.flush || binding.Z_NO_FLUSH;
}
}
this._processChunk(chunk, flushFlag, cb);
};
Zlib.prototype._processChunk = function (chunk, flushFlag, cb) {
var availInBefore = chunk && chunk.length;
var availOutBefore = this._chunkSize - this._offset;
var inOff = 0;
var self = this;
var async = typeof cb === 'function';
if (!async) {
var buffers = [];
var nread = 0;
var error;
this.on('error', function (er) {
error = er;
});
assert(this._handle, 'zlib binding closed');
do {
var res = this._handle.writeSync(flushFlag, chunk,
inOff,
availInBefore,
this._buffer,
this._offset,
availOutBefore);
} while (!this._hadError && callback(res[0], res[1]));
if (this._hadError) {
throw error;
}
if (nread >= kMaxLength) {
_close(this);
throw new RangeError(kRangeErrorMessage);
}
var buf = Buffer.concat(buffers, nread);
_close(this);
return buf;
}
assert(this._handle, 'zlib binding closed');
var req = this._handle.write(flushFlag, chunk,
inOff,
availInBefore,
this._buffer,
this._offset,
availOutBefore);
req.buffer = chunk;
req.callback = callback;
function callback(availInAfter, availOutAfter) {
if (this) {
this.buffer = null;
this.callback = null;
}
if (self._hadError) return;
var have = availOutBefore - availOutAfter;
assert(have >= 0, 'have should not go down');
if (have > 0) {
var out = self._buffer.slice(self._offset, self._offset + have);
self._offset += have;
if (async) {
self.push(out);
} else {
buffers.push(out);
nread += out.length;
}
}
if (availOutAfter === 0 || self._offset >= self._chunkSize) {
availOutBefore = self._chunkSize;
self._offset = 0;
self._buffer = Buffer.allocUnsafe(self._chunkSize);
}
if (availOutAfter === 0) {
inOff += availInBefore - availInAfter;
availInBefore = availInAfter;
if (!async) return true;
var newReq = self._handle.write(flushFlag, chunk, inOff, availInBefore, self._buffer, self._offset, self._chunkSize);
newReq.callback = callback;
newReq.buffer = chunk;
return;
}
if (!async) return false;
cb();
}
};
util.inherits(Deflate, Zlib);
util.inherits(Inflate, Zlib);
util.inherits(Gzip, Zlib);
util.inherits(Gunzip, Zlib);
util.inherits(DeflateRaw, Zlib);
util.inherits(InflateRaw, Zlib);
util.inherits(Unzip, Zlib);
}).call(this,require('_process'));
},{"./binding":26,"_process":47,"assert":23,"buffer":28,"stream":63,"util":67}],28:[function(require,module,exports){
var base64 = require('base64-js');
var ieee754 = require('ieee754');
exports.Buffer = Buffer;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
var K_MAX_LENGTH = 0x7fffffff;
exports.kMaxLength = K_MAX_LENGTH;
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
typeof console.error === 'function') {
console.error(
'This browser lacks typed array (Uint8Array) support which is required by ' +
'`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
);
}
function typedArraySupport () {
try {
var arr = new Uint8Array(1);
arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } };
return arr.foo() === 42
} catch (e) {
return false
}
}
Object.defineProperty(Buffer.prototype, 'parent', {
enumerable: true,
get: function () {
if (!Buffer.isBuffer(this)) return undefined
return this.buffer
}
});
Object.defineProperty(Buffer.prototype, 'offset', {
enumerable: true,
get: function () {
if (!Buffer.isBuffer(this)) return undefined
return this.byteOffset
}
});
function createBuffer (length) {
if (length > K_MAX_LENGTH) {
throw new RangeError('The value "' + length + '" is invalid for option "size"')
}
var buf = new Uint8Array(length);
buf.__proto__ = Buffer.prototype;
return buf
}
function Buffer (arg, encodingOrOffset, length) {
if (typeof arg === 'number') {
if (typeof encodingOrOffset === 'string') {
throw new TypeError(
'The "string" argument must be of type string. Received type number'
)
}
return allocUnsafe(arg)
}
return from(arg, encodingOrOffset, length)
}
if (typeof Symbol !== 'undefined' && Symbol.species != null &&
Buffer[Symbol.species] === Buffer) {
Object.defineProperty(Buffer, Symbol.species, {
value: null,
configurable: true,
enumerable: false,
writable: false
});
}
Buffer.poolSize = 8192;
function from (value, encodingOrOffset, length) {
if (typeof value === 'string') {
return fromString(value, encodingOrOffset)
}
if (ArrayBuffer.isView(value)) {
return fromArrayLike(value)
}
if (value == null) {
throw TypeError(
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
'or Array-like Object. Received type ' + (typeof value)
)
}
if (isInstance(value, ArrayBuffer) ||
(value && isInstance(value.buffer, ArrayBuffer))) {
return fromArrayBuffer(value, encodingOrOffset, length)
}
if (typeof value === 'number') {
throw new TypeError(
'The "value" argument must not be of type number. Received type number'
)
}
var valueOf = value.valueOf && value.valueOf();
if (valueOf != null && valueOf !== value) {
return Buffer.from(valueOf, encodingOrOffset, length)
}
var b = fromObject(value);
if (b) return b
if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
typeof value[Symbol.toPrimitive] === 'function') {
return Buffer.from(
value[Symbol.toPrimitive]('string'), encodingOrOffset, length
)
}
throw new TypeError(
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
'or Array-like Object. Received type ' + (typeof value)
)
}
Buffer.from = function (value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length)
};
Buffer.prototype.__proto__ = Uint8Array.prototype;
Buffer.__proto__ = Uint8Array;
function assertSize (size) {
if (typeof size !== 'number') {
throw new TypeError('"size" argument must be of type number')
} else if (size < 0) {
throw new RangeError('The value "' + size + '" is invalid for option "size"')
}
}
function alloc (size, fill, encoding) {
assertSize(size);
if (size <= 0) {
return createBuffer(size)
}
if (fill !== undefined) {
return typeof encoding === 'string'
? createBuffer(size).fill(fill, encoding)
: createBuffer(size).fill(fill)
}
return createBuffer(size)
}
Buffer.alloc = function (size, fill, encoding) {
return alloc(size, fill, encoding)
};
function allocUnsafe (size) {
assertSize(size);
return createBuffer(size < 0 ? 0 : checked(size) | 0)
}
Buffer.allocUnsafe = function (size) {
return allocUnsafe(size)
};
Buffer.allocUnsafeSlow = function (size) {
return allocUnsafe(size)
};
function fromString (string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
encoding = 'utf8';
}
if (!Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
var length = byteLength(string, encoding) | 0;
var buf = createBuffer(length);
var actual = buf.write(string, encoding);
if (actual !== length) {
buf = buf.slice(0, actual);
}
return buf
}
function fromArrayLike (array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0;
var buf = createBuffer(length);
for (var i = 0; i < length; i += 1) {
buf[i] = array[i] & 255;
}
return buf
}
function fromArrayBuffer (array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('"offset" is outside of buffer bounds')
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('"length" is outside of buffer bounds')
}
var buf;
if (byteOffset === undefined && length === undefined) {
buf = new Uint8Array(array);
} else if (length === undefined) {
buf = new Uint8Array(array, byteOffset);
} else {
buf = new Uint8Array(array, byteOffset, length);
}
buf.__proto__ = Buffer.prototype;
return buf
}
function fromObject (obj) {
if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0;
var buf = createBuffer(len);
if (buf.length === 0) {
return buf
}
obj.copy(buf, 0, 0, len);
return buf
}
if (obj.length !== undefined) {
if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
return createBuffer(0)
}
return fromArrayLike(obj)
}
if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
return fromArrayLike(obj.data)
}
}
function checked (length) {
if (length >= K_MAX_LENGTH) {
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
}
return length | 0
}
function SlowBuffer (length) {
if (+length != length) {
length = 0;
}
return Buffer.alloc(+length)
}
Buffer.isBuffer = function isBuffer (b) {
return b != null && b._isBuffer === true &&
b !== Buffer.prototype
};
Buffer.compare = function compare (a, b) {
if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
throw new TypeError(
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
)
}
if (a === b) return 0
var x = a.length;
var y = b.length;
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
if (a[i] !== b[i]) {
x = a[i];
y = b[i];
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
};
Buffer.isEncoding = function isEncoding (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'latin1':
case 'binary':
case 'base64':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
};
Buffer.concat = function concat (list, length) {
if (!Array.isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
if (list.length === 0) {
return Buffer.alloc(0)
}
var i;
if (length === undefined) {
length = 0;
for (i = 0; i < list.length; ++i) {
length += list[i].length;
}
}
var buffer = Buffer.allocUnsafe(length);
var pos = 0;
for (i = 0; i < list.length; ++i) {
var buf = list[i];
if (isInstance(buf, Uint8Array)) {
buf = Buffer.from(buf);
}
if (!Buffer.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
buf.copy(buffer, pos);
pos += buf.length;
}
return buffer
};
function byteLength (string, encoding) {
if (Buffer.isBuffer(string)) {
return string.length
}
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
return string.byteLength
}
if (typeof string !== 'string') {
throw new TypeError(
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
'Received type ' + typeof string
)
}
var len = string.length;
var mustMatch = (arguments.length > 2 && arguments[2] === true);
if (!mustMatch && len === 0) return 0
var loweredCase = false;
for (;;) {
switch (encoding) {
case 'ascii':
case 'latin1':
case 'binary':
return len
case 'utf8':
case 'utf-8':
return utf8ToBytes(string).length
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return len * 2
case 'hex':
return len >>> 1
case 'base64':
return base64ToBytes(string).length
default:
if (loweredCase) {
return mustMatch ? -1 : utf8ToBytes(string).length
}
encoding = ('' + encoding).toLowerCase();
loweredCase = true;
}
}
}
Buffer.byteLength = byteLength;
function slowToString (encoding, start, end) {
var loweredCase = false;
if (start === undefined || start < 0) {
start = 0;
}
if (start > this.length) {
return ''
}
if (end === undefined || end > this.length) {
end = this.length;
}
if (end <= 0) {
return ''
}
end >>>= 0;
start >>>= 0;
if (end <= start) {
return ''
}
if (!encoding) encoding = 'utf8';
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'latin1':
case 'binary':
return latin1Slice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase();
loweredCase = true;
}
}
}
Buffer.prototype._isBuffer = true;
function swap (b, n, m) {
var i = b[n];
b[n] = b[m];
b[m] = i;
}
Buffer.prototype.swap16 = function swap16 () {
var len = this.length;
if (len % 2 !== 0) {
throw new RangeError('Buffer size must be a multiple of 16-bits')
}
for (var i = 0; i < len; i += 2) {
swap(this, i, i + 1);
}
return this
};
Buffer.prototype.swap32 = function swap32 () {
var len = this.length;
if (len % 4 !== 0) {
throw new RangeError('Buffer size must be a multiple of 32-bits')
}
for (var i = 0; i < len; i += 4) {
swap(this, i, i + 3);
swap(this, i + 1, i + 2);
}
return this
};
Buffer.prototype.swap64 = function swap64 () {
var len = this.length;
if (len % 8 !== 0) {
throw new RangeError('Buffer size must be a multiple of 64-bits')
}
for (var i = 0; i < len; i += 8) {
swap(this, i, i + 7);
swap(this, i + 1, i + 6);
swap(this, i + 2, i + 5);
swap(this, i + 3, i + 4);
}
return this
};
Buffer.prototype.toString = function toString () {
var length = this.length;
if (length === 0) return ''
if (arguments.length === 0) return utf8Slice(this, 0, length)
return slowToString.apply(this, arguments)
};
Buffer.prototype.toLocaleString = Buffer.prototype.toString;
Buffer.prototype.equals = function equals (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
};
Buffer.prototype.inspect = function inspect () {
var str = '';
var max = exports.INSPECT_MAX_BYTES;
str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim();
if (this.length > max) str += ' ... ';
return '<Buffer ' + str + '>'
};
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array)) {
target = Buffer.from(target, target.offset, target.byteLength);
}
if (!Buffer.isBuffer(target)) {
throw new TypeError(
'The "target" argument must be one of type Buffer or Uint8Array. ' +
'Received type ' + (typeof target)
)
}
if (start === undefined) {
start = 0;
}
if (end === undefined) {
end = target ? target.length : 0;
}
if (thisStart === undefined) {
thisStart = 0;
}
if (thisEnd === undefined) {
thisEnd = this.length;
}
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
throw new RangeError('out of range index')
}
if (thisStart >= thisEnd && start >= end) {
return 0
}
if (thisStart >= thisEnd) {
return -1
}
if (start >= end) {
return 1
}
start >>>= 0;
end >>>= 0;
thisStart >>>= 0;
thisEnd >>>= 0;
if (this === target) return 0
var x = thisEnd - thisStart;
var y = end - start;
var len = Math.min(x, y);
var thisCopy = this.slice(thisStart, thisEnd);
var targetCopy = target.slice(start, end);
for (var i = 0; i < len; ++i) {
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i];
y = targetCopy[i];
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
};
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
if (buffer.length === 0) return -1
if (typeof byteOffset === 'string') {
encoding = byteOffset;
byteOffset = 0;
} else if (byteOffset > 0x7fffffff) {
byteOffset = 0x7fffffff;
} else if (byteOffset < -0x80000000) {
byteOffset = -0x80000000;
}
byteOffset = +byteOffset;
if (numberIsNaN(byteOffset)) {
byteOffset = dir ? 0 : (buffer.length - 1);
}
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
if (byteOffset >= buffer.length) {
if (dir) return -1
else byteOffset = buffer.length - 1;
} else if (byteOffset < 0) {
if (dir) byteOffset = 0;
else return -1
}
if (typeof val === 'string') {
val = Buffer.from(val, encoding);
}
if (Buffer.isBuffer(val)) {
if (val.length === 0) {
return -1
}
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
} else if (typeof val === 'number') {
val = val & 0xFF;
if (typeof Uint8Array.prototype.indexOf === 'function') {
if (dir) {
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
} else {
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
}
}
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}
throw new TypeError('val must be string, number or Buffer')
}
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
var indexSize = 1;
var arrLength = arr.length;
var valLength = val.length;
if (encoding !== undefined) {
encoding = String(encoding).toLowerCase();
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
encoding === 'utf16le' || encoding === 'utf-16le') {
if (arr.length < 2 || val.length < 2) {
return -1
}
indexSize = 2;
arrLength /= 2;
valLength /= 2;
byteOffset /= 2;
}
}
function read (buf, i) {
if (indexSize === 1) {
return buf[i]
} else {
return buf.readUInt16BE(i * indexSize)
}
}
var i;
if (dir) {
var foundIndex = -1;
for (i = byteOffset; i < arrLength; i++) {
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i;
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
} else {
if (foundIndex !== -1) i -= i - foundIndex;
foundIndex = -1;
}
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
for (i = byteOffset; i >= 0; i--) {
var found = true;
for (var j = 0; j < valLength; j++) {
if (read(arr, i + j) !== read(val, j)) {
found = false;
break
}
}
if (found) return i
}
}
return -1
}
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1
};
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
};
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
};
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0;
var remaining = buf.length - offset;
if (!length) {
length = remaining;
} else {
length = Number(length);
if (length > remaining) {
length = remaining;
}
}
var strLen = string.length;
if (length > strLen / 2) {
length = strLen / 2;
}
for (var i = 0; i < length; ++i) {
var parsed = parseInt(string.substr(i * 2, 2), 16);
if (numberIsNaN(parsed)) return i
buf[offset + i] = parsed;
}
return i
}
function utf8Write (buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}
function asciiWrite (buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length)
}
function latin1Write (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length)
}
function ucs2Write (buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}
Buffer.prototype.write = function write (string, offset, length, encoding) {
if (offset === undefined) {
encoding = 'utf8';
length = this.length;
offset = 0;
} else if (length === undefined && typeof offset === 'string') {
encoding = offset;
length = this.length;
offset = 0;
} else if (isFinite(offset)) {
offset = offset >>> 0;
if (isFinite(length)) {
length = length >>> 0;
if (encoding === undefined) encoding = 'utf8';
} else {
encoding = length;
length = undefined;
}
} else {
throw new Error(
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
)
}
var remaining = this.length - offset;
if (length === undefined || length > remaining) length = remaining;
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
throw new RangeError('Attempt to write outside buffer bounds')
}
if (!encoding) encoding = 'utf8';
var loweredCase = false;
for (;;) {
switch (encoding) {
case 'hex':
return hexWrite(this, string, offset, length)
case 'utf8':
case 'utf-8':
return utf8Write(this, string, offset, length)
case 'ascii':
return asciiWrite(this, string, offset, length)
case 'latin1':
case 'binary':
return latin1Write(this, string, offset, length)
case 'base64':
return base64Write(this, string, offset, length)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return ucs2Write(this, string, offset, length)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = ('' + encoding).toLowerCase();
loweredCase = true;
}
}
};
Buffer.prototype.toJSON = function toJSON () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
};
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
end = Math.min(buf.length, end);
var res = [];
var i = start;
while (i < end) {
var firstByte = buf[i];
var codePoint = null;
var bytesPerSequence = (firstByte > 0xEF) ? 4
: (firstByte > 0xDF) ? 3
: (firstByte > 0xBF) ? 2
: 1;
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 0x80) {
codePoint = firstByte;
}
break
case 2:
secondByte = buf[i + 1];
if ((secondByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
if (tempCodePoint > 0x7F) {
codePoint = tempCodePoint;
}
}
break
case 3:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
codePoint = tempCodePoint;
}
}
break
case 4:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
fourthByte = buf[i + 3];
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
codePoint = tempCodePoint;
}
}
}
}
if (codePoint === null) {
codePoint = 0xFFFD;
bytesPerSequence = 1;
} else if (codePoint > 0xFFFF) {
codePoint -= 0x10000;
res.push(codePoint >>> 10 & 0x3FF | 0xD800);
codePoint = 0xDC00 | codePoint & 0x3FF;
}
res.push(codePoint);
i += bytesPerSequence;
}
return decodeCodePointsArray(res)
}
var MAX_ARGUMENTS_LENGTH = 0x1000;
function decodeCodePointsArray (codePoints) {
var len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH) {
return String.fromCharCode.apply(String, codePoints)
}
var res = '';
var i = 0;
while (i < len) {
res += String.fromCharCode.apply(
String,
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
);
}
return res
}
function asciiSlice (buf, start, end) {
var ret = '';
end = Math.min(buf.length, end);
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i] & 0x7F);
}
return ret
}
function latin1Slice (buf, start, end) {
var ret = '';
end = Math.min(buf.length, end);
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i]);
}
return ret
}
function hexSlice (buf, start, end) {
var len = buf.length;
if (!start || start < 0) start = 0;
if (!end || end < 0 || end > len) end = len;
var out = '';
for (var i = start; i < end; ++i) {
out += toHex(buf[i]);
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end);
var res = '';
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256));
}
return res
}
Buffer.prototype.slice = function slice (start, end) {
var len = this.length;
start = ~~start;
end = end === undefined ? len : ~~end;
if (start < 0) {
start += len;
if (start < 0) start = 0;
} else if (start > len) {
start = len;
}
if (end < 0) {
end += len;
if (end < 0) end = 0;
} else if (end > len) {
end = len;
}
if (end < start) end = start;
var newBuf = this.subarray(start, end);
newBuf.__proto__ = Buffer.prototype;
return newBuf
};
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var val = this[offset];
var mul = 1;
var i = 0;
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul;
}
return val
};
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
checkOffset(offset, byteLength, this.length);
}
var val = this[offset + --byteLength];
var mul = 1;
while (byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul;
}
return val
};
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
return this[offset]
};
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] | (this[offset + 1] << 8)
};
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return (this[offset] << 8) | this[offset + 1]
};
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
};
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
};
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var val = this[offset];
var mul = 1;
var i = 0;
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul;
}
mul *= 0x80;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val
};
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var i = byteLength;
var mul = 1;
var val = this[offset + --i];
while (i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul;
}
mul *= 0x80;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val
};
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
if (!(this[offset] & 0x80)) return (this[offset])
return ((0xff - this[offset] + 1) * -1)
};
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
var val = this[offset] | (this[offset + 1] << 8);
return (val & 0x8000) ? val | 0xFFFF0000 : val
};
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
var val = this[offset + 1] | (this[offset] << 8);
return (val & 0x8000) ? val | 0xFFFF0000 : val
};
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
};
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
};
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return ieee754.read(this, offset, true, 23, 4)
};
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return ieee754.read(this, offset, false, 23, 4)
};
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 8, this.length);
return ieee754.read(this, offset, true, 52, 8)
};
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 8, this.length);
return ieee754.read(this, offset, false, 52, 8)
};
function checkInt (buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
if (offset + ext > buf.length) throw new RangeError('Index out of range')
}
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
var mul = 1;
var i = 0;
this[offset] = value & 0xFF;
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
var i = byteLength - 1;
var mul = 1;
this[offset + i] = value & 0xFF;
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
this[offset] = (value & 0xff);
return offset + 1
};
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
this[offset] = (value & 0xff);
this[offset + 1] = (value >>> 8);
return offset + 2
};
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
this[offset] = (value >>> 8);
this[offset + 1] = (value & 0xff);
return offset + 2
};
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
this[offset + 3] = (value >>> 24);
this[offset + 2] = (value >>> 16);
this[offset + 1] = (value >>> 8);
this[offset] = (value & 0xff);
return offset + 4
};
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
this[offset] = (value >>> 24);
this[offset + 1] = (value >>> 16);
this[offset + 2] = (value >>> 8);
this[offset + 3] = (value & 0xff);
return offset + 4
};
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit = Math.pow(2, (8 * byteLength) - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
var i = 0;
var mul = 1;
var sub = 0;
this[offset] = value & 0xFF;
while (++i < byteLength && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
sub = 1;
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit = Math.pow(2, (8 * byteLength) - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
var i = byteLength - 1;
var mul = 1;
var sub = 0;
this[offset + i] = value & 0xFF;
while (--i >= 0 && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
sub = 1;
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
if (value < 0) value = 0xff + value + 1;
this[offset] = (value & 0xff);
return offset + 1
};
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
this[offset] = (value & 0xff);
this[offset + 1] = (value >>> 8);
return offset + 2
};
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
this[offset] = (value >>> 8);
this[offset + 1] = (value & 0xff);
return offset + 2
};
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
this[offset] = (value & 0xff);
this[offset + 1] = (value >>> 8);
this[offset + 2] = (value >>> 16);
this[offset + 3] = (value >>> 24);
return offset + 4
};
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
if (value < 0) value = 0xffffffff + value + 1;
this[offset] = (value >>> 24);
this[offset + 1] = (value >>> 16);
this[offset + 2] = (value >>> 8);
this[offset + 3] = (value & 0xff);
return offset + 4
};
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError('Index out of range')
if (offset < 0) throw new RangeError('Index out of range')
}
function writeFloat (buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
checkIEEE754(buf, value, offset, 4);
}
ieee754.write(buf, value, offset, littleEndian, 23, 4);
return offset + 4
}
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
};
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
};
function writeDouble (buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
checkIEEE754(buf, value, offset, 8);
}
ieee754.write(buf, value, offset, littleEndian, 52, 8);
return offset + 8
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
};
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
};
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
if (!start) start = 0;
if (!end && end !== 0) end = this.length;
if (targetStart >= target.length) targetStart = target.length;
if (!targetStart) targetStart = 0;
if (end > 0 && end < start) end = start;
if (end === start) return 0
if (target.length === 0 || this.length === 0) return 0
if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
if (end < 0) throw new RangeError('sourceEnd out of bounds')
if (end > this.length) end = this.length;
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start;
}
var len = end - start;
if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
this.copyWithin(targetStart, start, end);
} else if (this === target && start < targetStart && targetStart < end) {
for (var i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start];
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, end),
targetStart
);
}
return len
};
Buffer.prototype.fill = function fill (val, start, end, encoding) {
if (typeof val === 'string') {
if (typeof start === 'string') {
encoding = start;
start = 0;
end = this.length;
} else if (typeof end === 'string') {
encoding = end;
end = this.length;
}
if (encoding !== undefined && typeof encoding !== 'string') {
throw new TypeError('encoding must be a string')
}
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
if (val.length === 1) {
var code = val.charCodeAt(0);
if ((encoding === 'utf8' && code < 128) ||
encoding === 'latin1') {
val = code;
}
}
} else if (typeof val === 'number') {
val = val & 255;
}
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError('Out of range index')
}
if (end <= start) {
return this
}
start = start >>> 0;
end = end === undefined ? this.length : end >>> 0;
if (!val) val = 0;
var i;
if (typeof val === 'number') {
for (i = start; i < end; ++i) {
this[i] = val;
}
} else {
var bytes = Buffer.isBuffer(val)
? val
: Buffer.from(val, encoding);
var len = bytes.length;
if (len === 0) {
throw new TypeError('The value "' + val +
'" is invalid for argument "value"')
}
for (i = 0; i < end - start; ++i) {
this[i + start] = bytes[i % len];
}
}
return this
};
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
function base64clean (str) {
str = str.split('=')[0];
str = str.trim().replace(INVALID_BASE64_RE, '');
if (str.length < 2) return ''
while (str.length % 4 !== 0) {
str = str + '=';
}
return str
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (string, units) {
units = units || Infinity;
var codePoint;
var length = string.length;
var leadSurrogate = null;
var bytes = [];
for (var i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i);
if (codePoint > 0xD7FF && codePoint < 0xE000) {
if (!leadSurrogate) {
if (codePoint > 0xDBFF) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
continue
} else if (i + 1 === length) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
continue
}
leadSurrogate = codePoint;
continue
}
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
leadSurrogate = codePoint;
continue
}
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
} else if (leadSurrogate) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
}
leadSurrogate = null;
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint);
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
);
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
);
} else if (codePoint < 0x110000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
);
} else {
throw new Error('Invalid code point')
}
}
return bytes
}
function asciiToBytes (str) {
var byteArray = [];
for (var i = 0; i < str.length; ++i) {
byteArray.push(str.charCodeAt(i) & 0xFF);
}
return byteArray
}
function utf16leToBytes (str, units) {
var c, hi, lo;
var byteArray = [];
for (var i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break
c = str.charCodeAt(i);
hi = c >> 8;
lo = c % 256;
byteArray.push(lo);
byteArray.push(hi);
}
return byteArray
}
function base64ToBytes (str) {
return base64.toByteArray(base64clean(str))
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; ++i) {
if ((i + offset >= dst.length) || (i >= src.length)) break
dst[i + offset] = src[i];
}
return i
}
function isInstance (obj, type) {
return obj instanceof type ||
(obj != null && obj.constructor != null && obj.constructor.name != null &&
obj.constructor.name === type.name)
}
function numberIsNaN (obj) {
return obj !== obj
}
},{"base64-js":24,"ieee754":31}],29:[function(require,module,exports){
(function (Buffer){
function isArray(arg) {
if (Array.isArray) {
return Array.isArray(arg);
}
return objectToString(arg) === '[object Array]';
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return (objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' ||
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = Buffer.isBuffer;
function objectToString(o) {
return Object.prototype.toString.call(o);
}
}).call(this,{"isBuffer":require("../../is-buffer/index.js")});
},{"../../is-buffer/index.js":33}],30:[function(require,module,exports){
var objectCreate = Object.create || objectCreatePolyfill;
var objectKeys = Object.keys || objectKeysPolyfill;
var bind = Function.prototype.bind || functionBindPolyfill;
function EventEmitter() {
if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
this._events = objectCreate(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;
var defaultMaxListeners = 10;
var hasDefineProperty;
try {
var o = {};
if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
hasDefineProperty = o.x === 0;
} catch (err) { hasDefineProperty = false; }
if (hasDefineProperty) {
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || arg !== arg)
throw new TypeError('"defaultMaxListeners" must be a positive number');
defaultMaxListeners = arg;
}
});
} else {
EventEmitter.defaultMaxListeners = defaultMaxListeners;
}
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || isNaN(n))
throw new TypeError('"n" argument must be a positive number');
this._maxListeners = n;
return this;
};
function $getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return $getMaxListeners(this);
};
function emitNone(handler, isFn, self) {
if (isFn)
handler.call(self);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self);
}
}
function emitOne(handler, isFn, self, arg1) {
if (isFn)
handler.call(self, arg1);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1);
}
}
function emitTwo(handler, isFn, self, arg1, arg2) {
if (isFn)
handler.call(self, arg1, arg2);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1, arg2);
}
}
function emitThree(handler, isFn, self, arg1, arg2, arg3) {
if (isFn)
handler.call(self, arg1, arg2, arg3);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1, arg2, arg3);
}
}
function emitMany(handler, isFn, self, args) {
if (isFn)
handler.apply(self, args);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].apply(self, args);
}
}
EventEmitter.prototype.emit = function emit(type) {
var er, handler, len, args, i, events;
var doError = (type === 'error');
events = this._events;
if (events)
doError = (doError && events.error == null);
else if (!doError)
return false;
if (doError) {
if (arguments.length > 1)
er = arguments[1];
if (er instanceof Error) {
throw er;
} else {
var err = new Error('Unhandled "error" event. (' + er + ')');
err.context = er;
throw err;
}
}
handler = events[type];
if (!handler)
return false;
var isFn = typeof handler === 'function';
len = arguments.length;
switch (len) {
case 1:
emitNone(handler, isFn, this);
break;
case 2:
emitOne(handler, isFn, this, arguments[1]);
break;
case 3:
emitTwo(handler, isFn, this, arguments[1], arguments[2]);
break;
case 4:
emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
break;
default:
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
emitMany(handler, isFn, this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
events = target._events;
if (!events) {
events = target._events = objectCreate(null);
target._eventsCount = 0;
} else {
if (events.newListener) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
events = target._events;
}
existing = events[type];
}
if (!existing) {
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
} else {
if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
}
if (!existing.warned) {
m = $getMaxListeners(target);
if (m && m > 0 && existing.length > m) {
existing.warned = true;
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' "' + String(type) + '" listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit.');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
if (typeof console === 'object' && console.warn) {
console.warn('%s: %s', w.name, w.message);
}
}
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
switch (arguments.length) {
case 0:
return this.listener.call(this.target);
case 1:
return this.listener.call(this.target, arguments[0]);
case 2:
return this.listener.call(this.target, arguments[0], arguments[1]);
case 3:
return this.listener.call(this.target, arguments[0], arguments[1],
arguments[2]);
default:
var args = new Array(arguments.length);
for (var i = 0; i < args.length; ++i)
args[i] = arguments[i];
this.listener.apply(this.target, args);
}
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = bind.call(onceWrapper, state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
events = this._events;
if (!events)
return this;
list = events[type];
if (!list)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = objectCreate(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else
spliceOne(list, position);
if (list.length === 1)
events[type] = list[0];
if (events.removeListener)
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (!events)
return this;
if (!events.removeListener) {
if (arguments.length === 0) {
this._events = objectCreate(null);
this._eventsCount = 0;
} else if (events[type]) {
if (--this._eventsCount === 0)
this._events = objectCreate(null);
else
delete events[type];
}
return this;
}
if (arguments.length === 0) {
var keys = objectKeys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = objectCreate(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners) {
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (!events)
return [];
var evlistener = events[type];
if (!evlistener)
return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener) {
return evlistener.length;
}
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
};
function spliceOne(list, index) {
for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
list[i] = list[k];
list.pop();
}
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function objectCreatePolyfill(proto) {
var F = function() {};
F.prototype = proto;
return new F;
}
function objectKeysPolyfill(obj) {
for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) ;
return k;
}
function functionBindPolyfill(context) {
var fn = this;
return function () {
return fn.apply(context, arguments);
};
}
},{}],31:[function(require,module,exports){
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
var e, m;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var nBits = -7;
var i = isLE ? (nBytes - 1) : 0;
var d = isLE ? -1 : 1;
var s = buffer[offset + i];
i += d;
e = s & ((1 << (-nBits)) - 1);
s >>= (-nBits);
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
m = e & ((1 << (-nBits)) - 1);
e >>= (-nBits);
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
};
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
var i = isLE ? 0 : (nBytes - 1);
var d = isLE ? 1 : -1;
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * Math.pow(2, 1 - eBias);
}
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
e = (e << mLen) | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
buffer[offset + i - d] |= s * 128;
};
},{}],32:[function(require,module,exports){
if (typeof Object.create === 'function') {
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function () {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
};
}
},{}],33:[function(require,module,exports){
/*!
* Determine if an object is a Buffer
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
module.exports = function (obj) {
return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
};
function isBuffer (obj) {
return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
}
function isSlowBuffer (obj) {
return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
}
},{}],34:[function(require,module,exports){
var toString = {}.toString;
module.exports = Array.isArray || function (arr) {
return toString.call(arr) == '[object Array]';
};
},{}],35:[function(require,module,exports){
var TYPED_OK = (typeof Uint8Array !== 'undefined') &&
(typeof Uint16Array !== 'undefined') &&
(typeof Int32Array !== 'undefined');
function _has(obj, key) {
return Object.prototype.hasOwnProperty.call(obj, key);
}
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 (_has(source, 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);
},{}],36:[function(require,module,exports){
function adler32(adler, buf, len, pos) {
var s1 = (adler & 0xffff) |0,
s2 = ((adler >>> 16) & 0xffff) |0,
n = 0;
while (len !== 0) {
n = len > 2000 ? 2000 : 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;
},{}],37:[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
};
},{}],38:[function(require,module,exports){
function makeTable() {
var c, table = [];
for (var n = 0; n < 256; n++) {
c = n;
for (var k = 0; k < 8; k++) {
c = ((c & 1) ? (0xEDB88320 ^ (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 ^= -1;
for (var i = pos; i < end; i++) {
crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
}
return (crc ^ (-1));
}
module.exports = crc32;
},{}],39:[function(require,module,exports){
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 = 0x20;
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 = 0x03;
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) & 0xff;
s.pending_buf[s.pending++] = b & 0xff;
}
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 = 0xffff;
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;
}
function Config(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 = 1 * s.lit_bufsize;
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 & 0xff);
put_byte(s, (s.gzhead.time >> 8) & 0xff);
put_byte(s, (s.gzhead.time >> 16) & 0xff);
put_byte(s, (s.gzhead.time >> 24) & 0xff);
put_byte(s, s.level === 9 ? 2 :
(s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
4 : 0));
put_byte(s, s.gzhead.os & 0xff);
if (s.gzhead.extra && s.gzhead.extra.length) {
put_byte(s, s.gzhead.extra.length & 0xff);
put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
}
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 & 0xffff);
}
strm.adler = 1;
}
}
if (s.status === EXTRA_STATE) {
if (s.gzhead.extra) {
beg = s.pending;
while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
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] & 0xff);
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++) & 0xff;
} 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++) & 0xff;
} 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 & 0xff);
put_byte(s, (strm.adler >> 8) & 0xff);
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 & 0xff);
put_byte(s, (strm.adler >> 8) & 0xff);
put_byte(s, (strm.adler >> 16) & 0xff);
put_byte(s, (strm.adler >> 24) & 0xff);
put_byte(s, strm.total_in & 0xff);
put_byte(s, (strm.total_in >> 8) & 0xff);
put_byte(s, (strm.total_in >> 16) & 0xff);
put_byte(s, (strm.total_in >> 24) & 0xff);
}
else
{
putShortMSB(s, strm.adler >>> 16);
putShortMSB(s, strm.adler & 0xffff);
}
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;
}
function deflateSetDictionary(strm, dictionary) {
var dictLength = dictionary.length;
var s;
var str, n;
var wrap;
var avail;
var next;
var input;
var tmpDict;
if (!strm || !strm.state) {
return Z_STREAM_ERROR;
}
s = strm.state;
wrap = s.wrap;
if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {
return Z_STREAM_ERROR;
}
if (wrap === 1) {
strm.adler = adler32(strm.adler, dictionary, dictLength, 0);
}
s.wrap = 0;
if (dictLength >= s.w_size) {
if (wrap === 0) {
zero(s.head);
s.strstart = 0;
s.block_start = 0;
s.insert = 0;
}
tmpDict = new utils.Buf8(s.w_size);
utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);
dictionary = tmpDict;
dictLength = s.w_size;
}
avail = strm.avail_in;
next = strm.next_in;
input = strm.input;
strm.avail_in = dictLength;
strm.next_in = 0;
strm.input = dictionary;
fill_window(s);
while (s.lookahead >= MIN_MATCH) {
str = s.strstart;
n = s.lookahead - (MIN_MATCH - 1);
do {
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++;
} while (--n);
s.strstart = str;
s.lookahead = MIN_MATCH - 1;
fill_window(s);
}
s.strstart += s.lookahead;
s.block_start = s.strstart;
s.insert = s.lookahead;
s.lookahead = 0;
s.match_length = s.prev_length = MIN_MATCH - 1;
s.match_available = 0;
strm.next_in = next;
strm.input = input;
strm.avail_in = avail;
s.wrap = wrap;
return Z_OK;
}
exports.deflateInit = deflateInit;
exports.deflateInit2 = deflateInit2;
exports.deflateReset = deflateReset;
exports.deflateResetKeep = deflateResetKeep;
exports.deflateSetHeader = deflateSetHeader;
exports.deflate = deflate;
exports.deflateEnd = deflateEnd;
exports.deflateSetDictionary = deflateSetDictionary;
exports.deflateInfo = 'pako deflate (from Nodeca project)';
},{"../utils/common":35,"./adler32":36,"./crc32":38,"./messages":43,"./trees":44}],40:[function(require,module,exports){
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) & 0xff;
if (op === 0) {
output[_out++] = here & 0xffff;
}
else if (op & 16) {
len = here & 0xffff;
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) & 0xff;
if (op & 16) {
dist = here & 0xffff;
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 & 0xffff) + (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 & 0xffff) + (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;
};
},{}],41:[function(require,module,exports){
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) & 0xff) +
((q >>> 8) & 0xff00) +
((q & 0xff00) << 8) +
((q & 0xff) << 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 === 0x8b1f) {
state.check = 0;
hbuf[0] = hold & 0xff;
hbuf[1] = (hold >>> 8) & 0xff;
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 & 0xff) << 8) + (hold >> 8)) % 31) {
strm.msg = 'incorrect header check';
state.mode = BAD;
break;
}
if ((hold & 0x0f) !== Z_DEFLATED) {
strm.msg = 'unknown compression method';
state.mode = BAD;
break;
}
hold >>>= 4;
bits -= 4;
len = (hold & 0x0f) + 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 & 0x200 ? 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 & 0xff) !== Z_DEFLATED) {
strm.msg = 'unknown compression method';
state.mode = BAD;
break;
}
if (state.flags & 0xe000) {
strm.msg = 'unknown header flags set';
state.mode = BAD;
break;
}
if (state.head) {
state.head.text = ((hold >> 8) & 1);
}
if (state.flags & 0x0200) {
hbuf[0] = hold & 0xff;
hbuf[1] = (hold >>> 8) & 0xff;
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 & 0x0200) {
hbuf[0] = hold & 0xff;
hbuf[1] = (hold >>> 8) & 0xff;
hbuf[2] = (hold >>> 16) & 0xff;
hbuf[3] = (hold >>> 24) & 0xff;
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 & 0xff);
state.head.os = (hold >> 8);
}
if (state.flags & 0x0200) {
hbuf[0] = hold & 0xff;
hbuf[1] = (hold >>> 8) & 0xff;
state.check = crc32(state.check, hbuf, 2, 0);
}
hold = 0;
bits = 0;
state.mode = EXLEN;
case EXLEN:
if (state.flags & 0x0400) {
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 & 0x0200) {
hbuf[0] = hold & 0xff;
hbuf[1] = (hold >>> 8) & 0xff;
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 & 0x0400) {
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 & 0x0200) {
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 & 0x0800) {
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 & 0x0200) {
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 & 0x1000) {
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 & 0x0200) {
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 & 0x0200) {
while (bits < 16) {
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
if (hold !== (state.check & 0xffff)) {
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 & 0x01);
hold >>>= 1;
bits -= 1;
switch ((hold & 0x03)) {
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 & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
strm.msg = 'invalid stored block lengths';
state.mode = BAD;
break;
}
state.length = hold & 0xffff;
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 & 0x1f) + 257;
hold >>>= 5;
bits -= 5;
state.ndist = (hold & 0x1f) + 1;
hold >>>= 5;
bits -= 5;
state.ncode = (hold & 0x0f) + 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 & 0x07);
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) & 0xff;
here_val = here & 0xffff;
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 & 0x03);
hold >>>= 2;
bits -= 2;
}
else if (here_val === 17) {
n = here_bits + 3;
while (bits < n) {
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
hold >>>= here_bits;
bits -= here_bits;
len = 0;
copy = 3 + (hold & 0x07);
hold >>>= 3;
bits -= 3;
}
else {
n = here_bits + 7;
while (bits < n) {
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
hold >>>= here_bits;
bits -= here_bits;
len = 0;
copy = 11 + (hold & 0x7f);
hold >>>= 7;
bits -= 7;
}
if (state.have + copy > state.nlen + state.ndist) {
strm.msg = 'invalid bit length repeat';
state.mode = BAD;
break;
}
while (copy--) {
state.lens[state.have++] = len;
}
}
}
if (state.mode === BAD) { break; }
if (state.lens[256] === 0) {
strm.msg = 'invalid code -- missing end-of-block';
state.mode = BAD;
break;
}
state.lenbits = 9;
opts = { bits: state.lenbits };
ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
state.lenbits = opts.bits;
if (ret) {
strm.msg = 'invalid literal/lengths set';
state.mode = BAD;
break;
}
state.distbits = 6;
state.distcode = state.distdyn;
opts = { bits: state.distbits };
ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
state.distbits = opts.bits;
if (ret) {
strm.msg = 'invalid distances set';
state.mode = BAD;
break;
}
state.mode = LEN_;
if (flush === Z_TREES) { break inf_leave; }
case LEN_:
state.mode = LEN;
case LEN:
if (have >= 6 && left >= 258) {
strm.next_out = put;
strm.avail_out = left;
strm.next_in = next;
strm.avail_in = have;
state.hold = hold;
state.bits = bits;
inflate_fast(strm, _out);
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;
if (state.mode === TYPE) {
state.back = -1;
}
break;
}
state.back = 0;
for (;;) {
here = state.lencode[hold & ((1 << state.lenbits) - 1)];
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
if (here_bits <= bits) { break; }
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
if (here_op && (here_op & 0xf0) === 0) {
last_bits = here_bits;
last_op = here_op;
last_val = here_val;
for (;;) {
here = state.lencode[last_val +
((hold & ((1 << (last_bits + last_op)) - 1)) >> last_bits)];
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
if ((last_bits + here_bits) <= bits) { break; }
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
hold >>>= last_bits;
bits -= last_bits;
state.back += last_bits;
}
hold >>>= here_bits;
bits -= here_bits;
state.back += here_bits;
state.length = here_val;
if (here_op === 0) {
state.mode = LIT;
break;
}
if (here_op & 32) {
state.back = -1;
state.mode = TYPE;
break;
}
if (here_op & 64) {
strm.msg = 'invalid literal/length code';
state.mode = BAD;
break;
}
state.extra = here_op & 15;
state.mode = LENEXT;
case LENEXT:
if (state.extra) {
n = state.extra;
while (bits < n) {
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
state.length += hold & ((1 << state.extra) - 1);
hold >>>= state.extra;
bits -= state.extra;
state.back += state.extra;
}
state.was = state.length;
state.mode = DIST;
case DIST:
for (;;) {
here = state.distcode[hold & ((1 << state.distbits) - 1)];
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
if ((here_bits) <= bits) { break; }
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
if ((here_op & 0xf0) === 0) {
last_bits = here_bits;
last_op = here_op;
last_val = here_val;
for (;;) {
here = state.distcode[last_val +
((hold & ((1 << (last_bits + last_op)) - 1)) >> last_bits)];
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
if ((last_bits + here_bits) <= bits) { break; }
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
hold >>>= last_bits;
bits -= last_bits;
state.back += last_bits;
}
hold >>>= here_bits;
bits -= here_bits;
state.back += here_bits;
if (here_op & 64) {
strm.msg = 'invalid distance code';
state.mode = BAD;
break;
}
state.offset = here_val;
state.extra = (here_op) & 15;
state.mode = DISTEXT;
case DISTEXT:
if (state.extra) {
n = state.extra;
while (bits < n) {
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
state.offset += hold & ((1 << state.extra) - 1);
hold >>>= state.extra;
bits -= state.extra;
state.back += state.extra;
}
if (state.offset > state.dmax) {
strm.msg = 'invalid distance too far back';
state.mode = BAD;
break;
}
state.mode = MATCH;
case MATCH:
if (left === 0) { break inf_leave; }
copy = _out - left;
if (state.offset > copy) {
copy = state.offset - copy;
if (copy > state.whave) {
if (state.sane) {
strm.msg = 'invalid distance too far back';
state.mode = BAD;
break;
}
}
if (copy > state.wnext) {
copy -= state.wnext;
from = state.wsize - copy;
}
else {
from = state.wnext - copy;
}
if (copy > state.length) { copy = state.length; }
from_source = state.window;
}
else {
from_source = output;
from = put - state.offset;
copy = state.length;
}
if (copy > left) { copy = left; }
left -= copy;
state.length -= copy;
do {
output[put++] = from_source[from++];
} while (--copy);
if (state.length === 0) { state.mode = LEN; }
break;
case LIT:
if (left === 0) { break inf_leave; }
output[put++] = state.length;
left--;
state.mode = LEN;
break;
case CHECK:
if (state.wrap) {
while (bits < 32) {
if (have === 0) { break inf_leave; }
have--;
hold |= input[next++] << bits;
bits += 8;
}
_out -= left;
strm.total_out += _out;
state.total += _out;
if (_out) {
strm.adler = state.check =
(state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
}
_out = left;
if ((state.flags ? hold : zswap32(hold)) !== state.check) {
strm.msg = 'incorrect data check';
state.mode = BAD;
break;
}
hold = 0;
bits = 0;
}
state.mode = LENGTH;
case LENGTH:
if (state.wrap && state.flags) {
while (bits < 32) {
if (have === 0) { break inf_leave; }
have--;
hold += input[next++] << bits;
bits += 8;
}
if (hold !== (state.total & 0xffffffff)) {
strm.msg = 'incorrect length check';
state.mode = BAD;
break;
}
hold = 0;
bits = 0;
}
state.mode = DONE;
case DONE:
ret = Z_STREAM_END;
break inf_leave;
case BAD:
ret = Z_DATA_ERROR;
break inf_leave;
case MEM:
return Z_MEM_ERROR;
case SYNC:
default:
return Z_STREAM_ERROR;
}
}
strm.next_out = put;
strm.avail_out = left;
strm.next_in = next;
strm.avail_in = have;
state.hold = hold;
state.bits = bits;
if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
(state.mode < CHECK || flush !== Z_FINISH))) {
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) ;
}
_in -= strm.avail_in;
_out -= strm.avail_out;
strm.total_in += _in;
strm.total_out += _out;
state.total += _out;
if (state.wrap && _out) {
strm.adler = state.check =
(state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
}
strm.data_type = state.bits + (state.last ? 64 : 0) +
(state.mode === TYPE ? 128 : 0) +
(state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
ret = Z_BUF_ERROR;
}
return ret;
}
function inflateEnd(strm) {
if (!strm || !strm.state ) {
return Z_STREAM_ERROR;
}
var state = strm.state;
if (state.window) {
state.window = null;
}
strm.state = null;
return Z_OK;
}
function inflateGetHeader(strm, head) {
var state;
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
state = strm.state;
if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }
state.head = head;
head.done = false;
return Z_OK;
}
function inflateSetDictionary(strm, dictionary) {
var dictLength = dictionary.length;
var state;
var dictid;
var ret;
if (!strm || !strm.state ) { return Z_STREAM_ERROR; }
state = strm.state;
if (state.wrap !== 0 && state.mode !== DICT) {
return Z_STREAM_ERROR;
}
if (state.mode === DICT) {
dictid = 1;
dictid = adler32(dictid, dictionary, dictLength, 0);
if (dictid !== state.check) {
return Z_DATA_ERROR;
}
}
ret = updatewindow(strm, dictionary, dictLength, dictLength);
if (ret) {
state.mode = MEM;
return Z_MEM_ERROR;
}
state.havedict = 1;
return Z_OK;
}
exports.inflateReset = inflateReset;
exports.inflateReset2 = inflateReset2;
exports.inflateResetKeep = inflateResetKeep;
exports.inflateInit = inflateInit;
exports.inflateInit2 = inflateInit2;
exports.inflate = inflate;
exports.inflateEnd = inflateEnd;
exports.inflateGetHeader = inflateGetHeader;
exports.inflateSetDictionary = inflateSetDictionary;
exports.inflateInfo = 'pako inflate (from Nodeca project)';
},{"../utils/common":35,"./adler32":36,"./crc32":38,"./inffast":40,"./inftrees":42}],42:[function(require,module,exports){
var utils = require('../utils/common');
var MAXBITS = 15;
var ENOUGH_LENS = 852;
var ENOUGH_DISTS = 592;
var CODES = 0;
var LENS = 1;
var DISTS = 2;
var lbase = [
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
];
var lext = [
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
];
var dbase = [
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
8193, 12289, 16385, 24577, 0, 0
];
var dext = [
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
28, 28, 29, 29, 64, 64
];
module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)
{
var bits = opts.bits;
var len = 0;
var sym = 0;
var min = 0, max = 0;
var root = 0;
var curr = 0;
var drop = 0;
var left = 0;
var used = 0;
var huff = 0;
var incr;
var fill;
var low;
var mask;
var next;
var base = null;
var base_index = 0;
var end;
var count = new utils.Buf16(MAXBITS + 1);
var offs = new utils.Buf16(MAXBITS + 1);
var extra = null;
var extra_index = 0;
var here_bits, here_op, here_val;
for (len = 0; len <= MAXBITS; len++) {
count[len] = 0;
}
for (sym = 0; sym < codes; sym++) {
count[lens[lens_index + sym]]++;
}
root = bits;
for (max = MAXBITS; max >= 1; max--) {
if (count[max] !== 0) { break; }
}
if (root > max) {
root = max;
}
if (max === 0) {
table[table_index++] = (1 << 24) | (64 << 16) | 0;
table[table_index++] = (1 << 24) | (64 << 16) | 0;
opts.bits = 1;
return 0;
}
for (min = 1; min < max; min++) {
if (count[min] !== 0) { break; }
}
if (root < min) {
root = min;
}
left = 1;
for (len = 1; len <= MAXBITS; len++) {
left <<= 1;
left -= count[len];
if (left < 0) {
return -1;
}
}
if (left > 0 && (type === CODES || max !== 1)) {
return -1;
}
offs[1] = 0;
for (len = 1; len < MAXBITS; len++) {
offs[len + 1] = offs[len] + count[len];
}
for (sym = 0; sym < codes; sym++) {
if (lens[lens_index + sym] !== 0) {
work[offs[lens[lens_index + sym]]++] = sym;
}
}
if (type === CODES) {
base = extra = work;
end = 19;
} else if (type === LENS) {
base = lbase;
base_index -= 257;
extra = lext;
extra_index -= 257;
end = 256;
} else {
base = dbase;
extra = dext;
end = -1;
}
huff = 0;
sym = 0;
len = min;
next = table_index;
curr = root;
drop = 0;
low = -1;
used = 1 << root;
mask = used - 1;
if ((type === LENS && used > ENOUGH_LENS) ||
(type === DISTS && used > ENOUGH_DISTS)) {
return 1;
}
for (;;) {
here_bits = len - drop;
if (work[sym] < end) {
here_op = 0;
here_val = work[sym];
}
else if (work[sym] > end) {
here_op = extra[extra_index + work[sym]];
here_val = base[base_index + work[sym]];
}
else {
here_op = 32 + 64;
here_val = 0;
}
incr = 1 << (len - drop);
fill = 1 << curr;
min = fill;
do {
fill -= incr;
table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
} while (fill !== 0);
incr = 1 << (len - 1);
while (huff & incr) {
incr >>= 1;
}
if (incr !== 0) {
huff &= incr - 1;
huff += incr;
} else {
huff = 0;
}
sym++;
if (--count[len] === 0) {
if (len === max) { break; }
len = lens[lens_index + work[sym]];
}
if (len > root && (huff & mask) !== low) {
if (drop === 0) {
drop = root;
}
next += min;
curr = len - drop;
left = 1 << curr;
while (curr + drop < max) {
left -= count[curr + drop];
if (left <= 0) { break; }
curr++;
left <<= 1;
}
used += 1 << curr;
if ((type === LENS && used > ENOUGH_LENS) ||
(type === DISTS && used > ENOUGH_DISTS)) {
return 1;
}
low = huff & mask;
table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
}
}
if (huff !== 0) {
table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
}
opts.bits = root;
return 0;
};
},{"../utils/common":35}],43:[function(require,module,exports){
module.exports = {
2: 'need dictionary',
1: 'stream end',
0: '',
'-1': 'file error',
'-2': 'stream error',
'-3': 'data error',
'-4': 'insufficient memory',
'-5': 'buffer error',
'-6': 'incompatible version'
};
},{}],44:[function(require,module,exports){
var utils = require('../utils/common');
var Z_FIXED = 4;
var Z_BINARY = 0;
var Z_TEXT = 1;
var Z_UNKNOWN = 2;
function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
var STORED_BLOCK = 0;
var STATIC_TREES = 1;
var DYN_TREES = 2;
var MIN_MATCH = 3;
var MAX_MATCH = 258;
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 Buf_size = 16;
var MAX_BL_BITS = 7;
var END_BLOCK = 256;
var REP_3_6 = 16;
var REPZ_3_10 = 17;
var REPZ_11_138 = 18;
var extra_lbits =
[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];
var extra_dbits =
[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];
var extra_blbits =
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];
var bl_order =
[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
var DIST_CODE_LEN = 512;
var static_ltree = new Array((L_CODES + 2) * 2);
zero(static_ltree);
var static_dtree = new Array(D_CODES * 2);
zero(static_dtree);
var _dist_code = new Array(DIST_CODE_LEN);
zero(_dist_code);
var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
zero(_length_code);
var base_length = new Array(LENGTH_CODES);
zero(base_length);
var base_dist = new Array(D_CODES);
zero(base_dist);
function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
this.static_tree = static_tree;
this.extra_bits = extra_bits;
this.extra_base = extra_base;
this.elems = elems;
this.max_length = max_length;
this.has_stree = static_tree && static_tree.length;
}
var static_l_desc;
var static_d_desc;
var static_bl_desc;
function TreeDesc(dyn_tree, stat_desc) {
this.dyn_tree = dyn_tree;
this.max_code = 0;
this.stat_desc = stat_desc;
}
function d_code(dist) {
return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
}
function put_short(s, w) {
s.pending_buf[s.pending++] = (w) & 0xff;
s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
}
function send_bits(s, value, length) {
if (s.bi_valid > (Buf_size - length)) {
s.bi_buf |= (value << s.bi_valid) & 0xffff;
put_short(s, s.bi_buf);
s.bi_buf = value >> (Buf_size - s.bi_valid);
s.bi_valid += length - Buf_size;
} else {
s.bi_buf |= (value << s.bi_valid) & 0xffff;
s.bi_valid += length;
}
}
function send_code(s, c, tree) {
send_bits(s, tree[c * 2], tree[c * 2 + 1]);
}
function bi_reverse(code, len) {
var res = 0;
do {
res |= code & 1;
code >>>= 1;
res <<= 1;
} while (--len > 0);
return res >>> 1;
}
function bi_flush(s) {
if (s.bi_valid === 16) {
put_short(s, s.bi_buf);
s.bi_buf = 0;
s.bi_valid = 0;
} else if (s.bi_valid >= 8) {
s.pending_buf[s.pending++] = s.bi_buf & 0xff;
s.bi_buf >>= 8;
s.bi_valid -= 8;
}
}
function gen_bitlen(s, desc)
{
var tree = desc.dyn_tree;
var max_code = desc.max_code;
var stree = desc.stat_desc.static_tree;
var has_stree = desc.stat_desc.has_stree;
var extra = desc.stat_desc.extra_bits;
var base = desc.stat_desc.extra_base;
var max_length = desc.stat_desc.max_length;
var h;
var n, m;
var bits;
var xbits;
var f;
var overflow = 0;
for (bits = 0; bits <= MAX_BITS; bits++) {
s.bl_count[bits] = 0;
}
tree[s.heap[s.heap_max] * 2 + 1] = 0;
for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
n = s.heap[h];
bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
if (bits > max_length) {
bits = max_length;
overflow++;
}
tree[n * 2 + 1] = bits;
if (n > max_code) { continue; }
s.bl_count[bits]++;
xbits = 0;
if (n >= base) {
xbits = extra[n - base];
}
f = tree[n * 2];
s.opt_len += f * (bits + xbits);
if (has_stree) {
s.static_len += f * (stree[n * 2 + 1] + xbits);
}
}
if (overflow === 0) { return; }
do {
bits = max_length - 1;
while (s.bl_count[bits] === 0) { bits--; }
s.bl_count[bits]--;
s.bl_count[bits + 1] += 2;
s.bl_count[max_length]--;
overflow -= 2;
} while (overflow > 0);
for (bits = max_length; bits !== 0; bits--) {
n = s.bl_count[bits];
while (n !== 0) {
m = s.heap[--h];
if (m > max_code) { continue; }
if (tree[m * 2 + 1] !== bits) {
s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
tree[m * 2 + 1] = bits;
}
n--;
}
}
}
function gen_codes(tree, max_code, bl_count)
{
var next_code = new Array(MAX_BITS + 1);
var code = 0;
var bits;
var n;
for (bits = 1; bits <= MAX_BITS; bits++) {
next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
}
for (n = 0; n <= max_code; n++) {
var len = tree[n * 2 + 1];
if (len === 0) { continue; }
tree[n * 2] = bi_reverse(next_code[len]++, len);
}
}
function tr_static_init() {
var n;
var bits;
var length;
var code;
var dist;
var bl_count = new Array(MAX_BITS + 1);
length = 0;
for (code = 0; code < LENGTH_CODES - 1; code++) {
base_length[code] = length;
for (n = 0; n < (1 << extra_lbits[code]); n++) {
_length_code[length++] = code;
}
}
_length_code[length - 1] = code;
dist = 0;
for (code = 0; code < 16; code++) {
base_dist[code] = dist;
for (n = 0; n < (1 << extra_dbits[code]); n++) {
_dist_code[dist++] = code;
}
}
dist >>= 7;
for (; code < D_CODES; code++) {
base_dist[code] = dist << 7;
for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
_dist_code[256 + dist++] = code;
}
}
for (bits = 0; bits <= MAX_BITS; bits++) {
bl_count[bits] = 0;
}
n = 0;
while (n <= 143) {
static_ltree[n * 2 + 1] = 8;
n++;
bl_count[8]++;
}
while (n <= 255) {
static_ltree[n * 2 + 1] = 9;
n++;
bl_count[9]++;
}
while (n <= 279) {
static_ltree[n * 2 + 1] = 7;
n++;
bl_count[7]++;
}
while (n <= 287) {
static_ltree[n * 2 + 1] = 8;
n++;
bl_count[8]++;
}
gen_codes(static_ltree, L_CODES + 1, bl_count);
for (n = 0; n < D_CODES; n++) {
static_dtree[n * 2 + 1] = 5;
static_dtree[n * 2] = bi_reverse(n, 5);
}
static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
}
function init_block(s) {
var n;
for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2] = 0; }
for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2] = 0; }
for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2] = 0; }
s.dyn_ltree[END_BLOCK * 2] = 1;
s.opt_len = s.static_len = 0;
s.last_lit = s.matches = 0;
}
function bi_windup(s)
{
if (s.bi_valid > 8) {
put_short(s, s.bi_buf);
} else if (s.bi_valid > 0) {
s.pending_buf[s.pending++] = s.bi_buf;
}
s.bi_buf = 0;
s.bi_valid = 0;
}
function copy_block(s, buf, len, header)
{
bi_windup(s);
if (header) {
put_short(s, len);
put_short(s, ~len);
}
utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
s.pending += len;
}
function smaller(tree, n, m, depth) {
var _n2 = n * 2;
var _m2 = m * 2;
return (tree[_n2] < tree[_m2] ||
(tree[_n2] === tree[_m2] && depth[n] <= depth[m]));
}
function pqdownheap(s, tree, k)
{
var v = s.heap[k];
var j = k << 1;
while (j <= s.heap_len) {
if (j < s.heap_len &&
smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
j++;
}
if (smaller(tree, v, s.heap[j], s.depth)) { break; }
s.heap[k] = s.heap[j];
k = j;
j <<= 1;
}
s.heap[k] = v;
}
function compress_block(s, ltree, dtree)
{
var dist;
var lc;
var lx = 0;
var code;
var extra;
if (s.last_lit !== 0) {
do {
dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
lc = s.pending_buf[s.l_buf + lx];
lx++;
if (dist === 0) {
send_code(s, lc, ltree);
} else {
code = _length_code[lc];
send_code(s, code + LITERALS + 1, ltree);
extra = extra_lbits[code];
if (extra !== 0) {
lc -= base_length[code];
send_bits(s, lc, extra);
}
dist--;
code = d_code(dist);
send_code(s, code, dtree);
extra = extra_dbits[code];
if (extra !== 0) {
dist -= base_dist[code];
send_bits(s, dist, extra);
}
}
} while (lx < s.last_lit);
}
send_code(s, END_BLOCK, ltree);
}
function build_tree(s, desc)
{
var tree = desc.dyn_tree;
var stree = desc.stat_desc.static_tree;
var has_stree = desc.stat_desc.has_stree;
var elems = desc.stat_desc.elems;
var n, m;
var max_code = -1;
var node;
s.heap_len = 0;
s.heap_max = HEAP_SIZE;
for (n = 0; n < elems; n++) {
if (tree[n * 2] !== 0) {
s.heap[++s.heap_len] = max_code = n;
s.depth[n] = 0;
} else {
tree[n * 2 + 1] = 0;
}
}
while (s.heap_len < 2) {
node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
tree[node * 2] = 1;
s.depth[node] = 0;
s.opt_len--;
if (has_stree) {
s.static_len -= stree[node * 2 + 1];
}
}
desc.max_code = max_code;
for (n = (s.heap_len >> 1); n >= 1; n--) { pqdownheap(s, tree, n); }
node = elems;
do {
n = s.heap[1];
s.heap[1] = s.heap[s.heap_len--];
pqdownheap(s, tree, 1);
m = s.heap[1];
s.heap[--s.heap_max] = n;
s.heap[--s.heap_max] = m;
tree[node * 2] = tree[n * 2] + tree[m * 2];
s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
tree[n * 2 + 1] = tree[m * 2 + 1] = node;
s.heap[1] = node++;
pqdownheap(s, tree, 1);
} while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[1];
gen_bitlen(s, desc);
gen_codes(tree, max_code, s.bl_count);
}
function scan_tree(s, tree, max_code)
{
var n;
var prevlen = -1;
var curlen;
var nextlen = tree[0 * 2 + 1];
var count = 0;
var max_count = 7;
var min_count = 4;
if (nextlen === 0) {
max_count = 138;
min_count = 3;
}
tree[(max_code + 1) * 2 + 1] = 0xffff;
for (n = 0; n <= max_code; n++) {
curlen = nextlen;
nextlen = tree[(n + 1) * 2 + 1];
if (++count < max_count && curlen === nextlen) {
continue;
} else if (count < min_count) {
s.bl_tree[curlen * 2] += count;
} else if (curlen !== 0) {
if (curlen !== prevlen) { s.bl_tree[curlen * 2]++; }
s.bl_tree[REP_3_6 * 2]++;
} else if (count <= 10) {
s.bl_tree[REPZ_3_10 * 2]++;
} else {
s.bl_tree[REPZ_11_138 * 2]++;
}
count = 0;
prevlen = curlen;
if (nextlen === 0) {
max_count = 138;
min_count = 3;
} else if (curlen === nextlen) {
max_count = 6;
min_count = 3;
} else {
max_count = 7;
min_count = 4;
}
}
}
function send_tree(s, tree, max_code)
{
var n;
var prevlen = -1;
var curlen;
var nextlen = tree[0 * 2 + 1];
var count = 0;
var max_count = 7;
var min_count = 4;
if (nextlen === 0) {
max_count = 138;
min_count = 3;
}
for (n = 0; n <= max_code; n++) {
curlen = nextlen;
nextlen = tree[(n + 1) * 2 + 1];
if (++count < max_count && curlen === nextlen) {
continue;
} else if (count < min_count) {
do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);
} else if (curlen !== 0) {
if (curlen !== prevlen) {
send_code(s, curlen, s.bl_tree);
count--;
}
send_code(s, REP_3_6, s.bl_tree);
send_bits(s, count - 3, 2);
} else if (count <= 10) {
send_code(s, REPZ_3_10, s.bl_tree);
send_bits(s, count - 3, 3);
} else {
send_code(s, REPZ_11_138, s.bl_tree);
send_bits(s, count - 11, 7);
}
count = 0;
prevlen = curlen;
if (nextlen === 0) {
max_count = 138;
min_count = 3;
} else if (curlen === nextlen) {
max_count = 6;
min_count = 3;
} else {
max_count = 7;
min_count = 4;
}
}
}
function build_bl_tree(s) {
var max_blindex;
scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
build_tree(s, s.bl_desc);
for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) {
break;
}
}
s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
return max_blindex;
}
function send_all_trees(s, lcodes, dcodes, blcodes)
{
var rank;
send_bits(s, lcodes - 257, 5);
send_bits(s, dcodes - 1, 5);
send_bits(s, blcodes - 4, 4);
for (rank = 0; rank < blcodes; rank++) {
send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3);
}
send_tree(s, s.dyn_ltree, lcodes - 1);
send_tree(s, s.dyn_dtree, dcodes - 1);
}
function detect_data_type(s) {
var black_mask = 0xf3ffc07f;
var n;
for (n = 0; n <= 31; n++, black_mask >>>= 1) {
if ((black_mask & 1) && (s.dyn_ltree[n * 2] !== 0)) {
return Z_BINARY;
}
}
if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 ||
s.dyn_ltree[13 * 2] !== 0) {
return Z_TEXT;
}
for (n = 32; n < LITERALS; n++) {
if (s.dyn_ltree[n * 2] !== 0) {
return Z_TEXT;
}
}
return Z_BINARY;
}
var static_init_done = false;
function _tr_init(s)
{
if (!static_init_done) {
tr_static_init();
static_init_done = true;
}
s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
s.bi_buf = 0;
s.bi_valid = 0;
init_block(s);
}
function _tr_stored_block(s, buf, stored_len, last)
{
send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);
copy_block(s, buf, stored_len, true);
}
function _tr_align(s) {
send_bits(s, STATIC_TREES << 1, 3);
send_code(s, END_BLOCK, static_ltree);
bi_flush(s);
}
function _tr_flush_block(s, buf, stored_len, last)
{
var opt_lenb, static_lenb;
var max_blindex = 0;
if (s.level > 0) {
if (s.strm.data_type === Z_UNKNOWN) {
s.strm.data_type = detect_data_type(s);
}
build_tree(s, s.l_desc);
build_tree(s, s.d_desc);
max_blindex = build_bl_tree(s);
opt_lenb = (s.opt_len + 3 + 7) >>> 3;
static_lenb = (s.static_len + 3 + 7) >>> 3;
if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }
} else {
opt_lenb = static_lenb = stored_len + 5;
}
if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {
_tr_stored_block(s, buf, stored_len, last);
} else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
compress_block(s, static_ltree, static_dtree);
} else {
send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
compress_block(s, s.dyn_ltree, s.dyn_dtree);
}
init_block(s);
if (last) {
bi_windup(s);
}
}
function _tr_tally(s, dist, lc)
{
s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;
s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
s.last_lit++;
if (dist === 0) {
s.dyn_ltree[lc * 2]++;
} else {
s.matches++;
dist--;
s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++;
s.dyn_dtree[d_code(dist) * 2]++;
}
return (s.last_lit === s.lit_bufsize - 1);
}
exports._tr_init = _tr_init;
exports._tr_stored_block = _tr_stored_block;
exports._tr_flush_block = _tr_flush_block;
exports._tr_tally = _tr_tally;
exports._tr_align = _tr_align;
},{"../utils/common":35}],45:[function(require,module,exports){
function ZStream() {
this.input = null;
this.next_in = 0;
this.avail_in = 0;
this.total_in = 0;
this.output = null;
this.next_out = 0;
this.avail_out = 0;
this.total_out = 0;
this.msg = '';
this.state = null;
this.data_type = 2;
this.adler = 0;
}
module.exports = ZStream;
},{}],46:[function(require,module,exports){
(function (process){
if (!process.version ||
process.version.indexOf('v0.') === 0 ||
process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
module.exports = nextTick;
} else {
module.exports = process.nextTick;
}
function nextTick(fn, arg1, arg2, arg3) {
if (typeof fn !== 'function') {
throw new TypeError('"callback" argument must be a function');
}
var len = arguments.length;
var args, i;
switch (len) {
case 0:
case 1:
return process.nextTick(fn);
case 2:
return process.nextTick(function afterTickOne() {
fn.call(null, arg1);
});
case 3:
return process.nextTick(function afterTickTwo() {
fn.call(null, arg1, arg2);
});
case 4:
return process.nextTick(function afterTickThree() {
fn.call(null, arg1, arg2, arg3);
});
default:
args = new Array(len - 1);
i = 0;
while (i < args.length) {
args[i++] = arguments[i];
}
return process.nextTick(function afterTick() {
fn.apply(null, args);
});
}
}
}).call(this,require('_process'));
},{"_process":47}],47:[function(require,module,exports){
var process = module.exports = {};
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
} else {
cachedSetTimeout = defaultSetTimout;
}
} catch (e) {
cachedSetTimeout = defaultSetTimout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
} else {
cachedClearTimeout = defaultClearTimeout;
}
} catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
} ());
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
return setTimeout(fun, 0);
}
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
return cachedSetTimeout(fun, 0);
} catch(e){
try {
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
return clearTimeout(marker);
}
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
return cachedClearTimeout(marker);
} catch (e){
try {
return cachedClearTimeout.call(null, marker);
} catch (e){
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
};
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = '';
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) { return [] };
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
},{}],48:[function(require,module,exports){
module.exports = require('./lib/_stream_duplex.js');
},{"./lib/_stream_duplex.js":49}],49:[function(require,module,exports){
var processNextTick = require('process-nextick-args');
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) {
keys.push(key);
}return keys;
};
module.exports = Duplex;
var util = require('core-util-is');
util.inherits = require('inherits');
var Readable = require('./_stream_readable');
var Writable = require('./_stream_writable');
util.inherits(Duplex, Readable);
var keys = objectKeys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
var method = keys[v];
if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}
function Duplex(options) {
if (!(this instanceof Duplex)) return new Duplex(options);
Readable.call(this, options);
Writable.call(this, options);
if (options && options.readable === false) this.readable = false;
if (options && options.writable === false) this.writable = false;
this.allowHalfOpen = true;
if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
this.once('end', onend);
}
function onend() {
if (this.allowHalfOpen || this._writableState.ended) return;
processNextTick(onEndNT, this);
}
function onEndNT(self) {
self.end();
}
Object.defineProperty(Duplex.prototype, 'destroyed', {
get: function () {
if (this._readableState === undefined || this._writableState === undefined) {
return false;
}
return this._readableState.destroyed && this._writableState.destroyed;
},
set: function (value) {
if (this._readableState === undefined || this._writableState === undefined) {
return;
}
this._readableState.destroyed = value;
this._writableState.destroyed = value;
}
});
Duplex.prototype._destroy = function (err, cb) {
this.push(null);
this.end();
processNextTick(cb, err);
};
},{"./_stream_readable":51,"./_stream_writable":53,"core-util-is":29,"inherits":32,"process-nextick-args":46}],50:[function(require,module,exports){
module.exports = PassThrough;
var Transform = require('./_stream_transform');
var util = require('core-util-is');
util.inherits = require('inherits');
util.inherits(PassThrough, Transform);
function PassThrough(options) {
if (!(this instanceof PassThrough)) return new PassThrough(options);
Transform.call(this, options);
}
PassThrough.prototype._transform = function (chunk, encoding, cb) {
cb(null, chunk);
};
},{"./_stream_transform":52,"core-util-is":29,"inherits":32}],51:[function(require,module,exports){
(function (process,global){
var processNextTick = require('process-nextick-args');
module.exports = Readable;
var isArray = require('isarray');
var Duplex;
Readable.ReadableState = ReadableState;
require('events').EventEmitter;
var EElistenerCount = function (emitter, type) {
return emitter.listeners(type).length;
};
var Stream = require('./internal/streams/stream');
var Buffer = require('safe-buffer').Buffer;
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
var util = require('core-util-is');
util.inherits = require('inherits');
var debugUtil = require('util');
var debug = void 0;
if (debugUtil && debugUtil.debuglog) {
debug = debugUtil.debuglog('stream');
} else {
debug = function () {};
}
var BufferList = require('./internal/streams/BufferList');
var destroyImpl = require('./internal/streams/destroy');
var StringDecoder;
util.inherits(Readable, Stream);
var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
function prependListener(emitter, event, fn) {
if (typeof emitter.prependListener === 'function') {
return emitter.prependListener(event, fn);
} else {
if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
}
}
function ReadableState(options, stream) {
Duplex = Duplex || require('./_stream_duplex');
options = options || {};
this.objectMode = !!options.objectMode;
if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
var hwm = options.highWaterMark;
var defaultHwm = this.objectMode ? 16 : 16 * 1024;
this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
this.highWaterMark = Math.floor(this.highWaterMark);
this.buffer = new BufferList();
this.length = 0;
this.pipes = null;
this.pipesCount = 0;
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false;
this.sync = true;
this.needReadable = false;
this.emittedReadable = false;
this.readableListening = false;
this.resumeScheduled = false;
this.destroyed = false;
this.defaultEncoding = options.defaultEncoding || 'utf8';
this.awaitDrain = 0;
this.readingMore = false;
this.decoder = null;
this.encoding = null;
if (options.encoding) {
if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}
function Readable(options) {
Duplex = Duplex || require('./_stream_duplex');
if (!(this instanceof Readable)) return new Readable(options);
this._readableState = new ReadableState(options, this);
this.readable = true;
if (options) {
if (typeof options.read === 'function') this._read = options.read;
if (typeof options.destroy === 'function') this._destroy = options.destroy;
}
Stream.call(this);
}
Object.defineProperty(Readable.prototype, 'destroyed', {
get: function () {
if (this._readableState === undefined) {
return false;
}
return this._readableState.destroyed;
},
set: function (value) {
if (!this._readableState) {
return;
}
this._readableState.destroyed = value;
}
});
Readable.prototype.destroy = destroyImpl.destroy;
Readable.prototype._undestroy = destroyImpl.undestroy;
Readable.prototype._destroy = function (err, cb) {
this.push(null);
cb(err);
};
Readable.prototype.push = function (chunk, encoding) {
var state = this._readableState;
var skipChunkCheck;
if (!state.objectMode) {
if (typeof chunk === 'string') {
encoding = encoding || state.defaultEncoding;
if (encoding !== state.encoding) {
chunk = Buffer.from(chunk, encoding);
encoding = '';
}
skipChunkCheck = true;
}
} else {
skipChunkCheck = true;
}
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
};
Readable.prototype.unshift = function (chunk) {
return readableAddChunk(this, chunk, null, true, false);
};
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
var state = stream._readableState;
if (chunk === null) {
state.reading = false;
onEofChunk(stream, state);
} else {
var er;
if (!skipChunkCheck) er = chunkInvalid(state, chunk);
if (er) {
stream.emit('error', er);
} else if (state.objectMode || chunk && chunk.length > 0) {
if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
chunk = _uint8ArrayToBuffer(chunk);
}
if (addToFront) {
if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
} else if (state.ended) {
stream.emit('error', new Error('stream.push() after EOF'));
} else {
state.reading = false;
if (state.decoder && !encoding) {
chunk = state.decoder.write(chunk);
if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
} else {
addChunk(stream, state, chunk, false);
}
}
} else if (!addToFront) {
state.reading = false;
}
}
return needMoreData(state);
}
function addChunk(stream, state, chunk, addToFront) {
if (state.flowing && state.length === 0 && !state.sync) {
stream.emit('data', chunk);
stream.read(0);
} else {
state.length += state.objectMode ? 1 : chunk.length;
if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
if (state.needReadable) emitReadable(stream);
}
maybeReadMore(stream, state);
}
function chunkInvalid(state, chunk) {
var er;
if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
er = new TypeError('Invalid non-string/buffer chunk');
}
return er;
}
function needMoreData(state) {
return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
}
Readable.prototype.isPaused = function () {
return this._readableState.flowing === false;
};
Readable.prototype.setEncoding = function (enc) {
if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
this._readableState.decoder = new StringDecoder(enc);
this._readableState.encoding = enc;
return this;
};
var MAX_HWM = 0x800000;
function computeNewHighWaterMark(n) {
if (n >= MAX_HWM) {
n = MAX_HWM;
} else {
n--;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
n++;
}
return n;
}
function howMuchToRead(n, state) {
if (n <= 0 || state.length === 0 && state.ended) return 0;
if (state.objectMode) return 1;
if (n !== n) {
if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
}
if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
if (n <= state.length) return n;
if (!state.ended) {
state.needReadable = true;
return 0;
}
return state.length;
}
Readable.prototype.read = function (n) {
debug('read', n);
n = parseInt(n, 10);
var state = this._readableState;
var nOrig = n;
if (n !== 0) state.emittedReadable = false;
if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
debug('read: emitReadable', state.length, state.ended);
if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
return null;
}
n = howMuchToRead(n, state);
if (n === 0 && state.ended) {
if (state.length === 0) endReadable(this);
return null;
}
var doRead = state.needReadable;
debug('need readable', doRead);
if (state.length === 0 || state.length - n < state.highWaterMark) {
doRead = true;
debug('length less than watermark', doRead);
}
if (state.ended || state.reading) {
doRead = false;
debug('reading or ended', doRead);
} else if (doRead) {
debug('do read');
state.reading = true;
state.sync = true;
if (state.length === 0) state.needReadable = true;
this._read(state.highWaterMark);
state.sync = false;
if (!state.reading) n = howMuchToRead(nOrig, state);
}
var ret;
if (n > 0) ret = fromList(n, state);else ret = null;
if (ret === null) {
state.needReadable = true;
n = 0;
} else {
state.length -= n;
}
if (state.length === 0) {
if (!state.ended) state.needReadable = true;
if (nOrig !== n && state.ended) endReadable(this);
}
if (ret !== null) this.emit('data', ret);
return ret;
};
function onEofChunk(stream, state) {
if (state.ended) return;
if (state.decoder) {
var chunk = state.decoder.end();
if (chunk && chunk.length) {
state.buffer.push(chunk);
state.length += state.objectMode ? 1 : chunk.length;
}
}
state.ended = true;
emitReadable(stream);
}
function emitReadable(stream) {
var state = stream._readableState;
state.needReadable = false;
if (!state.emittedReadable) {
debug('emitReadable', state.flowing);
state.emittedReadable = true;
if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);
}
}
function emitReadable_(stream) {
debug('emit readable');
stream.emit('readable');
flow(stream);
}
function maybeReadMore(stream, state) {
if (!state.readingMore) {
state.readingMore = true;
processNextTick(maybeReadMore_, stream, state);
}
}
function maybeReadMore_(stream, state) {
var len = state.length;
while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
debug('maybeReadMore read 0');
stream.read(0);
if (len === state.length)
break;else len = state.length;
}
state.readingMore = false;
}
Readable.prototype._read = function (n) {
this.emit('error', new Error('_read() is not implemented'));
};
Readable.prototype.pipe = function (dest, pipeOpts) {
var src = this;
var state = this._readableState;
switch (state.pipesCount) {
case 0:
state.pipes = dest;
break;
case 1:
state.pipes = [state.pipes, dest];
break;
default:
state.pipes.push(dest);
break;
}
state.pipesCount += 1;
debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
var endFn = doEnd ? onend : unpipe;
if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);
dest.on('unpipe', onunpipe);
function onunpipe(readable, unpipeInfo) {
debug('onunpipe');
if (readable === src) {
if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
unpipeInfo.hasUnpiped = true;
cleanup();
}
}
}
function onend() {
debug('onend');
dest.end();
}
var ondrain = pipeOnDrain(src);
dest.on('drain', ondrain);
var cleanedUp = false;
function cleanup() {
debug('cleanup');
dest.removeListener('close', onclose);
dest.removeListener('finish', onfinish);
dest.removeListener('drain', ondrain);
dest.removeListener('error', onerror);
dest.removeListener('unpipe', onunpipe);
src.removeListener('end', onend);
src.removeListener('end', unpipe);
src.removeListener('data', ondata);
cleanedUp = true;
if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
}
var increasedAwaitDrain = false;
src.on('data', ondata);
function ondata(chunk) {
debug('ondata');
increasedAwaitDrain = false;
var ret = dest.write(chunk);
if (false === ret && !increasedAwaitDrain) {
if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
debug('false write response, pause', src._readableState.awaitDrain);
src._readableState.awaitDrain++;
increasedAwaitDrain = true;
}
src.pause();
}
}
function onerror(er) {
debug('onerror', er);
unpipe();
dest.removeListener('error', onerror);
if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
}
prependListener(dest, 'error', onerror);
function onclose() {
dest.removeListener('finish', onfinish);
unpipe();
}
dest.once('close', onclose);
function onfinish() {
debug('onfinish');
dest.removeListener('close', onclose);
unpipe();
}
dest.once('finish', onfinish);
function unpipe() {
debug('unpipe');
src.unpipe(dest);
}
dest.emit('pipe', src);
if (!state.flowing) {
debug('pipe resume');
src.resume();
}
return dest;
};
function pipeOnDrain(src) {
return function () {
var state = src._readableState;
debug('pipeOnDrain', state.awaitDrain);
if (state.awaitDrain) state.awaitDrain--;
if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
state.flowing = true;
flow(src);
}
};
}
Readable.prototype.unpipe = function (dest) {
var state = this._readableState;
var unpipeInfo = { hasUnpiped: false };
if (state.pipesCount === 0) return this;
if (state.pipesCount === 1) {
if (dest && dest !== state.pipes) return this;
if (!dest) dest = state.pipes;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
if (dest) dest.emit('unpipe', this, unpipeInfo);
return this;
}
if (!dest) {
var dests = state.pipes;
var len = state.pipesCount;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
for (var i = 0; i < len; i++) {
dests[i].emit('unpipe', this, unpipeInfo);
}return this;
}
var index = indexOf(state.pipes, dest);
if (index === -1) return this;
state.pipes.splice(index, 1);
state.pipesCount -= 1;
if (state.pipesCount === 1) state.pipes = state.pipes[0];
dest.emit('unpipe', this, unpipeInfo);
return this;
};
Readable.prototype.on = function (ev, fn) {
var res = Stream.prototype.on.call(this, ev, fn);
if (ev === 'data') {
if (this._readableState.flowing !== false) this.resume();
} else if (ev === 'readable') {
var state = this._readableState;
if (!state.endEmitted && !state.readableListening) {
state.readableListening = state.needReadable = true;
state.emittedReadable = false;
if (!state.reading) {
processNextTick(nReadingNextTick, this);
} else if (state.length) {
emitReadable(this);
}
}
}
return res;
};
Readable.prototype.addListener = Readable.prototype.on;
function nReadingNextTick(self) {
debug('readable nexttick read 0');
self.read(0);
}
Readable.prototype.resume = function () {
var state = this._readableState;
if (!state.flowing) {
debug('resume');
state.flowing = true;
resume(this, state);
}
return this;
};
function resume(stream, state) {
if (!state.resumeScheduled) {
state.resumeScheduled = true;
processNextTick(resume_, stream, state);
}
}
function resume_(stream, state) {
if (!state.reading) {
debug('resume read 0');
stream.read(0);
}
state.resumeScheduled = false;
state.awaitDrain = 0;
stream.emit('resume');
flow(stream);
if (state.flowing && !state.reading) stream.read(0);
}
Readable.prototype.pause = function () {
debug('call pause flowing=%j', this._readableState.flowing);
if (false !== this._readableState.flowing) {
debug('pause');
this._readableState.flowing = false;
this.emit('pause');
}
return this;
};
function flow(stream) {
var state = stream._readableState;
debug('flow', state.flowing);
while (state.flowing && stream.read() !== null) {}
}
Readable.prototype.wrap = function (stream) {
var state = this._readableState;
var paused = false;
var self = this;
stream.on('end', function () {
debug('wrapped end');
if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length) self.push(chunk);
}
self.push(null);
});
stream.on('data', function (chunk) {
debug('wrapped data');
if (state.decoder) chunk = state.decoder.write(chunk);
if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
var ret = self.push(chunk);
if (!ret) {
paused = true;
stream.pause();
}
});
for (var i in stream) {
if (this[i] === undefined && typeof stream[i] === 'function') {
this[i] = function (method) {
return function () {
return stream[method].apply(stream, arguments);
};
}(i);
}
}
for (var n = 0; n < kProxyEvents.length; n++) {
stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));
}
self._read = function (n) {
debug('wrapped _read', n);
if (paused) {
paused = false;
stream.resume();
}
};
return self;
};
Readable._fromList = fromList;
function fromList(n, state) {
if (state.length === 0) return null;
var ret;
if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
state.buffer.clear();
} else {
ret = fromListPartial(n, state.buffer, state.decoder);
}
return ret;
}
function fromListPartial(n, list, hasStrings) {
var ret;
if (n < list.head.data.length) {
ret = list.head.data.slice(0, n);
list.head.data = list.head.data.slice(n);
} else if (n === list.head.data.length) {
ret = list.shift();
} else {
ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
}
return ret;
}
function copyFromBufferString(n, list) {
var p = list.head;
var c = 1;
var ret = p.data;
n -= ret.length;
while (p = p.next) {
var str = p.data;
var nb = n > str.length ? str.length : n;
if (nb === str.length) ret += str;else ret += str.slice(0, n);
n -= nb;
if (n === 0) {
if (nb === str.length) {
++c;
if (p.next) list.head = p.next;else list.head = list.tail = null;
} else {
list.head = p;
p.data = str.slice(nb);
}
break;
}
++c;
}
list.length -= c;
return ret;
}
function copyFromBuffer(n, list) {
var ret = Buffer.allocUnsafe(n);
var p = list.head;
var c = 1;
p.data.copy(ret);
n -= p.data.length;
while (p = p.next) {
var buf = p.data;
var nb = n > buf.length ? buf.length : n;
buf.copy(ret, ret.length - n, 0, nb);
n -= nb;
if (n === 0) {
if (nb === buf.length) {
++c;
if (p.next) list.head = p.next;else list.head = list.tail = null;
} else {
list.head = p;
p.data = buf.slice(nb);
}
break;
}
++c;
}
list.length -= c;
return ret;
}
function endReadable(stream) {
var state = stream._readableState;
if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
if (!state.endEmitted) {
state.ended = true;
processNextTick(endReadableNT, state, stream);
}
}
function endReadableNT(state, stream) {
if (!state.endEmitted && state.length === 0) {
state.endEmitted = true;
stream.readable = false;
stream.emit('end');
}
}
function indexOf(xs, x) {
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}
}).call(this,require('_process'),typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
},{"./_stream_duplex":49,"./internal/streams/BufferList":54,"./internal/streams/destroy":55,"./internal/streams/stream":56,"_process":47,"core-util-is":29,"events":30,"inherits":32,"isarray":34,"process-nextick-args":46,"safe-buffer":62,"string_decoder/":57,"util":25}],52:[function(require,module,exports){
module.exports = Transform;
var Duplex = require('./_stream_duplex');
var util = require('core-util-is');
util.inherits = require('inherits');
util.inherits(Transform, Duplex);
function TransformState(stream) {
this.afterTransform = function (er, data) {
return afterTransform(stream, er, data);
};
this.needTransform = false;
this.transforming = false;
this.writecb = null;
this.writechunk = null;
this.writeencoding = null;
}
function afterTransform(stream, er, data) {
var ts = stream._transformState;
ts.transforming = false;
var cb = ts.writecb;
if (!cb) {
return stream.emit('error', new Error('write callback called multiple times'));
}
ts.writechunk = null;
ts.writecb = null;
if (data !== null && data !== undefined) stream.push(data);
cb(er);
var rs = stream._readableState;
rs.reading = false;
if (rs.needReadable || rs.length < rs.highWaterMark) {
stream._read(rs.highWaterMark);
}
}
function Transform(options) {
if (!(this instanceof Transform)) return new Transform(options);
Duplex.call(this, options);
this._transformState = new TransformState(this);
var stream = this;
this._readableState.needReadable = true;
this._readableState.sync = false;
if (options) {
if (typeof options.transform === 'function') this._transform = options.transform;
if (typeof options.flush === 'function') this._flush = options.flush;
}
this.once('prefinish', function () {
if (typeof this._flush === 'function') this._flush(function (er, data) {
done(stream, er, data);
});else done(stream);
});
}
Transform.prototype.push = function (chunk, encoding) {
this._transformState.needTransform = false;
return Duplex.prototype.push.call(this, chunk, encoding);
};
Transform.prototype._transform = function (chunk, encoding, cb) {
throw new Error('_transform() is not implemented');
};
Transform.prototype._write = function (chunk, encoding, cb) {
var ts = this._transformState;
ts.writecb = cb;
ts.writechunk = chunk;
ts.writeencoding = encoding;
if (!ts.transforming) {
var rs = this._readableState;
if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
}
};
Transform.prototype._read = function (n) {
var ts = this._transformState;
if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
ts.transforming = true;
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
} else {
ts.needTransform = true;
}
};
Transform.prototype._destroy = function (err, cb) {
var _this = this;
Duplex.prototype._destroy.call(this, err, function (err2) {
cb(err2);
_this.emit('close');
});
};
function done(stream, er, data) {
if (er) return stream.emit('error', er);
if (data !== null && data !== undefined) stream.push(data);
var ws = stream._writableState;
var ts = stream._transformState;
if (ws.length) throw new Error('Calling transform done when ws.length != 0');
if (ts.transforming) throw new Error('Calling transform done when still transforming');
return stream.push(null);
}
},{"./_stream_duplex":49,"core-util-is":29,"inherits":32}],53:[function(require,module,exports){
(function (process,global){
var processNextTick = require('process-nextick-args');
module.exports = Writable;
function CorkedRequest(state) {
var _this = this;
this.next = null;
this.entry = null;
this.finish = function () {
onCorkedFinish(_this, state);
};
}
var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;
var Duplex;
Writable.WritableState = WritableState;
var util = require('core-util-is');
util.inherits = require('inherits');
var internalUtil = {
deprecate: require('util-deprecate')
};
var Stream = require('./internal/streams/stream');
var Buffer = require('safe-buffer').Buffer;
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
var destroyImpl = require('./internal/streams/destroy');
util.inherits(Writable, Stream);
function nop() {}
function WritableState(options, stream) {
Duplex = Duplex || require('./_stream_duplex');
options = options || {};
this.objectMode = !!options.objectMode;
if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
var hwm = options.highWaterMark;
var defaultHwm = this.objectMode ? 16 : 16 * 1024;
this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
this.highWaterMark = Math.floor(this.highWaterMark);
this.finalCalled = false;
this.needDrain = false;
this.ending = false;
this.ended = false;
this.finished = false;
this.destroyed = false;
var noDecode = options.decodeStrings === false;
this.decodeStrings = !noDecode;
this.defaultEncoding = options.defaultEncoding || 'utf8';
this.length = 0;
this.writing = false;
this.corked = 0;
this.sync = true;
this.bufferProcessing = false;
this.onwrite = function (er) {
onwrite(stream, er);
};
this.writecb = null;
this.writelen = 0;
this.bufferedRequest = null;
this.lastBufferedRequest = null;
this.pendingcb = 0;
this.prefinished = false;
this.errorEmitted = false;
this.bufferedRequestCount = 0;
this.corkedRequestsFree = new CorkedRequest(this);
}
WritableState.prototype.getBuffer = function getBuffer() {
var current = this.bufferedRequest;
var out = [];
while (current) {
out.push(current);
current = current.next;
}
return out;
};
(function () {
try {
Object.defineProperty(WritableState.prototype, 'buffer', {
get: internalUtil.deprecate(function () {
return this.getBuffer();
}, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
});
} catch (_) {}
})();
var realHasInstance;
if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
realHasInstance = Function.prototype[Symbol.hasInstance];
Object.defineProperty(Writable, Symbol.hasInstance, {
value: function (object) {
if (realHasInstance.call(this, object)) return true;
return object && object._writableState instanceof WritableState;
}
});
} else {
realHasInstance = function (object) {
return object instanceof this;
};
}
function Writable(options) {
Duplex = Duplex || require('./_stream_duplex');
if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
return new Writable(options);
}
this._writableState = new WritableState(options, this);
this.writable = true;
if (options) {
if (typeof options.write === 'function') this._write = options.write;
if (typeof options.writev === 'function') this._writev = options.writev;
if (typeof options.destroy === 'function') this._destroy = options.destroy;
if (typeof options.final === 'function') this._final = options.final;
}
Stream.call(this);
}
Writable.prototype.pipe = function () {
this.emit('error', new Error('Cannot pipe, not readable'));
};
function writeAfterEnd(stream, cb) {
var er = new Error('write after end');
stream.emit('error', er);
processNextTick(cb, er);
}
function validChunk(stream, state, chunk, cb) {
var valid = true;
var er = false;
if (chunk === null) {
er = new TypeError('May not write null values to stream');
} else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
er = new TypeError('Invalid non-string/buffer chunk');
}
if (er) {
stream.emit('error', er);
processNextTick(cb, er);
valid = false;
}
return valid;
}
Writable.prototype.write = function (chunk, encoding, cb) {
var state = this._writableState;
var ret = false;
var isBuf = _isUint8Array(chunk) && !state.objectMode;
if (isBuf && !Buffer.isBuffer(chunk)) {
chunk = _uint8ArrayToBuffer(chunk);
}
if (typeof encoding === 'function') {
cb = encoding;
encoding = null;
}
if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
if (typeof cb !== 'function') cb = nop;
if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
state.pendingcb++;
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
}
return ret;
};
Writable.prototype.cork = function () {
var state = this._writableState;
state.corked++;
};
Writable.prototype.uncork = function () {
var state = this._writableState;
if (state.corked) {
state.corked--;
if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
}
};
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
if (typeof encoding === 'string') encoding = encoding.toLowerCase();
if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
this._writableState.defaultEncoding = encoding;
return this;
};
function decodeChunk(state, chunk, encoding) {
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
chunk = Buffer.from(chunk, encoding);
}
return chunk;
}
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
if (!isBuf) {
var newChunk = decodeChunk(state, chunk, encoding);
if (chunk !== newChunk) {
isBuf = true;
encoding = 'buffer';
chunk = newChunk;
}
}
var len = state.objectMode ? 1 : chunk.length;
state.length += len;
var ret = state.length < state.highWaterMark;
if (!ret) state.needDrain = true;
if (state.writing || state.corked) {
var last = state.lastBufferedRequest;
state.lastBufferedRequest = {
chunk: chunk,
encoding: encoding,
isBuf: isBuf,
callback: cb,
next: null
};
if (last) {
last.next = state.lastBufferedRequest;
} else {
state.bufferedRequest = state.lastBufferedRequest;
}
state.bufferedRequestCount += 1;
} else {
doWrite(stream, state, false, len, chunk, encoding, cb);
}
return ret;
}
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
state.writelen = len;
state.writecb = cb;
state.writing = true;
state.sync = true;
if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
state.sync = false;
}
function onwriteError(stream, state, sync, er, cb) {
--state.pendingcb;
if (sync) {
processNextTick(cb, er);
processNextTick(finishMaybe, stream, state);
stream._writableState.errorEmitted = true;
stream.emit('error', er);
} else {
cb(er);
stream._writableState.errorEmitted = true;
stream.emit('error', er);
finishMaybe(stream, state);
}
}
function onwriteStateUpdate(state) {
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;
}
function onwrite(stream, er) {
var state = stream._writableState;
var sync = state.sync;
var cb = state.writecb;
onwriteStateUpdate(state);
if (er) onwriteError(stream, state, sync, er, cb);else {
var finished = needFinish(state);
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
clearBuffer(stream, state);
}
if (sync) {
asyncWrite(afterWrite, stream, state, finished, cb);
} else {
afterWrite(stream, state, finished, cb);
}
}
}
function afterWrite(stream, state, finished, cb) {
if (!finished) onwriteDrain(stream, state);
state.pendingcb--;
cb();
finishMaybe(stream, state);
}
function onwriteDrain(stream, state) {
if (state.length === 0 && state.needDrain) {
state.needDrain = false;
stream.emit('drain');
}
}
function clearBuffer(stream, state) {
state.bufferProcessing = true;
var entry = state.bufferedRequest;
if (stream._writev && entry && entry.next) {
var l = state.bufferedRequestCount;
var buffer = new Array(l);
var holder = state.corkedRequestsFree;
holder.entry = entry;
var count = 0;
var allBuffers = true;
while (entry) {
buffer[count] = entry;
if (!entry.isBuf) allBuffers = false;
entry = entry.next;
count += 1;
}
buffer.allBuffers = allBuffers;
doWrite(stream, state, true, state.length, buffer, '', holder.finish);
state.pendingcb++;
state.lastBufferedRequest = null;
if (holder.next) {
state.corkedRequestsFree = holder.next;
holder.next = null;
} else {
state.corkedRequestsFree = new CorkedRequest(state);
}
} else {
while (entry) {
var chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
var len = state.objectMode ? 1 : chunk.length;
doWrite(stream, state, false, len, chunk, encoding, cb);
entry = entry.next;
if (state.writing) {
break;
}
}
if (entry === null) state.lastBufferedRequest = null;
}
state.bufferedRequestCount = 0;
state.bufferedRequest = entry;
state.bufferProcessing = false;
}
Writable.prototype._write = function (chunk, encoding, cb) {
cb(new Error('_write() is not implemented'));
};
Writable.prototype._writev = null;
Writable.prototype.end = function (chunk, encoding, cb) {
var state = this._writableState;
if (typeof chunk === 'function') {
cb = chunk;
chunk = null;
encoding = null;
} else if (typeof encoding === 'function') {
cb = encoding;
encoding = null;
}
if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
if (state.corked) {
state.corked = 1;
this.uncork();
}
if (!state.ending && !state.finished) endWritable(this, state, cb);
};
function needFinish(state) {
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
function callFinal(stream, state) {
stream._final(function (err) {
state.pendingcb--;
if (err) {
stream.emit('error', err);
}
state.prefinished = true;
stream.emit('prefinish');
finishMaybe(stream, state);
});
}
function prefinish(stream, state) {
if (!state.prefinished && !state.finalCalled) {
if (typeof stream._final === 'function') {
state.pendingcb++;
state.finalCalled = true;
processNextTick(callFinal, stream, state);
} else {
state.prefinished = true;
stream.emit('prefinish');
}
}
}
function finishMaybe(stream, state) {
var need = needFinish(state);
if (need) {
prefinish(stream, state);
if (state.pendingcb === 0) {
state.finished = true;
stream.emit('finish');
}
}
return need;
}
function endWritable(stream, state, cb) {
state.ending = true;
finishMaybe(stream, state);
if (cb) {
if (state.finished) processNextTick(cb);else stream.once('finish', cb);
}
state.ended = true;
stream.writable = false;
}
function onCorkedFinish(corkReq, state, err) {
var entry = corkReq.entry;
corkReq.entry = null;
while (entry) {
var cb = entry.callback;
state.pendingcb--;
cb(err);
entry = entry.next;
}
if (state.corkedRequestsFree) {
state.corkedRequestsFree.next = corkReq;
} else {
state.corkedRequestsFree = corkReq;
}
}
Object.defineProperty(Writable.prototype, 'destroyed', {
get: function () {
if (this._writableState === undefined) {
return false;
}
return this._writableState.destroyed;
},
set: function (value) {
if (!this._writableState) {
return;
}
this._writableState.destroyed = value;
}
});
Writable.prototype.destroy = destroyImpl.destroy;
Writable.prototype._undestroy = destroyImpl.undestroy;
Writable.prototype._destroy = function (err, cb) {
this.end();
cb(err);
};
}).call(this,require('_process'),typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
},{"./_stream_duplex":49,"./internal/streams/destroy":55,"./internal/streams/stream":56,"_process":47,"core-util-is":29,"inherits":32,"process-nextick-args":46,"safe-buffer":62,"util-deprecate":64}],54:[function(require,module,exports){
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Buffer = require('safe-buffer').Buffer;
function copyBuffer(src, target, offset) {
src.copy(target, offset);
}
module.exports = function () {
function BufferList() {
_classCallCheck(this, BufferList);
this.head = null;
this.tail = null;
this.length = 0;
}
BufferList.prototype.push = function push(v) {
var entry = { data: v, next: null };
if (this.length > 0) this.tail.next = entry;else this.head = entry;
this.tail = entry;
++this.length;
};
BufferList.prototype.unshift = function unshift(v) {
var entry = { data: v, next: this.head };
if (this.length === 0) this.tail = entry;
this.head = entry;
++this.length;
};
BufferList.prototype.shift = function shift() {
if (this.length === 0) return;
var ret = this.head.data;
if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
--this.length;
return ret;
};
BufferList.prototype.clear = function clear() {
this.head = this.tail = null;
this.length = 0;
};
BufferList.prototype.join = function join(s) {
if (this.length === 0) return '';
var p = this.head;
var ret = '' + p.data;
while (p = p.next) {
ret += s + p.data;
}return ret;
};
BufferList.prototype.concat = function concat(n) {
if (this.length === 0) return Buffer.alloc(0);
if (this.length === 1) return this.head.data;
var ret = Buffer.allocUnsafe(n >>> 0);
var p = this.head;
var i = 0;
while (p) {
copyBuffer(p.data, ret, i);
i += p.data.length;
p = p.next;
}
return ret;
};
return BufferList;
}();
},{"safe-buffer":62}],55:[function(require,module,exports){
var processNextTick = require('process-nextick-args');
function destroy(err, cb) {
var _this = this;
var readableDestroyed = this._readableState && this._readableState.destroyed;
var writableDestroyed = this._writableState && this._writableState.destroyed;
if (readableDestroyed || writableDestroyed) {
if (cb) {
cb(err);
} else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
processNextTick(emitErrorNT, this, err);
}
return;
}
if (this._readableState) {
this._readableState.destroyed = true;
}
if (this._writableState) {
this._writableState.destroyed = true;
}
this._destroy(err || null, function (err) {
if (!cb && err) {
processNextTick(emitErrorNT, _this, err);
if (_this._writableState) {
_this._writableState.errorEmitted = true;
}
} else if (cb) {
cb(err);
}
});
}
function undestroy() {
if (this._readableState) {
this._readableState.destroyed = false;
this._readableState.reading = false;
this._readableState.ended = false;
this._readableState.endEmitted = false;
}
if (this._writableState) {
this._writableState.destroyed = false;
this._writableState.ended = false;
this._writableState.ending = false;
this._writableState.finished = false;
this._writableState.errorEmitted = false;
}
}
function emitErrorNT(self, err) {
self.emit('error', err);
}
module.exports = {
destroy: destroy,
undestroy: undestroy
};
},{"process-nextick-args":46}],56:[function(require,module,exports){
module.exports = require('events').EventEmitter;
},{"events":30}],57:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer;
var isEncoding = Buffer.isEncoding || function (encoding) {
encoding = '' + encoding;
switch (encoding && encoding.toLowerCase()) {
case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
return true;
default:
return false;
}
};
function _normalizeEncoding(enc) {
if (!enc) return 'utf8';
var retried;
while (true) {
switch (enc) {
case 'utf8':
case 'utf-8':
return 'utf8';
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return 'utf16le';
case 'latin1':
case 'binary':
return 'latin1';
case 'base64':
case 'ascii':
case 'hex':
return enc;
default:
if (retried) return;
enc = ('' + enc).toLowerCase();
retried = true;
}
}
}function normalizeEncoding(enc) {
var nenc = _normalizeEncoding(enc);
if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
return nenc || enc;
}
exports.StringDecoder = StringDecoder;
function StringDecoder(encoding) {
this.encoding = normalizeEncoding(encoding);
var nb;
switch (this.encoding) {
case 'utf16le':
this.text = utf16Text;
this.end = utf16End;
nb = 4;
break;
case 'utf8':
this.fillLast = utf8FillLast;
nb = 4;
break;
case 'base64':
this.text = base64Text;
this.end = base64End;
nb = 3;
break;
default:
this.write = simpleWrite;
this.end = simpleEnd;
return;
}
this.lastNeed = 0;
this.lastTotal = 0;
this.lastChar = Buffer.allocUnsafe(nb);
}
StringDecoder.prototype.write = function (buf) {
if (buf.length === 0) return '';
var r;
var i;
if (this.lastNeed) {
r = this.fillLast(buf);
if (r === undefined) return '';
i = this.lastNeed;
this.lastNeed = 0;
} else {
i = 0;
}
if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
return r || '';
};
StringDecoder.prototype.end = utf8End;
StringDecoder.prototype.text = utf8Text;
StringDecoder.prototype.fillLast = function (buf) {
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
this.lastNeed -= buf.length;
};
function utf8CheckByte(byte) {
if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
return -1;
}
function utf8CheckIncomplete(self, buf, i) {
var j = buf.length - 1;
if (j < i) return 0;
var nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.lastNeed = nb - 1;
return nb;
}
if (--j < i) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.lastNeed = nb - 2;
return nb;
}
if (--j < i) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) {
if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
}
return nb;
}
return 0;
}
function utf8CheckExtraBytes(self, buf, p) {
if ((buf[0] & 0xC0) !== 0x80) {
self.lastNeed = 0;
return '\ufffd'.repeat(p);
}
if (self.lastNeed > 1 && buf.length > 1) {
if ((buf[1] & 0xC0) !== 0x80) {
self.lastNeed = 1;
return '\ufffd'.repeat(p + 1);
}
if (self.lastNeed > 2 && buf.length > 2) {
if ((buf[2] & 0xC0) !== 0x80) {
self.lastNeed = 2;
return '\ufffd'.repeat(p + 2);
}
}
}
}
function utf8FillLast(buf) {
var p = this.lastTotal - this.lastNeed;
var r = utf8CheckExtraBytes(this, buf, p);
if (r !== undefined) return r;
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, p, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, p, 0, buf.length);
this.lastNeed -= buf.length;
}
function utf8Text(buf, i) {
var total = utf8CheckIncomplete(this, buf, i);
if (!this.lastNeed) return buf.toString('utf8', i);
this.lastTotal = total;
var end = buf.length - (total - this.lastNeed);
buf.copy(this.lastChar, 0, end);
return buf.toString('utf8', i, end);
}
function utf8End(buf) {
var r = buf && buf.length ? this.write(buf) : '';
if (this.lastNeed) return r + '\ufffd'.repeat(this.lastTotal - this.lastNeed);
return r;
}
function utf16Text(buf, i) {
if ((buf.length - i) % 2 === 0) {
var r = buf.toString('utf16le', i);
if (r) {
var c = r.charCodeAt(r.length - 1);
if (c >= 0xD800 && c <= 0xDBFF) {
this.lastNeed = 2;
this.lastTotal = 4;
this.lastChar[0] = buf[buf.length - 2];
this.lastChar[1] = buf[buf.length - 1];
return r.slice(0, -1);
}
}
return r;
}
this.lastNeed = 1;
this.lastTotal = 2;
this.lastChar[0] = buf[buf.length - 1];
return buf.toString('utf16le', i, buf.length - 1);
}
function utf16End(buf) {
var r = buf && buf.length ? this.write(buf) : '';
if (this.lastNeed) {
var end = this.lastTotal - this.lastNeed;
return r + this.lastChar.toString('utf16le', 0, end);
}
return r;
}
function base64Text(buf, i) {
var n = (buf.length - i) % 3;
if (n === 0) return buf.toString('base64', i);
this.lastNeed = 3 - n;
this.lastTotal = 3;
if (n === 1) {
this.lastChar[0] = buf[buf.length - 1];
} else {
this.lastChar[0] = buf[buf.length - 2];
this.lastChar[1] = buf[buf.length - 1];
}
return buf.toString('base64', i, buf.length - n);
}
function base64End(buf) {
var r = buf && buf.length ? this.write(buf) : '';
if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
return r;
}
function simpleWrite(buf) {
return buf.toString(this.encoding);
}
function simpleEnd(buf) {
return buf && buf.length ? this.write(buf) : '';
}
},{"safe-buffer":62}],58:[function(require,module,exports){
module.exports = require('./readable').PassThrough;
},{"./readable":59}],59:[function(require,module,exports){
exports = module.exports = require('./lib/_stream_readable.js');
exports.Stream = exports;
exports.Readable = exports;
exports.Writable = require('./lib/_stream_writable.js');
exports.Duplex = require('./lib/_stream_duplex.js');
exports.Transform = require('./lib/_stream_transform.js');
exports.PassThrough = require('./lib/_stream_passthrough.js');
},{"./lib/_stream_duplex.js":49,"./lib/_stream_passthrough.js":50,"./lib/_stream_readable.js":51,"./lib/_stream_transform.js":52,"./lib/_stream_writable.js":53}],60:[function(require,module,exports){
module.exports = require('./readable').Transform;
},{"./readable":59}],61:[function(require,module,exports){
module.exports = require('./lib/_stream_writable.js');
},{"./lib/_stream_writable.js":53}],62:[function(require,module,exports){
var buffer = require('buffer');
var Buffer = buffer.Buffer;
function copyProps (src, dst) {
for (var key in src) {
dst[key] = src[key];
}
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
module.exports = buffer;
} else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer (arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length)
}
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function (arg, encodingOrOffset, length) {
if (typeof arg === 'number') {
throw new TypeError('Argument must not be a number')
}
return Buffer(arg, encodingOrOffset, length)
};
SafeBuffer.alloc = function (size, fill, encoding) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
var buf = Buffer(size);
if (fill !== undefined) {
if (typeof encoding === 'string') {
buf.fill(fill, encoding);
} else {
buf.fill(fill);
}
} else {
buf.fill(0);
}
return buf
};
SafeBuffer.allocUnsafe = function (size) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return Buffer(size)
};
SafeBuffer.allocUnsafeSlow = function (size) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return buffer.SlowBuffer(size)
};
},{"buffer":28}],63:[function(require,module,exports){
module.exports = Stream;
var EE = require('events').EventEmitter;
var inherits = require('inherits');
inherits(Stream, EE);
Stream.Readable = require('readable-stream/readable.js');
Stream.Writable = require('readable-stream/writable.js');
Stream.Duplex = require('readable-stream/duplex.js');
Stream.Transform = require('readable-stream/transform.js');
Stream.PassThrough = require('readable-stream/passthrough.js');
Stream.Stream = Stream;
function Stream() {
EE.call(this);
}
Stream.prototype.pipe = function(dest, options) {
var source = this;
function ondata(chunk) {
if (dest.writable) {
if (false === dest.write(chunk) && source.pause) {
source.pause();
}
}
}
source.on('data', ondata);
function ondrain() {
if (source.readable && source.resume) {
source.resume();
}
}
dest.on('drain', ondrain);
if (!dest._isStdio && (!options || options.end !== false)) {
source.on('end', onend);
source.on('close', onclose);
}
var didOnEnd = false;
function onend() {
if (didOnEnd) return;
didOnEnd = true;
dest.end();
}
function onclose() {
if (didOnEnd) return;
didOnEnd = true;
if (typeof dest.destroy === 'function') dest.destroy();
}
function onerror(er) {
cleanup();
if (EE.listenerCount(this, 'error') === 0) {
throw er;
}
}
source.on('error', onerror);
dest.on('error', onerror);
function cleanup() {
source.removeListener('data', ondata);
dest.removeListener('drain', ondrain);
source.removeListener('end', onend);
source.removeListener('close', onclose);
source.removeListener('error', onerror);
dest.removeListener('error', onerror);
source.removeListener('end', cleanup);
source.removeListener('close', cleanup);
dest.removeListener('close', cleanup);
}
source.on('end', cleanup);
source.on('close', cleanup);
dest.on('close', cleanup);
dest.emit('pipe', source);
return dest;
};
},{"events":30,"inherits":32,"readable-stream/duplex.js":48,"readable-stream/passthrough.js":58,"readable-stream/readable.js":59,"readable-stream/transform.js":60,"readable-stream/writable.js":61}],64:[function(require,module,exports){
(function (global){
module.exports = deprecate;
function deprecate (fn, msg) {
if (config('noDeprecation')) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (config('throwDeprecation')) {
throw new Error(msg);
} else if (config('traceDeprecation')) {
console.trace(msg);
} else {
console.warn(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
}
function config (name) {
try {
if (!global.localStorage) return false;
} catch (_) {
return false;
}
var val = global.localStorage[name];
if (null == val) return false;
return String(val).toLowerCase() === 'true';
}
}).call(this,typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
},{}],65:[function(require,module,exports){
arguments[4][32][0].apply(exports,arguments);
},{"dup":32}],66:[function(require,module,exports){
module.exports = function isBuffer(arg) {
return arg && typeof arg === 'object'
&& typeof arg.copy === 'function'
&& typeof arg.fill === 'function'
&& typeof arg.readUInt8 === 'function';
};
},{}],67:[function(require,module,exports){
(function (process,global){
var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
if (!isString(f)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(inspect(arguments[i]));
}
return objects.join(' ');
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (x === '%%') return '%';
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j':
try {
return JSON.stringify(args[i++]);
} catch (_) {
return '[Circular]';
}
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull(x) || !isObject(x)) {
str += ' ' + x;
} else {
str += ' ' + inspect(x);
}
}
return str;
};
exports.deprecate = function(fn, msg) {
if (isUndefined(global.process)) {
return function() {
return exports.deprecate(fn, msg).apply(this, arguments);
};
}
if (process.noDeprecation === true) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (process.throwDeprecation) {
throw new Error(msg);
} else if (process.traceDeprecation) {
console.trace(msg);
} else {
console.error(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
};
var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
if (isUndefined(debugEnviron))
debugEnviron = process.env.NODE_DEBUG || '';
set = set.toUpperCase();
if (!debugs[set]) {
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
var pid = process.pid;
debugs[set] = function() {
var msg = exports.format.apply(exports, arguments);
console.error('%s %d: %s', set, pid, msg);
};
} else {
debugs[set] = function() {};
}
}
return debugs[set];
};
function inspect(obj, opts) {
var ctx = {
seen: [],
stylize: stylizeNoColor
};
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean(opts)) {
ctx.showHidden = opts;
} else if (opts) {
exports._extend(ctx, opts);
}
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined(ctx.depth)) ctx.depth = 2;
if (isUndefined(ctx.colors)) ctx.colors = false;
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;
inspect.colors = {
'bold' : [1, 22],
'italic' : [3, 23],
'underline' : [4, 24],
'inverse' : [7, 27],
'white' : [37, 39],
'grey' : [90, 39],
'black' : [30, 39],
'blue' : [34, 39],
'cyan' : [36, 39],
'green' : [32, 39],
'magenta' : [35, 39],
'red' : [31, 39],
'yellow' : [33, 39]
};
inspect.styles = {
'special': 'cyan',
'number': 'yellow',
'boolean': 'yellow',
'undefined': 'grey',
'null': 'bold',
'string': 'green',
'date': 'magenta',
'regexp': 'red'
};
function stylizeWithColor(str, styleType) {
var style = inspect.styles[styleType];
if (style) {
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
'\u001b[' + inspect.colors[style][1] + 'm';
} else {
return str;
}
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash = {};
array.forEach(function(val, idx) {
hash[val] = true;
});
return hash;
}
function formatValue(ctx, value, recurseTimes) {
if (ctx.customInspect &&
value &&
isFunction(value.inspect) &&
value.inspect !== exports.inspect &&
!(value.constructor && value.constructor.prototype === value)) {
var ret = value.inspect(recurseTimes, ctx);
if (!isString(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}
var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}
var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);
if (ctx.showHidden) {
keys = Object.getOwnPropertyNames(value);
}
if (isError(value)
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
return formatError(value);
}
if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ': ' + value.name : '';
return ctx.stylize('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
}
if (isDate(value)) {
return ctx.stylize(Date.prototype.toString.call(value), 'date');
}
if (isError(value)) {
return formatError(value);
}
}
var base = '', array = false, braces = ['{', '}'];
if (isArray(value)) {
array = true;
braces = ['[', ']'];
}
if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}
if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}
if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}
if (isError(value)) {
base = ' ' + formatError(value);
}
if (keys.length === 0 && (!array || value.length == 0)) {
return braces[0] + base + braces[1];
}
if (recurseTimes < 0) {
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
} else {
return ctx.stylize('[Object]', 'special');
}
}
ctx.seen.push(value);
var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = keys.map(function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}
ctx.seen.pop();
return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined(value))
return ctx.stylize('undefined', 'undefined');
if (isString(value)) {
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
.replace(/'/g, "\\'")
.replace(/\\"/g, '"') + '\'';
return ctx.stylize(simple, 'string');
}
if (isNumber(value))
return ctx.stylize('' + value, 'number');
if (isBoolean(value))
return ctx.stylize('' + value, 'boolean');
if (isNull(value))
return ctx.stylize('null', 'null');
}
function formatError(value) {
return '[' + Error.prototype.toString.call(value) + ']';
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
String(i), true));
} else {
output.push('');
}
}
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
key, true));
}
});
return output;
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
var name, str, desc;
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
if (desc.get) {
if (desc.set) {
str = ctx.stylize('[Getter/Setter]', 'special');
} else {
str = ctx.stylize('[Getter]', 'special');
}
} else {
if (desc.set) {
str = ctx.stylize('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(ctx, desc.value, recurseTimes - 1);
}
if (str.indexOf('\n') > -1) {
if (array) {
str = str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n').substr(2);
} else {
str = '\n' + str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = ctx.stylize('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && key.match(/^\d+$/)) {
return str;
}
name = JSON.stringify('' + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.substr(1, name.length - 2);
name = ctx.stylize(name, 'name');
} else {
name = name.replace(/'/g, "\\'")
.replace(/\\"/g, '"')
.replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, 'string');
}
}
return name + ': ' + str;
}
function reduceToSingleString(output, base, braces) {
var length = output.reduce(function(prev, cur) {
if (cur.indexOf('\n') >= 0) ;
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
}, 0);
if (length > 60) {
return braces[0] +
(base === '' ? '' : base + '\n ') +
' ' +
output.join(',\n ') +
' ' +
braces[1];
}
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' ||
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = require('./support/isBuffer');
function objectToString(o) {
return Object.prototype.toString.call(o);
}
function pad(n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
}
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'];
function timestamp() {
var d = new Date();
var time = [pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())].join(':');
return [d.getDate(), months[d.getMonth()], time].join(' ');
}
exports.log = function() {
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};
exports.inherits = require('inherits');
exports._extend = function(origin, add) {
if (!add || !isObject(add)) return origin;
var keys = Object.keys(add);
var i = keys.length;
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
};
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
}).call(this,require('_process'),typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
},{"./support/isBuffer":66,"_process":47,"inherits":65}]},{},[20])(20)
});
});
const offscreenCanvas = self.OffscreenCanvas ? new OffscreenCanvas(0, 0) : null;
const ctx = offscreenCanvas ? offscreenCanvas.getContext('2d') : null;
async function createBlobFromImageData(imageData) {
if (!offscreenCanvas) {
return null;
}
offscreenCanvas.width = imageData.width;
offscreenCanvas.height = imageData.height;
ctx.putImageData(imageData, 0, 0);
const blob = await offscreenCanvas.convertToBlob();
offscreenCanvas.width = 0;
offscreenCanvas.height = 0;
return blob;
}
class DjVuPage extends CompositeChunk {
constructor(bs, getINCLChunkCallback) {
super(bs);
this.getINCLChunkCallback = getINCLChunkCallback;
this.reset();
}
reset() {
this.bs.setOffset(12);
this.djbz = null;
this.bg44arr = new Array();
this.fg44 = null;
this.bgimage = null;
this.fgimage = null;
this.sjbz = null;
this.fgbz = null;
this.text = null;
this.decoded = false;
this.isBackgroundCompletelyDecoded = false;
this.isFirstBgChunkDecoded = false;
this.info = null;
this.iffchunks = [];
this.dependencies = null;
}
getDpi() {
if (this.info) {
return this.info.dpi;
} else {
return this.init().info.dpi;
}
}
getHeight() {
return this.info ? this.info.height : this.init().info.height;
}
getWidth() {
return this.info ? this.info.width : this.init().info.width;
}
async createPngObjectUrl() {
var time = performance.now();
var imageData = this.getImageData();
var imageBlob = await createBlobFromImageData(imageData);
if (!imageBlob) {
const pngImage = browser.PNG.sync.write(this.getImageData());
imageBlob = new Blob([pngImage.buffer]);
}
DjVu.IS_DEBUG && console.log("Png creation time = ", performance.now() - time);
var url = URL.createObjectURL(imageBlob);
return {
url: url,
byteLength: imageBlob.size,
width: this.getWidth(),
height: this.getHeight(),
dpi: this.getDpi(),
};
}
getDependencies() {
if (this.info || this.dependencies) {
return this.dependencies;
}
this.dependencies = [];
var bs = this.bs.fork();
while (!bs.isEmpty()) {
var chunk;
var id = bs.readStr4();
var length = bs.getInt32();
bs.jump(-8);
var chunkBs = bs.fork(length + 8);
bs.jump(8 + length + (length & 1 ? 1 : 0));
if (id === "INCL") {
chunk = new INCLChunk(chunkBs);
this.dependencies.push(chunk.ref);
}
}
return this.dependencies;
}
init() {
if (this.info) {
return this;
}
this.dependencies = [];
var id = this.bs.readStr4();
if (id !== 'INFO') {
throw new CorruptedFileDjVuError("The very first chunk must be INFO chunk, but we got " + id + '!')
}
var length = this.bs.getInt32();
this.bs.jump(-8);
this.info = new INFOChunk(this.bs.fork(length + 8));
this.bs.jump(8 + length + (this.info.length & 1));
this.iffchunks.push(this.info);
while (!this.bs.isEmpty()) {
var chunk;
var id = this.bs.readStr4();
var length = this.bs.getInt32();
this.bs.jump(-8);
var chunkBs = this.bs.fork(length + 8);
this.bs.jump(8 + length + (length & 1));
if (!length) {
chunk = new IFFChunk(chunkBs);
} else if (id == "FG44") {
chunk = this.fg44 = new ColorChunk(chunkBs);
} else if (id == "BG44") {
this.bg44arr.push(chunk = new ColorChunk(chunkBs));
} else if (id == 'Sjbz') {
chunk = this.sjbz = new JB2Image(chunkBs);
} else if (id === "INCL") {
chunk = this.incl = new INCLChunk(chunkBs);
var inclChunk = this.getINCLChunkCallback(this.incl.ref);
if (inclChunk) {
inclChunk.id === "Djbz" ? this.djbz = inclChunk : this.iffchunks.push(inclChunk);
}
this.dependencies.push(chunk.ref);
} else if (id === "CIDa") {
try {
chunk = new CIDaChunk(chunkBs);
} catch (e) {
chunk = new ErrorChunk('CIDa', e);
}
} else if (id === 'Djbz') {
chunk = this.djbz = new JB2Dict(chunkBs);
} else if (id === 'FGbz') {
chunk = this.fgbz = new DjVuPalette(chunkBs);
} else if (id === 'TXTa' || id === 'TXTz') {
chunk = this.text = new DjVuText(chunkBs);
} else {
chunk = new IFFChunk(chunkBs);
}
this.iffchunks.push(chunk);
}
return this;
}
getRotation() {
switch (this.info.flags) {
case 5: return 90;
case 2: return 180;
case 6: return 270;
default: return 0;
}
}
rotateIfRequired(imageData) {
if (this.info.flags === 5 || this.info.flags === 6) {
var newImageData = new ImageData(this.info.height, this.info.width);
var newPixelArray = new Uint32Array(newImageData.data.buffer);
var oldPixelArray = new Uint32Array(imageData.data.buffer);
var height = this.info.height;
var width = this.info.width;
if (this.info.flags === 6) {
for (var i = 0; i < width; i++) {
var rowOffset = (width - i - 1) * height;
var to = height + rowOffset;
for (var newIndex = rowOffset, oldIndex = i; newIndex < to; newIndex++, oldIndex += width) {
newPixelArray[newIndex] = oldPixelArray[oldIndex];
}
}
} else {
for (var i = 0; i < width; i++) {
var rowOffset = i * height;
var from = height + rowOffset - 1;
for (var newIndex = from, oldIndex = i; newIndex >= rowOffset; newIndex--, oldIndex += width) {
newPixelArray[newIndex] = oldPixelArray[oldIndex];
}
}
}
return newImageData;
}
if (this.info.flags === 2) {
new Uint32Array(imageData.data.buffer).reverse();
return imageData;
}
return imageData;
}
getImageData(rotate = true) {
const image = this._getImageData();
const rotatedImage = rotate ? this.rotateIfRequired(image) : image;
if (image.width * image.height > 10000000) {
this.reset();
}
return rotatedImage;
}
_getImageData() {
this.decode();
var time = performance.now();
if (!this.sjbz) {
if (this.bgimage) {
return this.bgimage.getImage();
}
else if (this.fgimage) {
return this.fgimage.getImage();
} else {
var emptyImage = new ImageData(this.info.width, this.info.height);
emptyImage.data.fill(255);
return emptyImage;
}
}
if (!this.bgimage && !this.fgimage) {
return this.sjbz.getImage(this.fgbz);
}
var fgscale, bgscale, fgpixelmap, bgpixelmap;
function fakePixelMap(r, g, b) {
return {
writePixel(index, pixelArray, pixelIndex) {
pixelArray[pixelIndex] = r;
pixelArray[pixelIndex | 1] = g;
pixelArray[pixelIndex | 2] = b;
}
}
}
if (this.bgimage) {
bgscale = Math.round(this.info.width / this.bgimage.info.width);
bgpixelmap = this.bgimage.pixelmap;
} else {
bgscale = 1;
bgpixelmap = fakePixelMap(255, 255, 255);
}
if (this.fgimage) {
fgscale = Math.round(this.info.width / this.fgimage.info.width);
fgpixelmap = this.fgimage.pixelmap;
} else {
fgscale = 1;
fgpixelmap = fakePixelMap(0, 0, 0);
}
var image;
if (!this.fgbz) {
image = this.createImageFromMaskImageAndPixelMaps(
this.sjbz.getMaskImage(),
fgpixelmap,
bgpixelmap,
fgscale,
bgscale
);
} else {
image = this.createImageFromMaskImageAndBackgroundPixelMap(
this.sjbz.getImage(this.fgbz, true),
bgpixelmap,
bgscale
);
}
DjVu.IS_DEBUG && console.log("DataImage creating time = ", performance.now() - time);
return image;
}
createImageFromMaskImageAndPixelMaps(maskImage, fgpixelmap, bgpixelmap, fgscale, bgscale) {
var image = maskImage;
var pixelArray = image.data;
var rowIndexOffset = ((this.info.height - 1) * this.info.width) << 2;
var width4 = this.info.width << 2;
for (var i = 0; i < this.info.height; i++) {
var bis = i / bgscale >> 0;
var fis = i / fgscale >> 0;
var bgIndexOffset = bgpixelmap.width * bis;
var fgIndexOffset = fgpixelmap.width * fis;
var index = rowIndexOffset;
for (var j = 0; j < this.info.width; j++) {
if (pixelArray[index]) {
bgpixelmap.writePixel(bgIndexOffset + (j / bgscale >> 0), pixelArray, index);
} else {
fgpixelmap.writePixel(fgIndexOffset + (j / fgscale >> 0), pixelArray, index);
}
index += 4;
}
rowIndexOffset -= width4;
}
return image;
}
createImageFromMaskImageAndBackgroundPixelMap(coloredMaskImage, bgpixelmap, bgscale) {
var pixelArray = coloredMaskImage.data;
var rowOffset = (this.info.height - 1) * this.info.width << 2;
var width4 = this.info.width << 2;
for (var i = 0; i < this.info.height; i++) {
var bgRowOffset = (i / bgscale >> 0) * bgpixelmap.width;
var index = rowOffset;
for (var j = 0; j < this.info.width; j++) {
if (pixelArray[index | 3]) {
bgpixelmap.writePixel(bgRowOffset + (j / bgscale >> 0), pixelArray, index);
} else {
pixelArray[index | 3] = 255;
}
index += 4;
}
rowOffset -= width4;
}
return coloredMaskImage;
}
decodeForeground() {
if (this.fg44) {
this.fgimage = new IWImage();
var zp = new ZPDecoder(this.fg44.bs);
this.fgimage.decodeChunk(zp, this.fg44.header);
var pixelMapTime = performance.now();
this.fgimage.createPixelmap();
DjVu.IS_DEBUG && console.log("Foreground pixelmap creating time = ", performance.now() - pixelMapTime);
}
}
decodeBackground(isOnlyFirstChunk = false) {
if (this.isBackgroundCompletelyDecoded || this.isFirstBgChunkDecoded && isOnlyFirstChunk) {
return;
}
if (this.bg44arr.length) {
this.bgimage = this.bgimage || new IWImage();
var to = isOnlyFirstChunk ? 1 : this.bg44arr.length;
var from = this.isFirstBgChunkDecoded ? 1 : 0;
for (var i = from; i < to; i++) {
var chunk = this.bg44arr[i];
var zp = new ZPDecoder(chunk.bs);
var time = performance.now();
this.bgimage.decodeChunk(zp, chunk.header);
DjVu.IS_DEBUG && console.log("Background chunk decoding time = ", performance.now() - time);
}
var pixelMapTime = performance.now();
this.bgimage.createPixelmap();
DjVu.IS_DEBUG && console.log("Background pixelmap creating time = ", performance.now() - pixelMapTime);
if (isOnlyFirstChunk) {
this.isFirstBgChunkDecoded = true;
} else {
this.isBackgroundCompletelyDecoded = true;
}
}
}
decode() {
if (this.decoded) {
this.decodeBackground();
return this;
}
this.init();
var time = performance.now();
this.sjbz ? this.sjbz.decode(this.djbz) : 0;
DjVu.IS_DEBUG && console.log("Mask decoding time = ", performance.now() - time);
time = performance.now();
this.decodeForeground();
DjVu.IS_DEBUG && console.log("Foreground decoding time = ", performance.now() - time);
time = performance.now();
this.decodeBackground();
DjVu.IS_DEBUG && console.log("Background decoding time = ", performance.now() - time);
this.decoded = true;
return this;
}
getBackgroundImageData() {
this.decode();
if (this.bg44arr.length) {
this.bg44arr.forEach((chunk) => {
var zp = new ZPDecoder(chunk.bs);
this.bgimage.decodeChunk(zp, chunk.header);
}
);
return this.bgimage.getImage();
} else {
return null;
}
}
getForegroundImageData() {
this.decode();
if (this.fg44) {
this.fgimage = new IWImage();
var zp = new ZPDecoder(this.fg44.bs);
this.fgimage.decodeChunk(zp, this.fg44.header);
return this.fgimage.getImage();
} else {
return null;
}
}
getMaskImageData() {
this.decode();
return this.sjbz && this.sjbz.getImage(this.fgbz);
}
getText() {
this.init();
return this.text ? this.text.getText() : "";
}
getPageTextZone() {
this.init();
return this.text ? this.text.getPageZone() : null;
}
getNormalizedTextZones() {
this.init();
return this.text ? this.text.getNormalizedZones() : null;
}
toString() {
this.init();
var str = this.iffchunks.reduce((str, chunk) => str + chunk.toString(), '');
return super.toString(str);
}
}
class DIRMChunk extends IFFChunk {
constructor(bs) {
super(bs);
this.dflags = bs.byte();
this.isBundled = this.dflags >> 7;
this.nfiles = bs.getInt16();
if (this.isBundled) {
this.offsets = new Int32Array(this.nfiles);
for (var i = 0; i < this.nfiles; i++) {
this.offsets[i] = bs.getInt32();
}
}
this.sizes = new Uint32Array(this.nfiles);
this.flags = new Uint8Array(this.nfiles);
this.ids = new Array(this.nfiles);
this.names = new Array(this.nfiles);
this.titles = new Array(this.nfiles);
var bsz = BZZDecoder.decodeByteStream(bs.fork());
for (var i = 0; i < this.nfiles; i++) {
this.sizes[i] = bsz.getUint24();
}
for (var i = 0; i < this.nfiles; i++) {
this.flags[i] = bsz.byte();
}
this.pagesIds = [];
this.idToNameRegistry = {};
for (var i = 0; i < this.nfiles && !bsz.isEmpty(); i++) {
this.ids[i] = bsz.readStrNT();
this.names[i] = this.flags[i] & 128 ? bsz.readStrNT() : this.ids[i];
this.titles[i] = this.flags[i] & 64 ? bsz.readStrNT() : this.ids[i];
if (this.isPageIndex(i)) {
this.pagesIds.push(this.ids[i]);
}
this.idToNameRegistry[this.ids[i]] = this.names[i];
}
}
isPageIndex(i) {
return (this.flags[i] & 63) === 1;
}
isThumbnailIndex(i) {
return (this.flags[i] & 63) === 2;
}
getPageNameByItsNumber(number) {
return this.getComponentNameByItsId(this.pagesIds[number - 1]);
}
getPageNumberByItsId(id) {
const index = this.pagesIds.indexOf(id);
return index === -1 ? null : (index + 1);
}
getComponentNameByItsId(id) {
return this.idToNameRegistry[id];
}
getPagesQuantity() {
return this.pagesIds.length;
}
getFilesQuantity() {
return this.nfiles;
}
getMetadataStringByIndex(i) {
return (
`[id: "${this.ids[i]}", flag: ${this.flags[i]}, ` +
`offset: ${this.offsets ? this.offsets[i] : 'indirect'}, size: ${this.sizes[i]}]\n`
);
}
toString() {
var str = super.toString();
str += (this.isBundled ? 'Bundled' : 'Indirect') + '\n';
str += "FilesCount: " + this.nfiles + '\n';
return str + '\n';
}
}
class NAVMChunk extends IFFChunk {
constructor(bs) {
super(bs);
this.isDecoded = false;
this.contents = [];
this.decodedBookmarkCounter = 0;
}
getContents() {
this.decode();
return this.contents;
}
decode() {
if (this.isDecoded) {
return;
}
var dbs = BZZDecoder.decodeByteStream(this.bs);
var bookmarksCount = dbs.getUint16();
while (this.decodedBookmarkCounter < bookmarksCount) {
this.contents.push(this.decodeBookmark(dbs));
}
this.isDecoded = true;
}
decodeBookmark(bs) {
var childrenCount = bs.getUint8();
var descriptionLength = bs.getInt24();
var description = descriptionLength ? bs.readStrUTF(descriptionLength) : '';
var urlLength = bs.getInt24();
var url = urlLength ? bs.readStrUTF(urlLength) : '';
this.decodedBookmarkCounter++;
var bookmark = { description, url };
if (childrenCount) {
var children = new Array(childrenCount);
for (var i = 0; i < childrenCount; i++) {
children[i] = this.decodeBookmark(bs);
}
bookmark.children = children;
}
return bookmark;
}
toString() {
this.decode();
var indent = ' ';
function stringifyBookmark(bookmark, indentSize = 0) {
var str = indent.repeat(indentSize) + `${bookmark.description} (${bookmark.url})\n`;
if (bookmark.children) {
str = bookmark.children.reduce((str, bookmark) => str + stringifyBookmark(bookmark, indentSize + 1), str);
}
return str;
}
var str = this.contents.reduce((str, bookmark) => str + stringifyBookmark(bookmark), super.toString());
return str + '\n';
}
}
class BZZEncoder {
constructor(zp) {
this.zp = zp || new ZPEncoder();
this.FREQMAX = 4;
this.CTXIDS = 3;
this.ctx = new Uint8Array(300);
this.size = 0;
this.blocksize = 0;
this.FREQS0 = 100000;
this.FREQS1 = 1000000;
}
blocksort(arr) {
var length = arr.length;
var offs = new Array(arr.length);
for (var i = 0; i < length; offs[i] = i++) { }
offs.sort((a, b) => {
for (var i = 0; i < length; i++) {
if (a === this.markerpos) {
return -1;
}
else if (b === this.markerpos) {
return 1;
}
var res = arr[a % length] - arr[b % length];
if (res) {
return res;
}
a++;
b++;
}
return 0;
});
var narr = new Uint8Array(length);
for (var i = 0; i < length; i++) {
var pos = offs[i] - 1;
if (pos >= 0) {
narr[i] = arr[pos];
}
else {
narr[i] = 0;
this.markerpos = i;
}
}
return narr;
}
encode_raw(bits, x) {
var n = 1;
var m = (1 << bits);
while (n < m) {
x = (x & (m - 1)) << 1;
var b = (x >> bits);
this.zp.encode(b);
n = (n << 1) | b;
}
}
encode_binary(cxtoff, bits, x) {
var n = 1;
var m = (1 << bits);
cxtoff--;
while (n < m) {
x = (x & (m - 1)) << 1;
var b = (x >> bits);
this.zp.encode(b, this.ctx, cxtoff + n);
n = (n << 1) | b;
}
}
encode(buffer) {
var data = new Uint8Array(buffer);
var size = data.length;
var markerpos = size - 1;
this.markerpos = markerpos;
data = this.blocksort(data);
markerpos = this.markerpos;
this.encode_raw(24, size);
var fshift = 0;
if (size < this.FREQS0) {
fshift = 0;
this.zp.encode(0);
}
else if (size < this.FREQS1) {
fshift = 1;
this.zp.encode(1);
this.zp.encode(0);
}
else {
fshift = 2;
this.zp.encode(1);
this.zp.encode(1);
}
var mtf = new Uint8Array(256);
var rmtf = new Uint8Array(256);
var freq = new Uint32Array(this.FREQMAX);
var m = 0;
for (m = 0; m < 256; m++)
mtf[m] = m;
for (m = 0; m < 256; m++)
rmtf[mtf[m]] = m;
var fadd = 4;
for (m = 0; m < this.FREQMAX; m++)
freq[m] = 0;
var i;
var mtfno = 3;
for (i = 0; i < size; i++) {
var c = data[i];
var ctxid = this.CTXIDS - 1;
if (ctxid > mtfno)
ctxid = mtfno;
mtfno = rmtf[c];
if (i == markerpos)
mtfno = 256;
var b;
var ctxoff = 0;
switch (0)
{
default:
b = (mtfno == 0);
this.zp.encode(b, this.ctx, ctxoff + ctxid);
if (b)
break;
ctxoff += this.CTXIDS;
b = (mtfno == 1);
this.zp.encode(b, this.ctx, ctxoff + ctxid);
if (b)
break;
ctxoff += this.CTXIDS;
b = (mtfno < 4);
this.zp.encode(b, this.ctx, ctxoff);
if (b) {
this.encode_binary(ctxoff + 1, 1, mtfno - 2);
break;
}
ctxoff += 1 + 1;
b = (mtfno < 8);
this.zp.encode(b, this.ctx, ctxoff);
if (b) {
this.encode_binary(ctxoff + 1, 2, mtfno - 4);
break;
}
ctxoff += 1 + 3;
b = (mtfno < 16);
this.zp.encode(b, this.ctx, ctxoff);
if (b) {
this.encode_binary(ctxoff + 1, 3, mtfno - 8);
break;
}
ctxoff += 1 + 7;
b = (mtfno < 32);
this.zp.encode(b, this.ctx, ctxoff);
if (b) {
this.encode_binary(ctxoff + 1, 4, mtfno - 16);
break;
}
ctxoff += 1 + 15;
b = (mtfno < 64);
this.zp.encode(b, this.ctx, ctxoff);
if (b) {
this.encode_binary(ctxoff + 1, 5, mtfno - 32);
break;
}
ctxoff += 1 + 31;
b = (mtfno < 128);
this.zp.encode(b, this.ctx, ctxoff);
if (b) {
this.encode_binary(ctxoff + 1, 6, mtfno - 64);
break;
}
ctxoff += 1 + 63;
b = (mtfno < 256);
this.zp.encode(b, this.ctx, ctxoff);
if (b) {
this.encode_binary(ctxoff + 1, 7, mtfno - 128);
break;
}
continue;
}
fadd = fadd + (fadd >> fshift);
if (fadd > 0x10000000) {
fadd = fadd >> 24;
freq[0] >>= 24;
freq[1] >>= 24;
freq[2] >>= 24;
freq[3] >>= 24;
for (var k = 4; k < this.FREQMAX; k++)
freq[k] = freq[k] >> 24;
}
var fc = fadd;
if (mtfno < this.FREQMAX)
fc += freq[mtfno];
var k;
for (k = mtfno; k >= this.FREQMAX; k--) {
mtf[k] = mtf[k - 1];
rmtf[mtf[k]] = k;
}
for (; k > 0 && fc >= freq[k - 1]; k--) {
mtf[k] = mtf[k - 1];
freq[k] = freq[k - 1];
rmtf[mtf[k]] = k;
}
mtf[k] = c;
freq[k] = fc;
rmtf[mtf[k]] = k;
}
this.encode_raw(24, 0);
this.zp.eflush();
return 0;
}
}
class DjVuWriter {
constructor(length) {
this.bsw = new ByteStreamWriter(length || 1024 * 1024);
}
startDJVM() {
this.bsw.writeStr('AT&T').writeStr('FORM').saveOffsetMark('fileSize')
.jump(4).writeStr('DJVM');
}
writeDirmChunk(dirm) {
this.dirm = dirm;
this.bsw.writeStr('DIRM').saveOffsetMark('DIRMsize').jump(4);
this.dirm.offsets = [];
this.bsw.writeByte(dirm.dflags)
.writeInt16(dirm.flags.length)
.saveOffsetMark('DIRMoffsets')
.jump(4 * dirm.flags.length);
var tmpBS = new ByteStreamWriter();
for (var i = 0; i < dirm.sizes.length; i++) {
tmpBS.writeInt24(dirm.sizes[i]);
}
for (var i = 0; i < dirm.flags.length; i++) {
tmpBS.writeByte(dirm.flags[i]);
}
for (var i = 0; i < dirm.ids.length; i++) {
tmpBS.writeStrNT(dirm.ids[i]);
if (dirm.flags[i] & 128) {
tmpBS.writeStrNT(dirm.names[i]);
}
if (dirm.flags[i] & 64) {
tmpBS.writeStrNT(dirm.titles[i]);
}
}
tmpBS.writeByte(0);
var tmpBuffer = tmpBS.getBuffer();
var bzzBS = new ByteStreamWriter();
var zp = new ZPEncoder(bzzBS);
var bzz = new BZZEncoder(zp);
bzz.encode(tmpBuffer);
var encodedBuffer = bzzBS.getBuffer();
this.bsw.writeBuffer(encodedBuffer);
this.bsw.rewriteSize('DIRMsize');
}
get offset() {
return this.bsw.offset;
}
writeByte(byte) {
this.bsw.writeByte(byte);
return this;
}
writeStr(str) {
this.bsw.writeStr(str);
return this;
}
writeInt32(val) {
this.bsw.writeInt32(val);
return this;
}
writeFormChunkBS(bs) {
if (this.bsw.offset & 1) {
this.bsw.writeByte(0);
}
var off = this.bsw.offset;
this.dirm.offsets.push(off);
this.bsw.writeByteStream(bs);
}
writeFormChunkBuffer(buffer) {
if (this.bsw.offset & 1) {
this.bsw.writeByte(0);
}
var off = this.bsw.offset;
this.dirm.offsets.push(off);
this.bsw.writeBuffer(buffer);
}
writeChunk(chunk) {
if (this.bsw.offset & 1) {
this.bsw.writeByte(0);
}
this.bsw.writeByteStream(chunk.bs);
}
getBuffer() {
this.bsw.rewriteSize('fileSize');
if (this.dirm.offsets.length !== (this.dirm.flags.length)) {
throw new Error("Записаны не все страницы и словари !!!");
}
for (var i = 0; i < this.dirm.offsets.length; i++) {
this.bsw.rewriteInt32('DIRMoffsets', this.dirm.offsets[i]);
}
return this.bsw.getBuffer();
}
}
class ThumChunk extends CompositeChunk { }
async function loadByteStream(url, errorData = {}) {
let xhr;
try {
xhr = await loadFileViaXHR(url);
} catch (e) {
throw new NetworkDjVuError({ url: url, ...errorData });
}
if (xhr.status && xhr.status !== 200) {
throw new UnsuccessfulRequestDjVuError(xhr, { ...errorData });
}
return new ByteStream(xhr.response);
}
function checkAndCropByteStream(bs, compositeChunkId = null, errorData = null) {
if (bs.readStr4() !== 'AT&T') {
throw new CorruptedFileDjVuError(`The byte stream isn't a djvu file.`, errorData);
}
if (!compositeChunkId) {
return bs.fork();
}
let chunkId = bs.readStr4();
const length = bs.getInt32();
chunkId += bs.readStr4();
if (chunkId !== compositeChunkId) {
throw new CorruptedFileDjVuError(
`Unexpected chunk id. Expected "${compositeChunkId}", but got "${chunkId}"`,
errorData
);
}
return bs.jump(-12).fork(length + 8);
}
async function loadPage(number, url) {
const errorData = { pageNumber: number };
return checkAndCropByteStream(await loadByteStream(url, errorData), null, errorData);
}
async function loadPageDependency(id, name, baseUrl, pageNumber = null) {
const errorData = { pageNumber: pageNumber, dependencyId: id };
return checkAndCropByteStream(await loadByteStream(baseUrl + name, errorData), 'FORMDJVI', errorData);
}
async function loadThumbnail(url, id = null) {
const errorData = { thumbnailId: id };
return checkAndCropByteStream(await loadByteStream(url, errorData), 'FORMTHUM', errorData);
}
async function bundle(progressCallback = () => { }) {
const djvuWriter = new DjVuWriter();
djvuWriter.startDJVM();
const dirm = {
dflags: this.dirm.dflags | 128,
flags: [],
names: [],
titles: [],
sizes: [],
ids: [],
};
const chunkByteStreams = [];
const filesQuantity = this.dirm.getFilesQuantity();
const totalOperations = filesQuantity + 3;
let pageNumber = 0;
const limit = pLimit(4);
let downloadedNumber = 0;
const promises = [];
for (let i = 0; i < filesQuantity; i++) {
promises.push(limit(async () => {
let bs;
if (this.dirm.isPageIndex(i)) {
pageNumber++;
bs = await loadPage(pageNumber, this._getUrlByPageNumber(pageNumber));
} else if (this.dirm.isThumbnailIndex(i)) {
bs = await loadThumbnail(
this.baseUrl + this.dirm.getComponentNameByItsId(this.dirm.ids[i]),
this.dirm.ids[i]
);
} else {
bs = await loadPageDependency(
this.dirm.ids[i],
this.dirm.getComponentNameByItsId(this.dirm.ids[i]),
this.baseUrl,
);
}
downloadedNumber++;
progressCallback(downloadedNumber / totalOperations);
return {
flags: this.dirm.flags[i],
id: this.dirm.ids[i],
name: this.dirm.names[i],
title: this.dirm.titles[i],
bs: bs,
};
}));
}
for (const data of await Promise.all(promises)) {
dirm.flags.push(data.flags);
dirm.ids.push(data.id);
dirm.names.push(data.names);
dirm.titles.push(data.title);
dirm.sizes.push(data.bs.length);
chunkByteStreams.push(data.bs);
}
djvuWriter.writeDirmChunk(dirm);
if (this.navm) {
djvuWriter.writeChunk(this.navm);
}
progressCallback((totalOperations - 2) / totalOperations);
for (let i = 0; i < chunkByteStreams.length; i++) {
djvuWriter.writeFormChunkBS(chunkByteStreams[i]);
chunkByteStreams[i] = null;
}
progressCallback((totalOperations - 1) / totalOperations);
const newBuffer = djvuWriter.getBuffer();
progressCallback(1);
return new this.constructor(newBuffer);
}
const MEMORY_LIMIT = 50 * 1024 * 1024;
class DjVuDocument {
constructor(arraybuffer, { baseUrl = null, memoryLimit = MEMORY_LIMIT } = {}) {
this.buffer = arraybuffer;
this.baseUrl = baseUrl && baseUrl.trim();
if (typeof this.baseUrl === 'string') {
if (this.baseUrl[this.baseUrl.length - 1] !== '/') {
this.baseUrl += '/';
}
if (!/^[A-Za-z]+:\/\//.test(this.baseUrl)) {
this.baseUrl = location.origin && (new URL(this.baseUrl, location.origin).href);
}
}
this.memoryLimit = memoryLimit;
this.djvi = {};
this.getINCLChunkCallback = id => this.djvi[id].innerChunk;
this.bs = new ByteStream(arraybuffer);
this.formatID = this.bs.readStr4();
if (this.formatID !== 'AT&T') {
throw new IncorrectFileFormatDjVuError();
}
this.id = this.bs.readStr4();
this.length = this.bs.getInt32();
this.id += this.bs.readStr4();
if (this.id === 'FORMDJVM') {
this._initMultiPageDocument();
} else if (this.id === 'FORMDJVU') {
this.bs.jump(-12);
this.pages = [new DjVuPage(this.bs.fork(this.length + 8), this.getINCLChunkCallback)];
} else {
throw new CorruptedFileDjVuError(
`The id of the first chunk of the document should be either FORMDJVM or FORMDJVU, but there is ${this.id}`
);
}
}
_initMultiPageDocument() {
this._readMetaDataChunk();
this._readContentsChunkIfExists();
this.pages = [];
this.thumbs = [];
if (this.dirm.isBundled) {
this._parseComponents();
} else {
this.pages = new Array(this.dirm.getPagesQuantity());
this.memoryUsage = this.bs.buffer.byteLength;
this.loadedPageNumbers = [];
}
}
_readMetaDataChunk() {
var id = this.bs.readStr4();
if (id !== 'DIRM') {
throw new CorruptedFileDjVuError("The DIRM chunk must be the first but there is " + id + " instead!");
}
var length = this.bs.getInt32();
this.bs.jump(-8);
this.dirm = new DIRMChunk(this.bs.fork(length + 8));
this.bs.jump(8 + length + (length & 1 ? 1 : 0));
}
_readContentsChunkIfExists() {
this.navm = null;
if (this.bs.remainingLength() > 8) {
var id = this.bs.readStr4();
var length = this.bs.getInt32();
this.bs.jump(-8);
if (id === 'NAVM') {
this.navm = new NAVMChunk(this.bs.fork(length + 8));
}
}
}
_parseComponents() {
this.dirmOrderedChunks = new Array(this.dirm.getFilesQuantity());
for (var i = 0; i < this.dirm.offsets.length; i++) {
this.bs.setOffset(this.dirm.offsets[i]);
var id = this.bs.readStr4();
var length = this.bs.getInt32();
id += this.bs.readStr4();
this.bs.jump(-12);
switch (id) {
case "FORMDJVU":
this.pages.push(this.dirmOrderedChunks[i] = new DjVuPage(
this.bs.fork(length + 8),
this.getINCLChunkCallback
));
break;
case "FORMDJVI":
this.dirmOrderedChunks[i] = this.djvi[this.dirm.ids[i]] = new DjViChunk(this.bs.fork(length + 8));
break;
case "FORMTHUM":
this.thumbs.push(this.dirmOrderedChunks[i] = new ThumChunk(this.bs.fork(length + 8)));
break;
default:
console.error("Incorrect chunk ID: ", id);
}
}
}
getPagesSizes() {
var sizes = this.pages.map(page => {
return {
width: page.getWidth(),
height: page.getHeight(),
dpi: page.getDpi(),
};
});
this.pages.forEach(page => page.reset());
return sizes;
}
isBundled() {
return this.dirm ? this.dirm.isBundled : true;
}
getPagesQuantity() {
return this.dirm ? this.dirm.getPagesQuantity() : 1;
}
getContents() {
return this.navm ? this.navm.getContents() : null;
}
getMemoryUsage() {
return this.memoryUsage;
}
getMemoryLimit() {
return this.memoryLimit;
}
setMemoryLimit(limit = MEMORY_LIMIT) {
this.memoryLimit = limit;
}
getPageNumberByUrl(url) {
if (url[0] !== '#') {
return null;
}
const ref = url.slice(1);
let pageNumber = this.dirm.getPageNumberByItsId(ref);
if (!pageNumber) {
const num = Math.round(Number(ref));
if (num >= 1 && num <= this.pages.length) {
pageNumber = num;
}
}
return pageNumber || null;
}
releaseMemoryIfRequired(preservedDependencies = null) {
if (this.memoryUsage <= this.memoryLimit) {
return;
}
while (this.memoryUsage > this.memoryLimit && this.loadedPageNumbers.length) {
var number = this.loadedPageNumbers.shift();
this.memoryUsage -= this.pages[number].bs.buffer.byteLength;
this.pages[number] = null;
}
if (this.memoryUsage > this.memoryLimit && !this.loadedPageNumbers.length) {
this.resetLastRequestedPage();
var newDjVi = {};
if (preservedDependencies) {
preservedDependencies.forEach(id => {
newDjVi[id] = this.djvi[id];
this.memoryUsage += newDjVi[id].bs.buffer.byteLength;
});
}
Object.keys(this.djvi).forEach(key => {
this.memoryUsage -= this.djvi[key].bs.buffer.byteLength;
});
this.djvi = newDjVi;
}
}
_getUrlByPageNumber(number) {
return this.baseUrl + this.dirm.getPageNameByItsNumber(number);
}
async getPage(number) {
var page = this.pages[number - 1];
if (this.lastRequestedPage && this.lastRequestedPage !== page) {
this.lastRequestedPage.reset();
}
this.lastRequestedPage = page;
if (!page) {
if (number < 1 || number > this.pages.length || this.isBundled()) {
throw new NoSuchPageDjVuError(number);
} else {
if (this.baseUrl === null) {
throw new NoBaseUrlDjVuError();
}
const bs = await loadPage(
number,
this._getUrlByPageNumber(number)
);
const page = new DjVuPage(bs, this.getINCLChunkCallback);
this.memoryUsage += bs.buffer.byteLength;
await this._loadDependencies(page.getDependencies(), number);
this.releaseMemoryIfRequired(page.getDependencies());
this.pages[number - 1] = page;
this.loadedPageNumbers.push(number - 1);
this.lastRequestedPage = page;
}
} else if (!this.isOnePageDependenciesLoaded && this.id === "FORMDJVU") {
var dependencies = page.getDependencies();
if (dependencies.length) {
await this._loadDependencies(dependencies, 1);
}
this.isOnePageDependenciesLoaded = true;
}
return this.lastRequestedPage;
}
async _loadDependencies(dependencies, pageNumber = null) {
var unloadedDependencies = dependencies.filter(id => !this.djvi[id]);
if (!unloadedDependencies.length) {
return;
}
await Promise.all(unloadedDependencies.map(async id => {
const bs = await loadPageDependency(
id,
this.dirm ? this.dirm.getComponentNameByItsId(id) : id,
this.baseUrl,
pageNumber
);
this.djvi[id] = new DjViChunk(bs);
this.memoryUsage += bs.buffer.byteLength;
}));
}
getPageUnsafe(number) {
return this.pages[number - 1];
}
resetLastRequestedPage() {
this.lastRequestedPage && this.lastRequestedPage.reset();
this.lastRequestedPage = null;
}
countFiles() {
var count = 0;
var bs = this.bs.clone();
bs.jump(16);
while (!bs.isEmpty()) {
var id = bs.readStr4();
var length = bs.getInt32();
bs.jump(length + (length & 1 ? 1 : 0));
if (id === 'FORM') {
count++;
}
}
return count;
}
toString(html) {
var str = this.formatID + '\n';
if (this.dirm) {
str += this.id + " " + this.length + '\n\n';
str += this.dirm.toString();
str += this.navm ? this.navm.toString() : '';
if (this.isBundled()) {
this.dirmOrderedChunks.forEach((chunk, i) => {
str += this.dirm.getMetadataStringByIndex(i) + chunk.toString();
});
} else {
for (let i = 0; i < this.dirm.getFilesQuantity(); i++) {
str += this.dirm.getMetadataStringByIndex(i);
}
}
} else {
str += this.pages[0].toString();
}
return html ? str.replace(/\n/g, '<br>').replace(/\s/g, '&nbsp;') : str;
}
createObjectURL() {
var blob = new Blob([this.bs.buffer]);
var url = URL.createObjectURL(blob);
return url;
}
slice(from = 1, to = this.pages.length) {
const djvuWriter = new DjVuWriter();
djvuWriter.startDJVM();
const dirm = {
dflags: this.dirm.dflags,
flags: [],
names: [],
titles: [],
sizes: [],
ids: [],
};
const chunkByteStreams = [];
const totalPageCount = to - from + 1;
const dependencies = {};
const filesQuantity = this.dirm.getFilesQuantity();
for (
let i = 0, pageIndex = 0, addedPageCount = 0;
i < filesQuantity && addedPageCount < totalPageCount;
i++
) {
const isPage = (this.dirm.flags[i] & 63) === 1;
if (!isPage) continue;
pageIndex++;
if (pageIndex < from) continue;
addedPageCount++;
const pageByteStream = new ByteStream(this.buffer, this.dirm.offsets[i], this.dirm.sizes[i]);
const deps = new DjVuPage(pageByteStream).getDependencies();
for (const dependencyId of deps) {
dependencies[dependencyId] = 1;
}
}
for (
let i = 0, pageIndex = 0, addedPageCount = 0;
i < filesQuantity && addedPageCount < totalPageCount;
i++
) {
const isPage = (this.dirm.flags[i] & 63) === 1;
if (isPage) {
pageIndex++;
if (pageIndex < from) continue;
addedPageCount++;
}
if ((this.dirm.ids[i] in dependencies) || isPage) {
dirm.flags.push(this.dirm.flags[i]);
dirm.sizes.push(this.dirm.sizes[i]);
dirm.ids.push(this.dirm.ids[i]);
dirm.names.push(this.dirm.names[i]);
dirm.titles.push(this.dirm.titles[i]);
chunkByteStreams.push(
new ByteStream(this.buffer, this.dirm.offsets[i], this.dirm.sizes[i])
);
}
}
djvuWriter.writeDirmChunk(dirm);
if (this.navm) {
djvuWriter.writeChunk(this.navm);
}
for (const chunkByteStream of chunkByteStreams) {
djvuWriter.writeFormChunkBS(chunkByteStream);
}
const newBuffer = djvuWriter.getBuffer();
DjVu.IS_DEBUG && console.log("New Buffer size = ", newBuffer.byteLength);
return new DjVuDocument(newBuffer);
}
static concat(doc1, doc2) {
var dirm = {};
var length = doc1.pages.length + doc2.pages.length;
dirm.dflags = 129;
dirm.flags = [];
dirm.sizes = [];
dirm.ids = [];
var pages = [];
var idset = new Set();
if (!doc1.dirm) {
dirm.flags.push(1);
dirm.sizes.push(doc1.pages[0].bs.length);
dirm.ids.push('single');
idset.add('single');
pages.push(doc1.pages[0]);
}
else {
for (var i = 0; i < doc1.pages.length; i++) {
dirm.flags.push(doc1.dirm.flags[i]);
dirm.sizes.push(doc1.dirm.sizes[i]);
dirm.ids.push(doc1.dirm.ids[i]);
idset.add(doc1.dirm.ids[i]);
pages.push(doc1.pages[i]);
}
}
if (!doc2.dirm) {
dirm.flags.push(1);
dirm.sizes.push(doc2.pages[0].bs.length);
var newid = 'single2';
var tmp = 0;
while (idset.has(newid)) {
newid = 'single2' + tmp.toString();
tmp++;
}
dirm.ids.push(newid);
pages.push(doc2.pages[0]);
}
else {
for (var i = 0; i < doc2.pages.length; i++) {
dirm.flags.push(doc2.dirm.flags[i]);
dirm.sizes.push(doc2.dirm.sizes[i]);
var newid = doc2.dirm.ids[i];
var tmp = 0;
while (idset.has(newid)) {
newid = doc2.dirm.ids[i] + tmp.toString();
tmp++;
}
dirm.ids.push(newid);
idset.add(newid);
pages.push(doc2.pages[i]);
}
}
var dw = new DjVuWriter();
dw.startDJVM();
dw.writeDirmChunk(dirm);
for (var i = 0; i < length; i++) {
dw.writeFormChunkBS(pages[i].bs);
}
return new DjVuDocument(dw.getBuffer());
}
}
Object.assign(DjVuDocument.prototype, {
bundle,
});
function getLinkToTheWholeLibrary() {
if (!getLinkToTheWholeLibrary.url) {
getLinkToTheWholeLibrary.url = URL.createObjectURL(new Blob(
["(" + DjVuScript.toString() + ")();"],
{ type: 'application/javascript' }
));
}
return getLinkToTheWholeLibrary.url;
}
class DjVuWorker {
constructor(path = getLinkToTheWholeLibrary()) {
this.path = path;
this.reset();
}
reset() {
this.terminate();
this.worker = new Worker(this.path);
this.worker.onmessage = (e) => this.messageHandler(e);
this.worker.onerror = (e) => this.errorHandler(e);
this.promiseCallbacks = null;
this.currentPromise = null;
this.promiseMap = new Map();
this.isWorking = false;
this.commandCounter = 0;
this.currentCommandId = null;
this.hyperCallbacks = {};
this.hyperCallbackCounter = 0;
}
registerHyperCallback(func) {
const id = this.hyperCallbackCounter++;
this.hyperCallbacks[id] = func;
return { hyperCallback: true, id: id };
}
unregisterHyperCallback(id) {
delete this.hyperCallbacks[id];
}
terminate() {
this.worker && this.worker.terminate();
}
get doc() {
return DjVuWorkerTask.instance(this);
}
errorHandler(event) {
console.error("DjVu.js Worker error!", event);
}
cancelTask(promise) {
if (!this.promiseMap.delete(promise)) {
if (this.currentPromise === promise) {
this.dropCurrentTask();
}
}
}
dropCurrentTask() {
this.currentPromise = null;
this.promiseCallbacks = null;
this.currentCommandId = null;
}
emptyTaskQueue() {
this.promiseMap.clear();
}
cancelAllTasks() {
this.emptyTaskQueue();
this.dropCurrentTask();
}
createNewPromise(commandObj, transferList = undefined) {
var callbacks;
var promise = new Promise((resolve, reject) => {
callbacks = { resolve, reject };
});
this.promiseMap.set(promise, { callbacks, commandObj, transferList });
this.runNextTask();
return promise;
}
prepareCommandObject(commandObj) {
if (!(commandObj.data instanceof Array)) return commandObj;
const hyperCallbackIds = [];
for (const { args: argsList } of commandObj.data) {
for (const args of argsList) {
for (let i = 0; i < args.length; i++) {
if (typeof args[i] === 'function') {
const hyperCallback = this.registerHyperCallback(args[i]);
args[i] = hyperCallback;
hyperCallbackIds.push(hyperCallback.id);
}
}
}
}
if (hyperCallbackIds.length) {
commandObj.sendBackData = {
...commandObj.sendBackData,
hyperCallbackIds
};
}
return commandObj;
}
runNextTask() {
if (this.isWorking) {
return;
}
var next = this.promiseMap.entries().next().value;
if (next) {
const [promise, { callbacks, commandObj, transferList }] = next;
this.promiseCallbacks = callbacks;
this.currentPromise = promise;
this.currentCommandId = this.commandCounter++;
commandObj.sendBackData = {
commandId: this.currentCommandId,
};
this.worker.postMessage(this.prepareCommandObject(commandObj), transferList);
this.isWorking = true;
this.promiseMap.delete(promise);
} else {
this.dropCurrentTask();
}
}
isTaskInProcess(promise) {
return this.currentPromise === promise;
}
isTaskInQueue(promise) {
return this.promiseMap.has(promise) || this.isTaskInProcess(promise);
}
processAction(obj) {
switch (obj.action) {
case 'Process':
this.onprocess ? this.onprocess(obj.percent) : 0;
break;
case 'hyperCallback':
if (this.hyperCallbacks[obj.id]) this.hyperCallbacks[obj.id](...obj.args);
break;
}
}
messageHandler({ data: obj }) {
if (obj.action) return this.processAction(obj);
this.isWorking = false;
const callbacks = this.promiseCallbacks;
const commandId = obj.sendBackData && obj.sendBackData.commandId;
if (commandId === this.currentCommandId || this.currentCommandId === null) {
this.runNextTask();
} else {
if (obj === "unhandledrejection" || obj === "error") {
console.warn("DjVu.js: " + obj + " occurred in the worker!");
this.runNextTask();
} else {
console.warn('DjVu.js: Something strange came from the worker.', obj);
}
return;
}
if (!callbacks) return;
const { resolve, reject } = callbacks;
switch (obj.command) {
case 'Error':
reject(obj.error);
break;
case 'createDocument':
case 'startMultiPageDocument':
case 'addPageToDocument':
resolve();
break;
case 'createDocumentFromPictures':
case 'endMultiPageDocument':
resolve(obj.buffer);
break;
case 'run':
var restoredResult = !obj.result ? obj.result :
obj.result.length && obj.result.map ? obj.result.map(result => this.restoreValueAfterTransfer(result)) :
this.restoreValueAfterTransfer(obj.result);
resolve(restoredResult);
break;
default:
console.error("Unexpected message from DjVuWorker: ", obj);
}
if (obj.sendBackData && obj.sendBackData.hyperCallbackIds) {
obj.sendBackData.hyperCallbackIds.forEach(id => this.unregisterHyperCallback(id));
}
}
restoreValueAfterTransfer(value) {
if (value) {
if (value.width && value.height && value.buffer) {
return new ImageData(new Uint8ClampedArray(value.buffer), value.width, value.height);
}
}
return value;
}
run(...tasks) {
const data = tasks.map(task => task._);
return this.createNewPromise({
command: 'run',
data: data,
});
}
revokeObjectURL(url) {
this.worker.postMessage({
action: this.revokeObjectURL.name,
url: url,
});
}
startMultiPageDocument(slicenumber, delayInit, grayscale) {
return this.createNewPromise({
command: 'startMultiPageDocument',
slicenumber: slicenumber,
delayInit: delayInit,
grayscale: grayscale
});
}
addPageToDocument(imageData) {
var simpleImage = {
buffer: imageData.data.buffer,
width: imageData.width,
height: imageData.height
};
return this.createNewPromise({
command: 'addPageToDocument',
simpleImage: simpleImage
}, [simpleImage.buffer]);
}
endMultiPageDocument() {
return this.createNewPromise({ command: 'endMultiPageDocument' });
}
createDocument(buffer, options) {
return this.createNewPromise({ command: 'createDocument', buffer: buffer, options: options }, [buffer]);
}
createDocumentFromPictures(imageArray, slicenumber, delayInit, grayscale) {
var simpleImages = new Array(imageArray.length);
var buffers = new Array(imageArray.length);
for (var i = 0; i < imageArray.length; i++) {
simpleImages[i] = {
buffer: imageArray[i].data.buffer,
width: imageArray[i].width,
height: imageArray[i].height
};
buffers[i] = imageArray[i].data.buffer;
}
return this.createNewPromise({
command: 'createDocumentFromPictures',
images: simpleImages,
slicenumber: slicenumber,
delayInit: delayInit,
grayscale: grayscale
}, buffers);
}
}
class DjVuWorkerTask {
static instance(worker, funcs = [], args = []) {
var proxy = new Proxy(DjVuWorkerTask.emptyFunc, {
get: (target, key) => {
switch (key) {
case '_':
return { funcs, args };
case 'run':
return () => worker.run(proxy);
default:
return DjVuWorkerTask.instance(worker, [...funcs, key], args);
}
},
apply: (target, that, _args) => {
return DjVuWorkerTask.instance(worker, funcs, [...args, _args]);
}
});
return proxy;
}
static emptyFunc() { }
}
class IWEncoder extends IWCodecBaseClass {
constructor(bytemap) {
super();
this.width = bytemap.width;
this.height = bytemap.height;
this.inverseWaveletTransform(bytemap);
this.createBlocks(bytemap);
}
inverseWaveletTransform(bytemap) {
for (var scale = 1; scale < 32; scale <<= 1) {
this.filter_fh(scale, bytemap);
this.filter_fv(scale, bytemap);
}
return bytemap;
}
filter_fv(s, bitmap) {
var kmax = Math.floor((bitmap.height - 1) / s);
for (var i = 0; i < bitmap.width; i += s) {
for (var k = 1; k <= kmax; k += 2) {
if ((k - 3 >= 0) && (k + 3 <= kmax)) {
bitmap[k * s][i] -= (9 * (bitmap[(k - 1) * s][i] + bitmap[(k + 1) * s][i]) - (bitmap[(k - 3) * s][i] + bitmap[(k + 3) * s][i]) + 8) >> 4;
} else if (k + 1 <= kmax) {
bitmap[k * s][i] -= (bitmap[(k - 1) * s][i] + bitmap[(k + 1) * s][i] + 1) >> 1;
} else {
bitmap[k * s][i] -= bitmap[(k - 1) * s][i];
}
}
for (var k = 0; k <= kmax; k += 2) {
var a, b, c, d;
if (k - 1 < 0) {
a = 0;
} else {
a = bitmap[(k - 1) * s][i];
}
if (k - 3 < 0) {
c = 0;
} else {
c = bitmap[(k - 3) * s][i];
}
if (k + 1 > kmax) {
b = 0;
} else {
b = bitmap[(k + 1) * s][i];
}
if (k + 3 > kmax) {
d = 0;
} else {
d = bitmap[(k + 3) * s][i];
}
bitmap[k * s][i] += (9 * (a + b) - (c + d) + 16) >> 5;
}
}
}
filter_fh(s, bitmap) {
var kmax = Math.floor((bitmap.width - 1) / s);
for (var i = 0; i < bitmap.height; i += s) {
for (var k = 1; k <= kmax; k += 2) {
if ((k - 3 >= 0) && (k + 3 <= kmax)) {
bitmap[i][k * s] -= (9 * (bitmap[i][(k - 1) * s] + bitmap[i][(k + 1) * s]) - (bitmap[i][(k - 3) * s] + bitmap[i][(k + 3) * s]) + 8) >> 4;
} else if (k + 1 <= kmax) {
bitmap[i][k * s] -= (bitmap[i][(k - 1) * s] + bitmap[i][(k + 1) * s] + 1) >> 1;
} else {
bitmap[i][k * s] -= bitmap[i][(k - 1) * s];
}
}
for (var k = 0; k <= kmax; k += 2) {
var a, b, c, d;
if (k - 1 < 0) {
a = 0;
} else {
a = bitmap[i][(k - 1) * s];
}
if (k - 3 < 0) {
c = 0;
} else {
c = bitmap[i][(k - 3) * s];
}
if (k + 1 > kmax) {
b = 0;
} else {
b = bitmap[i][(k + 1) * s];
}
if (k + 3 > kmax) {
d = 0;
} else {
d = bitmap[i][(k + 3) * s];
}
bitmap[i][k * s] += (9 * (a + b) - (c + d) + 16) >> 5;
}
}
}
createBlocks(bitmap) {
var blockRows = Math.ceil(this.height / 32);
var blockCols = Math.ceil(this.width / 32);
var length = blockRows * blockCols;
var buffer = new ArrayBuffer(length << 11);
this.blocks = [];
for (var r = 0; r < blockRows; r++) {
for (var c = 0; c < blockCols; c++) {
var block = new Block(buffer, (r * blockCols + c) << 11, true);
for (var i = 0; i < 1024; i++) {
var val = 0;
if (bitmap[this.zigzagRow[i] + 32 * r]) {
val = bitmap[this.zigzagRow[i] + 32 * r][this.zigzagCol[i] + 32 * c];
val = val || 0;
}
block.setCoef(i, val);
}
this.blocks.push(block);
}
}
buffer = new ArrayBuffer(length << 11);
this.eblocks = new Array(length);
for (var i = 0; i < length; i++) {
this.eblocks[i] = new Block(buffer, i << 11, true);
}
}
encodeSlice(zp) {
this.zp = zp;
if (!this.is_null_slice()) {
for (var i = 0; i < this.blocks.length; i++) {
var block = this.blocks[i];
var eblock = this.eblocks[i];
this.preliminaryFlagComputation(block, eblock);
if (this.blockBandEncodingPass()) {
this.bucketEncodingPass(eblock);
this.newlyActiveCoefficientEncodingPass(block, eblock);
}
this.previouslyActiveCoefficientEncodingPass(block, eblock);
}
}
return this.finish_code_slice();
}
previouslyActiveCoefficientEncodingPass(block, eblock) {
var boff = 0;
var step = this.quant_hi[this.curband];
var indices = this.getBandBuckets(this.curband);
for (var i = indices.from; i <= indices.to; i++ ,
boff++) {
for (var j = 0; j < 16; j++) {
if (this.coeffstate[boff][j] & this.ACTIVE) {
if (!this.curband) {
step = this.quant_lo[j];
}
var coef = Math.abs(block.buckets[i][j]);
var ecoef = eblock.buckets[i][j];
var pix = coef >= ecoef ? 1 : 0;
if (ecoef <= 3 * step) {
this.zp.encode(pix, this.inreaseCoefCtx, 0);
} else {
this.zp.IWencode(pix);
}
eblock.buckets[i][j] = ecoef - (pix ? 0 : step) + (step >> 1);
}
}
}
}
newlyActiveCoefficientEncodingPass(block, eblock) {
var boff = 0;
var indices = this.getBandBuckets(this.curband);
var step = this.quant_hi[this.curband];
for (var i = indices.from; i <= indices.to; i++ ,
boff++) {
if (this.bucketstate[boff] & this.NEW) {
var shift = 0;
if (this.bucketstate[boff] & this.ACTIVE) {
shift = 8;
}
var bucket = block.buckets[i];
var ebucket = eblock.buckets[i];
var np = 0;
for (var j = 0; j < 16; j++) {
if (this.coeffstate[boff][j] & this.UNK) {
np++;
}
}
for (var j = 0; j < 16; j++) {
if (this.coeffstate[boff][j] & this.UNK) {
var ip = Math.min(7, np);
this.zp.encode((this.coeffstate[boff][j] & this.NEW) ? 1 : 0, this.activateCoefCtx, shift + ip);
if (this.coeffstate[boff][j] & this.NEW) {
this.zp.IWencode((bucket[j] < 0) ? 1 : 0);
np = 0;
if (!this.curband) {
step = this.quant_lo[j];
}
ebucket[j] = (step + (step >> 1) - (step >> 3));
ebucket[j] = (step + (step >> 1));
}
if (np) {
np--;
}
}
}
}
}
}
bucketEncodingPass(eblock) {
var indices = this.getBandBuckets(this.curband);
var boff = 0;
for (var i = indices.from; i <= indices.to; i++ ,
boff++) {
if (!(this.bucketstate[boff] & this.UNK)) {
continue;
}
var n = 0;
if (this.curband) {
var t = 4 * i;
for (var j = t; j < t + 4; j++) {
if (eblock.getCoef(j)) {
n++;
}
}
if (n === 4) {
n--;
}
}
if (this.bbstate & this.ACTIVE) {
n |= 4;
}
this.zp.encode((this.bucketstate[boff] & this.NEW) ? 1 : 0, this.decodeCoefCtx, n + this.curband * 8);
}
}
blockBandEncodingPass() {
var indices = this.getBandBuckets(this.curband);
var bcount = indices.to - indices.from + 1;
if (bcount < 16 || (this.bbstate & this.ACTIVE)) {
this.bbstate |= this.NEW;
} else if (this.bbstate & this.UNK) {
this.zp.encode(this.bbstate & this.NEW ? 1 : 0, this.decodeBucketCtx, 0);
}
return this.bbstate & this.NEW;
}
preliminaryFlagComputation(block, eblock) {
this.bbstate = 0;
var bstatetmp = 0;
var indices = this.getBandBuckets(this.curband);
var step = this.quant_hi[this.curband];
if (this.curband) {
var boff = 0;
for (var j = indices.from; j <= indices.to; j++ , boff++) {
bstatetmp = 0;
var bucket = block.buckets[j];
var ebucket = eblock.buckets[j];
for (var k = 0; k < bucket.length; k++) {
if (ebucket[k]) {
this.coeffstate[boff][k] = this.ACTIVE;
} else if (bucket[k] >= step || bucket[k] <= -step) {
this.coeffstate[boff][k] = this.UNK | this.NEW;
} else {
this.coeffstate[boff][k] = this.UNK;
}
bstatetmp |= this.coeffstate[boff][k];
}
this.bucketstate[boff] = bstatetmp;
this.bbstate |= bstatetmp;
}
} else {
var bucket = block.buckets[0];
var ebucket = eblock.buckets[0];
for (var k = 0; k < bucket.length; k++) {
step = this.quant_lo[k];
if (this.coeffstate[0][k] !== this.ZERO) {
if (ebucket[k]) {
this.coeffstate[0][k] = this.ACTIVE;
} else if (bucket[k] >= step || bucket[k] <= -step) {
this.coeffstate[0][k] = this.UNK | this.NEW;
} else {
this.coeffstate[0][k] = this.UNK;
}
}
bstatetmp |= this.coeffstate[0][k];
}
this.bucketstate[0] = bstatetmp;
this.bbstate |= bstatetmp;
}
}
}
class IWImageWriter {
constructor(slicenumber, delayInit, grayscale) {
this.slicenumber = slicenumber || 100;
this.grayscale = grayscale || 0;
this.delayInit = (delayInit & 127) || 0;
this.onprocess = undefined;
}
get width() {
return this.imageData.width;
}
get height() {
return this.imageData.height;
}
startMultiPageDocument() {
this.dw = new DjVuWriter();
this.dw.startDJVM();
this.pageBuffers = [];
var dirm = {};
this.dirm = dirm;
dirm.offsets = [];
dirm.dflags = 129;
dirm.flags = [];
dirm.ids = [];
dirm.sizes = [];
}
addPageToDocument(imageData) {
var tbsw = new ByteStreamWriter();
this.writeImagePage(tbsw, imageData);
var buffer = tbsw.getBuffer();
this.pageBuffers.push(buffer);
this.dirm.flags.push(1);
this.dirm.ids.push('p' + this.dirm.ids.length);
this.dirm.sizes.push(buffer.byteLength);
}
endMultiPageDocument() {
this.dw.writeDirmChunk(this.dirm);
var len = this.pageBuffers.length;
for (var i = 0; i < len; i++) {
this.dw.writeFormChunkBuffer(this.pageBuffers.shift());
}
var buffer = this.dw.getBuffer();
delete this.dw;
delete this.pageBuffers;
delete this.dirm;
return buffer;
}
createMultiPageDocument(imageArray) {
var dw = new DjVuWriter();
dw.startDJVM();
var length = imageArray.length;
var pageBuffers = new Array(imageArray.length);
var dirm = {};
this.dirm = dirm;
dirm.offsets = [];
dirm.dflags = 129;
dirm.flags = new Array(imageArray.length);
dirm.ids = new Array(imageArray.length);
dirm.sizes = new Array(imageArray.length);
var tbsw = new ByteStreamWriter();
for (var i = 0; i < imageArray.length; i++) {
this.writeImagePage(tbsw, imageArray[i]);
var buffer = tbsw.getBuffer();
pageBuffers[i] = buffer;
tbsw.reset();
dirm.flags[i] = 1;
dirm.ids[i] = 'p' + i;
dirm.sizes[i] = buffer.byteLength;
this.onprocess ? this.onprocess((i + 1) / length) : 0;
}
dw.writeDirmChunk(dirm);
for (var i = 0; i < imageArray.length; i++) {
dw.writeFormChunkBuffer(pageBuffers[i]);
}
return new DjVuDocument(dw.getBuffer());
}
writeImagePage(bsw, imageData) {
bsw.writeStr('FORM').saveOffsetMark('formSize').jump(4).writeStr('DJVU');
bsw.writeStr('INFO')
.writeInt32(10)
.writeInt16(imageData.width)
.writeInt16(imageData.height)
.writeByte(24).writeByte(0)
.writeByte(100 & 0xff)
.writeByte(100 >> 8)
.writeByte(22).writeByte(1);
bsw.writeStr('BG44').saveOffsetMark('BG44Size').jump(4);
bsw.writeByte(0)
.writeByte(this.slicenumber)
.writeByte((this.grayscale << 7) | 1)
.writeByte(2)
.writeUint16(imageData.width)
.writeUint16(imageData.height)
.writeByte(this.delayInit);
var ycodec = new IWEncoder(this.RGBtoY(imageData));
var crcodec, cbcodec;
if (!this.grayscale) {
cbcodec = new IWEncoder(this.RGBtoCb(imageData));
crcodec = new IWEncoder(this.RGBtoCr(imageData));
}
var zp = new ZPEncoder(bsw);
for (var i = 0; i < this.slicenumber; i++) {
ycodec.encodeSlice(zp);
if (cbcodec && crcodec && i >= this.delayInit) {
cbcodec.encodeSlice(zp);
crcodec.encodeSlice(zp);
}
}
zp.eflush();
bsw.rewriteSize('formSize');
bsw.rewriteSize('BG44Size');
}
createOnePageDocument(imageData) {
var bsw = new ByteStreamWriter(10 * 1024);
bsw.writeStr('AT&T');
this.writeImagePage(bsw, imageData);
return new DjVuDocument(bsw.getBuffer());
}
RGBtoY(imageData) {
var rmul = new Int32Array(256);
var gmul = new Int32Array(256);
var bmul = new Int32Array(256);
var data = imageData.data;
var width = imageData.width;
var height = imageData.height;
var bytemap = new Bytemap(width, height);
if (this.grayscale) {
for (var i = 0; i < data.length; i++) {
data[i] = 255 - data[i];
}
}
for (var k = 0; k < 256; k++) {
rmul[k] = (k * 0x10000 * this.rgb_to_ycc[0][0]);
gmul[k] = (k * 0x10000 * this.rgb_to_ycc[0][1]);
bmul[k] = (k * 0x10000 * this.rgb_to_ycc[0][2]);
}
for (var i = 0; i < height; i++) {
for (var j = 0; j < width; j++) {
var index = ((height - i - 1) * width + j) << 2;
var y = rmul[data[index]] + gmul[data[index + 1]] + bmul[data[index + 2]] + 32768;
bytemap[i][j] = ((y >> 16) - 128) << this.iw_shift;
}
}
return bytemap;
}
RGBtoCb(imageData) {
var rmul = new Int32Array(256);
var gmul = new Int32Array(256);
var bmul = new Int32Array(256);
var data = imageData.data;
var width = imageData.width;
var height = imageData.height;
var bytemap = new Bytemap(width, height);
for (var k = 0; k < 256; k++) {
rmul[k] = (k * 0x10000 * this.rgb_to_ycc[2][0]);
gmul[k] = (k * 0x10000 * this.rgb_to_ycc[2][1]);
bmul[k] = (k * 0x10000 * this.rgb_to_ycc[2][2]);
}
for (var i = 0; i < height; i++) {
for (var j = 0; j < width; j++) {
var index = ((height - i - 1) * width + j) << 2;
var y = rmul[data[index]] + gmul[data[index + 1]] + bmul[data[index + 2]] + 32768;
bytemap[i][j] = Math.max(-128, Math.min(127, y >> 16)) << this.iw_shift;
}
}
return bytemap;
}
RGBtoCr(imageData) {
var rmul = new Int32Array(256);
var gmul = new Int32Array(256);
var bmul = new Int32Array(256);
var data = imageData.data;
var width = imageData.width;
var height = imageData.height;
var bytemap = new Bytemap(width, height);
for (var k = 0; k < 256; k++) {
rmul[k] = (k * 0x10000 * this.rgb_to_ycc[1][0]);
gmul[k] = (k * 0x10000 * this.rgb_to_ycc[1][1]);
bmul[k] = (k * 0x10000 * this.rgb_to_ycc[1][2]);
}
for (var i = 0; i < height; i++) {
for (var j = 0; j < width; j++) {
var index = ((height - i - 1) * width + j) << 2;
var y = rmul[data[index]] + gmul[data[index + 1]] + bmul[data[index + 2]] + 32768;
bytemap[i][j] = Math.max(-128, Math.min(127, y >> 16)) << this.iw_shift;
}
}
return bytemap;
}
}
IWImageWriter.prototype.iw_shift = 6;
IWImageWriter.prototype.rgb_to_ycc = [
[0.304348, 0.608696, 0.086956],
[0.463768, -0.405797, -0.057971],
[-0.173913, -0.347826, 0.521739]];
function initWorker() {
var djvuDocument;
var iwiw;
addEventListener("error", e => {
console.error(e);
postMessage("error");
});
addEventListener("unhandledrejection", e => {
console.error(e);
postMessage("unhandledrejection");
});
onmessage = async function ({ data: obj }) {
if (obj.action) return handlers[obj.action](obj);
try {
const { data, transferList } = await handlers[obj.command](obj) || {};
try {
postMessage({
command: obj.command,
...data,
...(obj.sendBackData ? { sendBackData: obj.sendBackData } : null),
}, transferList && transferList.length ? transferList : undefined);
} catch (e) {
throw new UnableToTransferDataDjVuError(obj.data);
}
} catch (error) {
console.error(error);
var errorObj = error instanceof DjVuError ? error : {
code: DjVuErrorCodes.UNEXPECTED_ERROR,
name: error.name,
message: error.message
};
errorObj.commandObject = obj;
postMessage({
command: 'Error',
error: errorObj,
...(obj.sendBackData ? { sendBackData: obj.sendBackData } : null),
});
}
};
function processValueBeforeTransfer(value, transferList) {
if (value instanceof ArrayBuffer) {
transferList.push(value);
return value;
}
if (value instanceof ImageData) {
transferList.push(value.data.buffer);
return {
width: value.width,
height: value.height,
buffer: value.data.buffer
};
}
if (value instanceof DjVuDocument) {
transferList.push(value.buffer);
return value.buffer;
}
return value;
}
function restoreHyperCallbacks(args) {
return args.map(arg => {
if (arg && (typeof arg === 'object') && arg.hyperCallback) {
return (...params) => postMessage({
action: 'hyperCallback',
id: arg.id,
args: params
});
}
return arg;
});
}
var handlers = {
async run(obj) {
const results = await Promise.all(obj.data.map(async task => {
var res = djvuDocument;
for (var i = 0; i < task.funcs.length; i++) {
if (typeof res[task.funcs[i]] !== 'function') {
throw new IncorrectTaskDjVuError(task);
}
res = await res[task.funcs[i]](...restoreHyperCallbacks(task.args[i]));
}
return res;
}));
var transferList = [];
var processedResults = results.map(result => processValueBeforeTransfer(result, transferList));
return {
data: {
result: processedResults.length === 1 ? processedResults[0] : processedResults
},
transferList
};
},
revokeObjectURL(obj) {
URL.revokeObjectURL(obj.url);
},
startMultiPageDocument(obj) {
iwiw = new IWImageWriter(obj.slicenumber, obj.delayInit, obj.grayscale);
iwiw.startMultiPageDocument();
},
addPageToDocument(obj) {
var imageData = new ImageData(new Uint8ClampedArray(obj.simpleImage.buffer), obj.simpleImage.width, obj.simpleImage.height);
iwiw.addPageToDocument(imageData);
},
endMultiPageDocument(obj) {
var buffer = iwiw.endMultiPageDocument();
return {
data: { buffer: buffer },
transferList: [buffer]
};
},
createDocumentFromPictures(obj) {
var sims = obj.images;
var imageArray = new Array(sims.length);
for (var i = 0; i < sims.length; i++) {
imageArray[i] = new ImageData(new Uint8ClampedArray(sims[i].buffer), sims[i].width, sims[i].height);
}
var iw = new IWImageWriter(obj.slicenumber, obj.delayInit, obj.grayscale);
iw.onprocess = (percent) => {
postMessage({ action: 'Process', percent: percent });
};
var ndoc = iw.createMultyPageDocument(imageArray);
return {
data: { buffer: ndoc.buffer },
transferList: [ndoc.buffer]
};
},
createDocument(obj) {
djvuDocument = new DjVuDocument(obj.buffer, obj.options);
},
};
}
if (!self.document) {
initWorker();
}
var index = Object.assign({}, DjVu, {
Worker: DjVuWorker,
Document: DjVuDocument,
ErrorCodes: DjVuErrorCodes
});
return index;
}
return Object.assign(DjVuScript(), {DjVuScript});
}());
Raw
djvu_viewer.js
This file has been truncated, but you can view the full file.
/*! For license information please see djvu_viewer.js.LICENSE.txt */
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment