mirror of
https://github.com/zen-browser/pdf.js.git
synced 2025-07-08 01:10:08 +02:00
de36b2aaba
Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
1340 lines
40 KiB
JavaScript
1340 lines
40 KiB
JavaScript
/* Copyright 2012 Mozilla Foundation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/* Copyright 1996-2003 Glyph & Cog, LLC
|
|
*
|
|
* The flate stream implementation contained in this file is a JavaScript port
|
|
* of XPDF's implementation, made available under the Apache 2.0 open source
|
|
* license.
|
|
*/
|
|
|
|
import {
|
|
FormatError,
|
|
isSpace,
|
|
stringToBytes,
|
|
unreachable,
|
|
} from "../shared/util";
|
|
import { isDict } from "./primitives";
|
|
|
|
var Stream = (function StreamClosure() {
|
|
function Stream(arrayBuffer, start, length, dict) {
|
|
this.bytes =
|
|
arrayBuffer instanceof Uint8Array
|
|
? arrayBuffer
|
|
: new Uint8Array(arrayBuffer);
|
|
this.start = start || 0;
|
|
this.pos = this.start;
|
|
this.end = start + length || this.bytes.length;
|
|
this.dict = dict;
|
|
}
|
|
|
|
// required methods for a stream. if a particular stream does not
|
|
// implement these, an error should be thrown
|
|
Stream.prototype = {
|
|
get length() {
|
|
return this.end - this.start;
|
|
},
|
|
get isEmpty() {
|
|
return this.length === 0;
|
|
},
|
|
getByte: function Stream_getByte() {
|
|
if (this.pos >= this.end) {
|
|
return -1;
|
|
}
|
|
return this.bytes[this.pos++];
|
|
},
|
|
getUint16: function Stream_getUint16() {
|
|
var b0 = this.getByte();
|
|
var b1 = this.getByte();
|
|
if (b0 === -1 || b1 === -1) {
|
|
return -1;
|
|
}
|
|
return (b0 << 8) + b1;
|
|
},
|
|
getInt32: function Stream_getInt32() {
|
|
var b0 = this.getByte();
|
|
var b1 = this.getByte();
|
|
var b2 = this.getByte();
|
|
var b3 = this.getByte();
|
|
return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
|
|
},
|
|
// Returns subarray of original buffer, should only be read.
|
|
getBytes(length, forceClamped = false) {
|
|
var bytes = this.bytes;
|
|
var pos = this.pos;
|
|
var strEnd = this.end;
|
|
|
|
if (!length) {
|
|
let subarray = bytes.subarray(pos, strEnd);
|
|
// `this.bytes` is always a `Uint8Array` here.
|
|
return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
|
|
}
|
|
var end = pos + length;
|
|
if (end > strEnd) {
|
|
end = strEnd;
|
|
}
|
|
this.pos = end;
|
|
let subarray = bytes.subarray(pos, end);
|
|
// `this.bytes` is always a `Uint8Array` here.
|
|
return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
|
|
},
|
|
peekByte: function Stream_peekByte() {
|
|
var peekedByte = this.getByte();
|
|
if (peekedByte !== -1) {
|
|
this.pos--;
|
|
}
|
|
return peekedByte;
|
|
},
|
|
peekBytes(length, forceClamped = false) {
|
|
var bytes = this.getBytes(length, forceClamped);
|
|
this.pos -= bytes.length;
|
|
return bytes;
|
|
},
|
|
|
|
getByteRange(begin, end) {
|
|
if (begin < 0) {
|
|
begin = 0;
|
|
}
|
|
if (end > this.end) {
|
|
end = this.end;
|
|
}
|
|
return this.bytes.subarray(begin, end);
|
|
},
|
|
|
|
skip: function Stream_skip(n) {
|
|
if (!n) {
|
|
n = 1;
|
|
}
|
|
this.pos += n;
|
|
},
|
|
reset: function Stream_reset() {
|
|
this.pos = this.start;
|
|
},
|
|
moveStart: function Stream_moveStart() {
|
|
this.start = this.pos;
|
|
},
|
|
makeSubStream: function Stream_makeSubStream(start, length, dict) {
|
|
return new Stream(this.bytes.buffer, start, length, dict);
|
|
},
|
|
};
|
|
|
|
return Stream;
|
|
})();
|
|
|
|
var StringStream = (function StringStreamClosure() {
|
|
function StringStream(str) {
|
|
let bytes = stringToBytes(str);
|
|
Stream.call(this, bytes);
|
|
}
|
|
|
|
StringStream.prototype = Stream.prototype;
|
|
|
|
return StringStream;
|
|
})();
|
|
|
|
// super class for the decoding streams
|
|
var DecodeStream = (function DecodeStreamClosure() {
|
|
// Lots of DecodeStreams are created whose buffers are never used. For these
|
|
// we share a single empty buffer. This is (a) space-efficient and (b) avoids
|
|
// having special cases that would be required if we used |null| for an empty
|
|
// buffer.
|
|
var emptyBuffer = new Uint8Array(0);
|
|
|
|
function DecodeStream(maybeMinBufferLength) {
|
|
this._rawMinBufferLength = maybeMinBufferLength || 0;
|
|
|
|
this.pos = 0;
|
|
this.bufferLength = 0;
|
|
this.eof = false;
|
|
this.buffer = emptyBuffer;
|
|
this.minBufferLength = 512;
|
|
if (maybeMinBufferLength) {
|
|
// Compute the first power of two that is as big as maybeMinBufferLength.
|
|
while (this.minBufferLength < maybeMinBufferLength) {
|
|
this.minBufferLength *= 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
DecodeStream.prototype = {
|
|
get isEmpty() {
|
|
while (!this.eof && this.bufferLength === 0) {
|
|
this.readBlock();
|
|
}
|
|
return this.bufferLength === 0;
|
|
},
|
|
ensureBuffer: function DecodeStream_ensureBuffer(requested) {
|
|
var buffer = this.buffer;
|
|
if (requested <= buffer.byteLength) {
|
|
return buffer;
|
|
}
|
|
var size = this.minBufferLength;
|
|
while (size < requested) {
|
|
size *= 2;
|
|
}
|
|
var buffer2 = new Uint8Array(size);
|
|
buffer2.set(buffer);
|
|
return (this.buffer = buffer2);
|
|
},
|
|
getByte: function DecodeStream_getByte() {
|
|
var pos = this.pos;
|
|
while (this.bufferLength <= pos) {
|
|
if (this.eof) {
|
|
return -1;
|
|
}
|
|
this.readBlock();
|
|
}
|
|
return this.buffer[this.pos++];
|
|
},
|
|
getUint16: function DecodeStream_getUint16() {
|
|
var b0 = this.getByte();
|
|
var b1 = this.getByte();
|
|
if (b0 === -1 || b1 === -1) {
|
|
return -1;
|
|
}
|
|
return (b0 << 8) + b1;
|
|
},
|
|
getInt32: function DecodeStream_getInt32() {
|
|
var b0 = this.getByte();
|
|
var b1 = this.getByte();
|
|
var b2 = this.getByte();
|
|
var b3 = this.getByte();
|
|
return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
|
|
},
|
|
getBytes(length, forceClamped = false) {
|
|
var end,
|
|
pos = this.pos;
|
|
|
|
if (length) {
|
|
this.ensureBuffer(pos + length);
|
|
end = pos + length;
|
|
|
|
while (!this.eof && this.bufferLength < end) {
|
|
this.readBlock();
|
|
}
|
|
var bufEnd = this.bufferLength;
|
|
if (end > bufEnd) {
|
|
end = bufEnd;
|
|
}
|
|
} else {
|
|
while (!this.eof) {
|
|
this.readBlock();
|
|
}
|
|
end = this.bufferLength;
|
|
}
|
|
|
|
this.pos = end;
|
|
let subarray = this.buffer.subarray(pos, end);
|
|
// `this.buffer` is either a `Uint8Array` or `Uint8ClampedArray` here.
|
|
return forceClamped && !(subarray instanceof Uint8ClampedArray)
|
|
? new Uint8ClampedArray(subarray)
|
|
: subarray;
|
|
},
|
|
peekByte: function DecodeStream_peekByte() {
|
|
var peekedByte = this.getByte();
|
|
if (peekedByte !== -1) {
|
|
this.pos--;
|
|
}
|
|
return peekedByte;
|
|
},
|
|
peekBytes(length, forceClamped = false) {
|
|
var bytes = this.getBytes(length, forceClamped);
|
|
this.pos -= bytes.length;
|
|
return bytes;
|
|
},
|
|
makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
|
|
var end = start + length;
|
|
while (this.bufferLength <= end && !this.eof) {
|
|
this.readBlock();
|
|
}
|
|
return new Stream(this.buffer, start, length, dict);
|
|
},
|
|
|
|
getByteRange(begin, end) {
|
|
unreachable("Should not call DecodeStream.getByteRange");
|
|
},
|
|
|
|
skip: function DecodeStream_skip(n) {
|
|
if (!n) {
|
|
n = 1;
|
|
}
|
|
this.pos += n;
|
|
},
|
|
reset: function DecodeStream_reset() {
|
|
this.pos = 0;
|
|
},
|
|
getBaseStreams: function DecodeStream_getBaseStreams() {
|
|
if (this.str && this.str.getBaseStreams) {
|
|
return this.str.getBaseStreams();
|
|
}
|
|
return [];
|
|
},
|
|
};
|
|
|
|
return DecodeStream;
|
|
})();
|
|
|
|
var StreamsSequenceStream = (function StreamsSequenceStreamClosure() {
|
|
function StreamsSequenceStream(streams) {
|
|
this.streams = streams;
|
|
|
|
let maybeLength = 0;
|
|
for (let i = 0, ii = streams.length; i < ii; i++) {
|
|
const stream = streams[i];
|
|
if (stream instanceof DecodeStream) {
|
|
maybeLength += stream._rawMinBufferLength;
|
|
} else {
|
|
maybeLength += stream.length;
|
|
}
|
|
}
|
|
DecodeStream.call(this, maybeLength);
|
|
}
|
|
|
|
StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
|
|
var streams = this.streams;
|
|
if (streams.length === 0) {
|
|
this.eof = true;
|
|
return;
|
|
}
|
|
var stream = streams.shift();
|
|
var chunk = stream.getBytes();
|
|
var bufferLength = this.bufferLength;
|
|
var newLength = bufferLength + chunk.length;
|
|
var buffer = this.ensureBuffer(newLength);
|
|
buffer.set(chunk, bufferLength);
|
|
this.bufferLength = newLength;
|
|
};
|
|
|
|
StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
|
|
var baseStreams = [];
|
|
for (var i = 0, ii = this.streams.length; i < ii; i++) {
|
|
var stream = this.streams[i];
|
|
if (stream.getBaseStreams) {
|
|
baseStreams.push(...stream.getBaseStreams());
|
|
}
|
|
}
|
|
return baseStreams;
|
|
};
|
|
|
|
return StreamsSequenceStream;
|
|
})();
|
|
|
|
var FlateStream = (function FlateStreamClosure() {
|
|
// prettier-ignore
|
|
var codeLenCodeMap = new Int32Array([
|
|
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
|
|
]);
|
|
|
|
// prettier-ignore
|
|
var lengthDecode = new Int32Array([
|
|
0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a,
|
|
0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f,
|
|
0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073,
|
|
0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102
|
|
]);
|
|
|
|
// prettier-ignore
|
|
var distDecode = new Int32Array([
|
|
0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d,
|
|
0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1,
|
|
0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01,
|
|
0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001
|
|
]);
|
|
|
|
// prettier-ignore
|
|
var fixedLitCodeTab = [new Int32Array([
|
|
0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0,
|
|
0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0,
|
|
0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0,
|
|
0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0,
|
|
0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8,
|
|
0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8,
|
|
0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8,
|
|
0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8,
|
|
0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4,
|
|
0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4,
|
|
0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4,
|
|
0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4,
|
|
0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc,
|
|
0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec,
|
|
0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc,
|
|
0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc,
|
|
0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2,
|
|
0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2,
|
|
0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2,
|
|
0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2,
|
|
0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca,
|
|
0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea,
|
|
0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da,
|
|
0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa,
|
|
0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6,
|
|
0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6,
|
|
0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6,
|
|
0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6,
|
|
0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce,
|
|
0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee,
|
|
0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de,
|
|
0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe,
|
|
0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1,
|
|
0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1,
|
|
0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1,
|
|
0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1,
|
|
0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9,
|
|
0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9,
|
|
0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9,
|
|
0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9,
|
|
0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5,
|
|
0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5,
|
|
0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5,
|
|
0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5,
|
|
0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd,
|
|
0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed,
|
|
0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd,
|
|
0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd,
|
|
0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3,
|
|
0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3,
|
|
0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3,
|
|
0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3,
|
|
0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb,
|
|
0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb,
|
|
0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db,
|
|
0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb,
|
|
0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7,
|
|
0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7,
|
|
0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7,
|
|
0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 0x900f7,
|
|
0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf,
|
|
0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef,
|
|
0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df,
|
|
0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff
|
|
]), 9];
|
|
|
|
// prettier-ignore
|
|
var fixedDistCodeTab = [new Int32Array([
|
|
0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c,
|
|
0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000,
|
|
0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d,
|
|
0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000
|
|
]), 5];
|
|
|
|
function FlateStream(str, maybeLength) {
|
|
this.str = str;
|
|
this.dict = str.dict;
|
|
|
|
var cmf = str.getByte();
|
|
var flg = str.getByte();
|
|
if (cmf === -1 || flg === -1) {
|
|
throw new FormatError(`Invalid header in flate stream: ${cmf}, ${flg}`);
|
|
}
|
|
if ((cmf & 0x0f) !== 0x08) {
|
|
throw new FormatError(
|
|
`Unknown compression method in flate stream: ${cmf}, ${flg}`
|
|
);
|
|
}
|
|
if (((cmf << 8) + flg) % 31 !== 0) {
|
|
throw new FormatError(`Bad FCHECK in flate stream: ${cmf}, ${flg}`);
|
|
}
|
|
if (flg & 0x20) {
|
|
throw new FormatError(`FDICT bit set in flate stream: ${cmf}, ${flg}`);
|
|
}
|
|
|
|
this.codeSize = 0;
|
|
this.codeBuf = 0;
|
|
|
|
DecodeStream.call(this, maybeLength);
|
|
}
|
|
|
|
FlateStream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
|
|
var str = this.str;
|
|
var codeSize = this.codeSize;
|
|
var codeBuf = this.codeBuf;
|
|
|
|
var b;
|
|
while (codeSize < bits) {
|
|
if ((b = str.getByte()) === -1) {
|
|
throw new FormatError("Bad encoding in flate stream");
|
|
}
|
|
codeBuf |= b << codeSize;
|
|
codeSize += 8;
|
|
}
|
|
b = codeBuf & ((1 << bits) - 1);
|
|
this.codeBuf = codeBuf >> bits;
|
|
this.codeSize = codeSize -= bits;
|
|
|
|
return b;
|
|
};
|
|
|
|
FlateStream.prototype.getCode = function FlateStream_getCode(table) {
|
|
var str = this.str;
|
|
var codes = table[0];
|
|
var maxLen = table[1];
|
|
var codeSize = this.codeSize;
|
|
var codeBuf = this.codeBuf;
|
|
|
|
var b;
|
|
while (codeSize < maxLen) {
|
|
if ((b = str.getByte()) === -1) {
|
|
// premature end of stream. code might however still be valid.
|
|
// codeSize < codeLen check below guards against incomplete codeVal.
|
|
break;
|
|
}
|
|
codeBuf |= b << codeSize;
|
|
codeSize += 8;
|
|
}
|
|
var code = codes[codeBuf & ((1 << maxLen) - 1)];
|
|
var codeLen = code >> 16;
|
|
var codeVal = code & 0xffff;
|
|
if (codeLen < 1 || codeSize < codeLen) {
|
|
throw new FormatError("Bad encoding in flate stream");
|
|
}
|
|
this.codeBuf = codeBuf >> codeLen;
|
|
this.codeSize = codeSize - codeLen;
|
|
return codeVal;
|
|
};
|
|
|
|
FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(
|
|
lengths
|
|
) {
|
|
var n = lengths.length;
|
|
|
|
// find max code length
|
|
var maxLen = 0;
|
|
var i;
|
|
for (i = 0; i < n; ++i) {
|
|
if (lengths[i] > maxLen) {
|
|
maxLen = lengths[i];
|
|
}
|
|
}
|
|
|
|
// build the table
|
|
var size = 1 << maxLen;
|
|
var codes = new Int32Array(size);
|
|
for (
|
|
var len = 1, code = 0, skip = 2;
|
|
len <= maxLen;
|
|
++len, code <<= 1, skip <<= 1
|
|
) {
|
|
for (var val = 0; val < n; ++val) {
|
|
if (lengths[val] === len) {
|
|
// bit-reverse the code
|
|
var code2 = 0;
|
|
var t = code;
|
|
for (i = 0; i < len; ++i) {
|
|
code2 = (code2 << 1) | (t & 1);
|
|
t >>= 1;
|
|
}
|
|
|
|
// fill the table entries
|
|
for (i = code2; i < size; i += skip) {
|
|
codes[i] = (len << 16) | val;
|
|
}
|
|
++code;
|
|
}
|
|
}
|
|
}
|
|
|
|
return [codes, maxLen];
|
|
};
|
|
|
|
FlateStream.prototype.readBlock = function FlateStream_readBlock() {
|
|
var buffer, len;
|
|
var str = this.str;
|
|
// read block header
|
|
var hdr = this.getBits(3);
|
|
if (hdr & 1) {
|
|
this.eof = true;
|
|
}
|
|
hdr >>= 1;
|
|
|
|
if (hdr === 0) {
|
|
// uncompressed block
|
|
var b;
|
|
|
|
if ((b = str.getByte()) === -1) {
|
|
throw new FormatError("Bad block header in flate stream");
|
|
}
|
|
var blockLen = b;
|
|
if ((b = str.getByte()) === -1) {
|
|
throw new FormatError("Bad block header in flate stream");
|
|
}
|
|
blockLen |= b << 8;
|
|
if ((b = str.getByte()) === -1) {
|
|
throw new FormatError("Bad block header in flate stream");
|
|
}
|
|
var check = b;
|
|
if ((b = str.getByte()) === -1) {
|
|
throw new FormatError("Bad block header in flate stream");
|
|
}
|
|
check |= b << 8;
|
|
if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
|
|
// Ignoring error for bad "empty" block (see issue 1277)
|
|
throw new FormatError("Bad uncompressed block length in flate stream");
|
|
}
|
|
|
|
this.codeBuf = 0;
|
|
this.codeSize = 0;
|
|
|
|
const bufferLength = this.bufferLength,
|
|
end = bufferLength + blockLen;
|
|
buffer = this.ensureBuffer(end);
|
|
this.bufferLength = end;
|
|
|
|
if (blockLen === 0) {
|
|
if (str.peekByte() === -1) {
|
|
this.eof = true;
|
|
}
|
|
} else {
|
|
const block = str.getBytes(blockLen);
|
|
buffer.set(block, bufferLength);
|
|
if (block.length < blockLen) {
|
|
this.eof = true;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
var litCodeTable;
|
|
var distCodeTable;
|
|
if (hdr === 1) {
|
|
// compressed block, fixed codes
|
|
litCodeTable = fixedLitCodeTab;
|
|
distCodeTable = fixedDistCodeTab;
|
|
} else if (hdr === 2) {
|
|
// compressed block, dynamic codes
|
|
var numLitCodes = this.getBits(5) + 257;
|
|
var numDistCodes = this.getBits(5) + 1;
|
|
var numCodeLenCodes = this.getBits(4) + 4;
|
|
|
|
// build the code lengths code table
|
|
var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
|
|
|
|
var i;
|
|
for (i = 0; i < numCodeLenCodes; ++i) {
|
|
codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
|
|
}
|
|
var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
|
|
|
|
// build the literal and distance code tables
|
|
len = 0;
|
|
i = 0;
|
|
var codes = numLitCodes + numDistCodes;
|
|
var codeLengths = new Uint8Array(codes);
|
|
var bitsLength, bitsOffset, what;
|
|
while (i < codes) {
|
|
var code = this.getCode(codeLenCodeTab);
|
|
if (code === 16) {
|
|
bitsLength = 2;
|
|
bitsOffset = 3;
|
|
what = len;
|
|
} else if (code === 17) {
|
|
bitsLength = 3;
|
|
bitsOffset = 3;
|
|
what = len = 0;
|
|
} else if (code === 18) {
|
|
bitsLength = 7;
|
|
bitsOffset = 11;
|
|
what = len = 0;
|
|
} else {
|
|
codeLengths[i++] = len = code;
|
|
continue;
|
|
}
|
|
|
|
var repeatLength = this.getBits(bitsLength) + bitsOffset;
|
|
while (repeatLength-- > 0) {
|
|
codeLengths[i++] = what;
|
|
}
|
|
}
|
|
|
|
litCodeTable = this.generateHuffmanTable(
|
|
codeLengths.subarray(0, numLitCodes)
|
|
);
|
|
distCodeTable = this.generateHuffmanTable(
|
|
codeLengths.subarray(numLitCodes, codes)
|
|
);
|
|
} else {
|
|
throw new FormatError("Unknown block type in flate stream");
|
|
}
|
|
|
|
buffer = this.buffer;
|
|
var limit = buffer ? buffer.length : 0;
|
|
var pos = this.bufferLength;
|
|
while (true) {
|
|
var code1 = this.getCode(litCodeTable);
|
|
if (code1 < 256) {
|
|
if (pos + 1 >= limit) {
|
|
buffer = this.ensureBuffer(pos + 1);
|
|
limit = buffer.length;
|
|
}
|
|
buffer[pos++] = code1;
|
|
continue;
|
|
}
|
|
if (code1 === 256) {
|
|
this.bufferLength = pos;
|
|
return;
|
|
}
|
|
code1 -= 257;
|
|
code1 = lengthDecode[code1];
|
|
var code2 = code1 >> 16;
|
|
if (code2 > 0) {
|
|
code2 = this.getBits(code2);
|
|
}
|
|
len = (code1 & 0xffff) + code2;
|
|
code1 = this.getCode(distCodeTable);
|
|
code1 = distDecode[code1];
|
|
code2 = code1 >> 16;
|
|
if (code2 > 0) {
|
|
code2 = this.getBits(code2);
|
|
}
|
|
var dist = (code1 & 0xffff) + code2;
|
|
if (pos + len >= limit) {
|
|
buffer = this.ensureBuffer(pos + len);
|
|
limit = buffer.length;
|
|
}
|
|
for (var k = 0; k < len; ++k, ++pos) {
|
|
buffer[pos] = buffer[pos - dist];
|
|
}
|
|
}
|
|
};
|
|
|
|
return FlateStream;
|
|
})();
|
|
|
|
var PredictorStream = (function PredictorStreamClosure() {
|
|
function PredictorStream(str, maybeLength, params) {
|
|
if (!isDict(params)) {
|
|
return str; // no prediction
|
|
}
|
|
var predictor = (this.predictor = params.get("Predictor") || 1);
|
|
|
|
if (predictor <= 1) {
|
|
return str; // no prediction
|
|
}
|
|
if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
|
|
throw new FormatError(`Unsupported predictor: ${predictor}`);
|
|
}
|
|
|
|
if (predictor === 2) {
|
|
this.readBlock = this.readBlockTiff;
|
|
} else {
|
|
this.readBlock = this.readBlockPng;
|
|
}
|
|
|
|
this.str = str;
|
|
this.dict = str.dict;
|
|
|
|
var colors = (this.colors = params.get("Colors") || 1);
|
|
var bits = (this.bits = params.get("BitsPerComponent") || 8);
|
|
var columns = (this.columns = params.get("Columns") || 1);
|
|
|
|
this.pixBytes = (colors * bits + 7) >> 3;
|
|
this.rowBytes = (columns * colors * bits + 7) >> 3;
|
|
|
|
DecodeStream.call(this, maybeLength);
|
|
return this;
|
|
}
|
|
|
|
PredictorStream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
PredictorStream.prototype.readBlockTiff = function predictorStreamReadBlockTiff() {
|
|
var rowBytes = this.rowBytes;
|
|
|
|
var bufferLength = this.bufferLength;
|
|
var buffer = this.ensureBuffer(bufferLength + rowBytes);
|
|
|
|
var bits = this.bits;
|
|
var colors = this.colors;
|
|
|
|
var rawBytes = this.str.getBytes(rowBytes);
|
|
this.eof = !rawBytes.length;
|
|
if (this.eof) {
|
|
return;
|
|
}
|
|
|
|
var inbuf = 0,
|
|
outbuf = 0;
|
|
var inbits = 0,
|
|
outbits = 0;
|
|
var pos = bufferLength;
|
|
var i;
|
|
|
|
if (bits === 1 && colors === 1) {
|
|
// Optimized version of the loop in the "else"-branch
|
|
// for 1 bit-per-component and 1 color TIFF images.
|
|
for (i = 0; i < rowBytes; ++i) {
|
|
var c = rawBytes[i] ^ inbuf;
|
|
c ^= c >> 1;
|
|
c ^= c >> 2;
|
|
c ^= c >> 4;
|
|
inbuf = (c & 1) << 7;
|
|
buffer[pos++] = c;
|
|
}
|
|
} else if (bits === 8) {
|
|
for (i = 0; i < colors; ++i) {
|
|
buffer[pos++] = rawBytes[i];
|
|
}
|
|
for (; i < rowBytes; ++i) {
|
|
buffer[pos] = buffer[pos - colors] + rawBytes[i];
|
|
pos++;
|
|
}
|
|
} else if (bits === 16) {
|
|
var bytesPerPixel = colors * 2;
|
|
for (i = 0; i < bytesPerPixel; ++i) {
|
|
buffer[pos++] = rawBytes[i];
|
|
}
|
|
for (; i < rowBytes; i += 2) {
|
|
var sum =
|
|
((rawBytes[i] & 0xff) << 8) +
|
|
(rawBytes[i + 1] & 0xff) +
|
|
((buffer[pos - bytesPerPixel] & 0xff) << 8) +
|
|
(buffer[pos - bytesPerPixel + 1] & 0xff);
|
|
buffer[pos++] = (sum >> 8) & 0xff;
|
|
buffer[pos++] = sum & 0xff;
|
|
}
|
|
} else {
|
|
var compArray = new Uint8Array(colors + 1);
|
|
var bitMask = (1 << bits) - 1;
|
|
var j = 0,
|
|
k = bufferLength;
|
|
var columns = this.columns;
|
|
for (i = 0; i < columns; ++i) {
|
|
for (var kk = 0; kk < colors; ++kk) {
|
|
if (inbits < bits) {
|
|
inbuf = (inbuf << 8) | (rawBytes[j++] & 0xff);
|
|
inbits += 8;
|
|
}
|
|
compArray[kk] =
|
|
(compArray[kk] + (inbuf >> (inbits - bits))) & bitMask;
|
|
inbits -= bits;
|
|
outbuf = (outbuf << bits) | compArray[kk];
|
|
outbits += bits;
|
|
if (outbits >= 8) {
|
|
buffer[k++] = (outbuf >> (outbits - 8)) & 0xff;
|
|
outbits -= 8;
|
|
}
|
|
}
|
|
}
|
|
if (outbits > 0) {
|
|
buffer[k++] =
|
|
(outbuf << (8 - outbits)) + (inbuf & ((1 << (8 - outbits)) - 1));
|
|
}
|
|
}
|
|
this.bufferLength += rowBytes;
|
|
};
|
|
|
|
PredictorStream.prototype.readBlockPng = function predictorStreamReadBlockPng() {
|
|
var rowBytes = this.rowBytes;
|
|
var pixBytes = this.pixBytes;
|
|
|
|
var predictor = this.str.getByte();
|
|
var rawBytes = this.str.getBytes(rowBytes);
|
|
this.eof = !rawBytes.length;
|
|
if (this.eof) {
|
|
return;
|
|
}
|
|
|
|
var bufferLength = this.bufferLength;
|
|
var buffer = this.ensureBuffer(bufferLength + rowBytes);
|
|
|
|
var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
|
|
if (prevRow.length === 0) {
|
|
prevRow = new Uint8Array(rowBytes);
|
|
}
|
|
|
|
var i,
|
|
j = bufferLength,
|
|
up,
|
|
c;
|
|
switch (predictor) {
|
|
case 0:
|
|
for (i = 0; i < rowBytes; ++i) {
|
|
buffer[j++] = rawBytes[i];
|
|
}
|
|
break;
|
|
case 1:
|
|
for (i = 0; i < pixBytes; ++i) {
|
|
buffer[j++] = rawBytes[i];
|
|
}
|
|
for (; i < rowBytes; ++i) {
|
|
buffer[j] = (buffer[j - pixBytes] + rawBytes[i]) & 0xff;
|
|
j++;
|
|
}
|
|
break;
|
|
case 2:
|
|
for (i = 0; i < rowBytes; ++i) {
|
|
buffer[j++] = (prevRow[i] + rawBytes[i]) & 0xff;
|
|
}
|
|
break;
|
|
case 3:
|
|
for (i = 0; i < pixBytes; ++i) {
|
|
buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
|
|
}
|
|
for (; i < rowBytes; ++i) {
|
|
buffer[j] =
|
|
(((prevRow[i] + buffer[j - pixBytes]) >> 1) + rawBytes[i]) & 0xff;
|
|
j++;
|
|
}
|
|
break;
|
|
case 4:
|
|
// we need to save the up left pixels values. the simplest way
|
|
// is to create a new buffer
|
|
for (i = 0; i < pixBytes; ++i) {
|
|
up = prevRow[i];
|
|
c = rawBytes[i];
|
|
buffer[j++] = up + c;
|
|
}
|
|
for (; i < rowBytes; ++i) {
|
|
up = prevRow[i];
|
|
var upLeft = prevRow[i - pixBytes];
|
|
var left = buffer[j - pixBytes];
|
|
var p = left + up - upLeft;
|
|
|
|
var pa = p - left;
|
|
if (pa < 0) {
|
|
pa = -pa;
|
|
}
|
|
var pb = p - up;
|
|
if (pb < 0) {
|
|
pb = -pb;
|
|
}
|
|
var pc = p - upLeft;
|
|
if (pc < 0) {
|
|
pc = -pc;
|
|
}
|
|
|
|
c = rawBytes[i];
|
|
if (pa <= pb && pa <= pc) {
|
|
buffer[j++] = left + c;
|
|
} else if (pb <= pc) {
|
|
buffer[j++] = up + c;
|
|
} else {
|
|
buffer[j++] = upLeft + c;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new FormatError(`Unsupported predictor: ${predictor}`);
|
|
}
|
|
this.bufferLength += rowBytes;
|
|
};
|
|
|
|
return PredictorStream;
|
|
})();
|
|
|
|
var DecryptStream = (function DecryptStreamClosure() {
|
|
function DecryptStream(str, maybeLength, decrypt) {
|
|
this.str = str;
|
|
this.dict = str.dict;
|
|
this.decrypt = decrypt;
|
|
this.nextChunk = null;
|
|
this.initialized = false;
|
|
|
|
DecodeStream.call(this, maybeLength);
|
|
}
|
|
|
|
var chunkSize = 512;
|
|
|
|
DecryptStream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {
|
|
var chunk;
|
|
if (this.initialized) {
|
|
chunk = this.nextChunk;
|
|
} else {
|
|
chunk = this.str.getBytes(chunkSize);
|
|
this.initialized = true;
|
|
}
|
|
if (!chunk || chunk.length === 0) {
|
|
this.eof = true;
|
|
return;
|
|
}
|
|
this.nextChunk = this.str.getBytes(chunkSize);
|
|
var hasMoreData = this.nextChunk && this.nextChunk.length > 0;
|
|
|
|
var decrypt = this.decrypt;
|
|
chunk = decrypt(chunk, !hasMoreData);
|
|
|
|
var bufferLength = this.bufferLength;
|
|
var i,
|
|
n = chunk.length;
|
|
var buffer = this.ensureBuffer(bufferLength + n);
|
|
for (i = 0; i < n; i++) {
|
|
buffer[bufferLength++] = chunk[i];
|
|
}
|
|
this.bufferLength = bufferLength;
|
|
};
|
|
|
|
return DecryptStream;
|
|
})();
|
|
|
|
var Ascii85Stream = (function Ascii85StreamClosure() {
|
|
function Ascii85Stream(str, maybeLength) {
|
|
this.str = str;
|
|
this.dict = str.dict;
|
|
this.input = new Uint8Array(5);
|
|
|
|
// Most streams increase in size when decoded, but Ascii85 streams
|
|
// typically shrink by ~20%.
|
|
if (maybeLength) {
|
|
maybeLength = 0.8 * maybeLength;
|
|
}
|
|
DecodeStream.call(this, maybeLength);
|
|
}
|
|
|
|
Ascii85Stream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {
|
|
var TILDA_CHAR = 0x7e; // '~'
|
|
var Z_LOWER_CHAR = 0x7a; // 'z'
|
|
var EOF = -1;
|
|
|
|
var str = this.str;
|
|
|
|
var c = str.getByte();
|
|
while (isSpace(c)) {
|
|
c = str.getByte();
|
|
}
|
|
|
|
if (c === EOF || c === TILDA_CHAR) {
|
|
this.eof = true;
|
|
return;
|
|
}
|
|
|
|
var bufferLength = this.bufferLength,
|
|
buffer;
|
|
var i;
|
|
|
|
// special code for z
|
|
if (c === Z_LOWER_CHAR) {
|
|
buffer = this.ensureBuffer(bufferLength + 4);
|
|
for (i = 0; i < 4; ++i) {
|
|
buffer[bufferLength + i] = 0;
|
|
}
|
|
this.bufferLength += 4;
|
|
} else {
|
|
var input = this.input;
|
|
input[0] = c;
|
|
for (i = 1; i < 5; ++i) {
|
|
c = str.getByte();
|
|
while (isSpace(c)) {
|
|
c = str.getByte();
|
|
}
|
|
|
|
input[i] = c;
|
|
|
|
if (c === EOF || c === TILDA_CHAR) {
|
|
break;
|
|
}
|
|
}
|
|
buffer = this.ensureBuffer(bufferLength + i - 1);
|
|
this.bufferLength += i - 1;
|
|
|
|
// partial ending;
|
|
if (i < 5) {
|
|
for (; i < 5; ++i) {
|
|
input[i] = 0x21 + 84;
|
|
}
|
|
this.eof = true;
|
|
}
|
|
var t = 0;
|
|
for (i = 0; i < 5; ++i) {
|
|
t = t * 85 + (input[i] - 0x21);
|
|
}
|
|
|
|
for (i = 3; i >= 0; --i) {
|
|
buffer[bufferLength + i] = t & 0xff;
|
|
t >>= 8;
|
|
}
|
|
}
|
|
};
|
|
|
|
return Ascii85Stream;
|
|
})();
|
|
|
|
var AsciiHexStream = (function AsciiHexStreamClosure() {
|
|
function AsciiHexStream(str, maybeLength) {
|
|
this.str = str;
|
|
this.dict = str.dict;
|
|
|
|
this.firstDigit = -1;
|
|
|
|
// Most streams increase in size when decoded, but AsciiHex streams shrink
|
|
// by 50%.
|
|
if (maybeLength) {
|
|
maybeLength = 0.5 * maybeLength;
|
|
}
|
|
DecodeStream.call(this, maybeLength);
|
|
}
|
|
|
|
AsciiHexStream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {
|
|
var UPSTREAM_BLOCK_SIZE = 8000;
|
|
var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);
|
|
if (!bytes.length) {
|
|
this.eof = true;
|
|
return;
|
|
}
|
|
|
|
var maxDecodeLength = (bytes.length + 1) >> 1;
|
|
var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
|
|
var bufferLength = this.bufferLength;
|
|
|
|
var firstDigit = this.firstDigit;
|
|
for (var i = 0, ii = bytes.length; i < ii; i++) {
|
|
var ch = bytes[i],
|
|
digit;
|
|
if (ch >= 0x30 && ch <= 0x39) {
|
|
// '0'-'9'
|
|
digit = ch & 0x0f;
|
|
} else if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {
|
|
// 'A'-'Z', 'a'-'z'
|
|
digit = (ch & 0x0f) + 9;
|
|
} else if (ch === 0x3e) {
|
|
// '>'
|
|
this.eof = true;
|
|
break;
|
|
} else {
|
|
// probably whitespace
|
|
continue; // ignoring
|
|
}
|
|
if (firstDigit < 0) {
|
|
firstDigit = digit;
|
|
} else {
|
|
buffer[bufferLength++] = (firstDigit << 4) | digit;
|
|
firstDigit = -1;
|
|
}
|
|
}
|
|
if (firstDigit >= 0 && this.eof) {
|
|
// incomplete byte
|
|
buffer[bufferLength++] = firstDigit << 4;
|
|
firstDigit = -1;
|
|
}
|
|
this.firstDigit = firstDigit;
|
|
this.bufferLength = bufferLength;
|
|
};
|
|
|
|
return AsciiHexStream;
|
|
})();
|
|
|
|
var RunLengthStream = (function RunLengthStreamClosure() {
|
|
function RunLengthStream(str, maybeLength) {
|
|
this.str = str;
|
|
this.dict = str.dict;
|
|
|
|
DecodeStream.call(this, maybeLength);
|
|
}
|
|
|
|
RunLengthStream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {
|
|
// The repeatHeader has following format. The first byte defines type of run
|
|
// and amount of bytes to repeat/copy: n = 0 through 127 - copy next n bytes
|
|
// (in addition to the second byte from the header), n = 129 through 255 -
|
|
// duplicate the second byte from the header (257 - n) times, n = 128 - end.
|
|
var repeatHeader = this.str.getBytes(2);
|
|
if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
|
|
this.eof = true;
|
|
return;
|
|
}
|
|
|
|
var buffer;
|
|
var bufferLength = this.bufferLength;
|
|
var n = repeatHeader[0];
|
|
if (n < 128) {
|
|
// copy n bytes
|
|
buffer = this.ensureBuffer(bufferLength + n + 1);
|
|
buffer[bufferLength++] = repeatHeader[1];
|
|
if (n > 0) {
|
|
var source = this.str.getBytes(n);
|
|
buffer.set(source, bufferLength);
|
|
bufferLength += n;
|
|
}
|
|
} else {
|
|
n = 257 - n;
|
|
var b = repeatHeader[1];
|
|
buffer = this.ensureBuffer(bufferLength + n + 1);
|
|
for (var i = 0; i < n; i++) {
|
|
buffer[bufferLength++] = b;
|
|
}
|
|
}
|
|
this.bufferLength = bufferLength;
|
|
};
|
|
|
|
return RunLengthStream;
|
|
})();
|
|
|
|
var LZWStream = (function LZWStreamClosure() {
|
|
function LZWStream(str, maybeLength, earlyChange) {
|
|
this.str = str;
|
|
this.dict = str.dict;
|
|
this.cachedData = 0;
|
|
this.bitsCached = 0;
|
|
|
|
var maxLzwDictionarySize = 4096;
|
|
var lzwState = {
|
|
earlyChange,
|
|
codeLength: 9,
|
|
nextCode: 258,
|
|
dictionaryValues: new Uint8Array(maxLzwDictionarySize),
|
|
dictionaryLengths: new Uint16Array(maxLzwDictionarySize),
|
|
dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),
|
|
currentSequence: new Uint8Array(maxLzwDictionarySize),
|
|
currentSequenceLength: 0,
|
|
};
|
|
for (var i = 0; i < 256; ++i) {
|
|
lzwState.dictionaryValues[i] = i;
|
|
lzwState.dictionaryLengths[i] = 1;
|
|
}
|
|
this.lzwState = lzwState;
|
|
|
|
DecodeStream.call(this, maybeLength);
|
|
}
|
|
|
|
LZWStream.prototype = Object.create(DecodeStream.prototype);
|
|
|
|
LZWStream.prototype.readBits = function LZWStream_readBits(n) {
|
|
var bitsCached = this.bitsCached;
|
|
var cachedData = this.cachedData;
|
|
while (bitsCached < n) {
|
|
var c = this.str.getByte();
|
|
if (c === -1) {
|
|
this.eof = true;
|
|
return null;
|
|
}
|
|
cachedData = (cachedData << 8) | c;
|
|
bitsCached += 8;
|
|
}
|
|
this.bitsCached = bitsCached -= n;
|
|
this.cachedData = cachedData;
|
|
this.lastCode = null;
|
|
return (cachedData >>> bitsCached) & ((1 << n) - 1);
|
|
};
|
|
|
|
LZWStream.prototype.readBlock = function LZWStream_readBlock() {
|
|
var blockSize = 512;
|
|
var estimatedDecodedSize = blockSize * 2,
|
|
decodedSizeDelta = blockSize;
|
|
var i, j, q;
|
|
|
|
var lzwState = this.lzwState;
|
|
if (!lzwState) {
|
|
return; // eof was found
|
|
}
|
|
|
|
var earlyChange = lzwState.earlyChange;
|
|
var nextCode = lzwState.nextCode;
|
|
var dictionaryValues = lzwState.dictionaryValues;
|
|
var dictionaryLengths = lzwState.dictionaryLengths;
|
|
var dictionaryPrevCodes = lzwState.dictionaryPrevCodes;
|
|
var codeLength = lzwState.codeLength;
|
|
var prevCode = lzwState.prevCode;
|
|
var currentSequence = lzwState.currentSequence;
|
|
var currentSequenceLength = lzwState.currentSequenceLength;
|
|
|
|
var decodedLength = 0;
|
|
var currentBufferLength = this.bufferLength;
|
|
var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
|
|
|
|
for (i = 0; i < blockSize; i++) {
|
|
var code = this.readBits(codeLength);
|
|
var hasPrev = currentSequenceLength > 0;
|
|
if (code < 256) {
|
|
currentSequence[0] = code;
|
|
currentSequenceLength = 1;
|
|
} else if (code >= 258) {
|
|
if (code < nextCode) {
|
|
currentSequenceLength = dictionaryLengths[code];
|
|
for (j = currentSequenceLength - 1, q = code; j >= 0; j--) {
|
|
currentSequence[j] = dictionaryValues[q];
|
|
q = dictionaryPrevCodes[q];
|
|
}
|
|
} else {
|
|
currentSequence[currentSequenceLength++] = currentSequence[0];
|
|
}
|
|
} else if (code === 256) {
|
|
codeLength = 9;
|
|
nextCode = 258;
|
|
currentSequenceLength = 0;
|
|
continue;
|
|
} else {
|
|
this.eof = true;
|
|
delete this.lzwState;
|
|
break;
|
|
}
|
|
|
|
if (hasPrev) {
|
|
dictionaryPrevCodes[nextCode] = prevCode;
|
|
dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1;
|
|
dictionaryValues[nextCode] = currentSequence[0];
|
|
nextCode++;
|
|
codeLength =
|
|
(nextCode + earlyChange) & (nextCode + earlyChange - 1)
|
|
? codeLength
|
|
: Math.min(
|
|
Math.log(nextCode + earlyChange) / 0.6931471805599453 + 1,
|
|
12
|
|
) | 0;
|
|
}
|
|
prevCode = code;
|
|
|
|
decodedLength += currentSequenceLength;
|
|
if (estimatedDecodedSize < decodedLength) {
|
|
do {
|
|
estimatedDecodedSize += decodedSizeDelta;
|
|
} while (estimatedDecodedSize < decodedLength);
|
|
buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
|
|
}
|
|
for (j = 0; j < currentSequenceLength; j++) {
|
|
buffer[currentBufferLength++] = currentSequence[j];
|
|
}
|
|
}
|
|
lzwState.nextCode = nextCode;
|
|
lzwState.codeLength = codeLength;
|
|
lzwState.prevCode = prevCode;
|
|
lzwState.currentSequenceLength = currentSequenceLength;
|
|
|
|
this.bufferLength = currentBufferLength;
|
|
};
|
|
|
|
return LZWStream;
|
|
})();
|
|
|
|
var NullStream = (function NullStreamClosure() {
|
|
function NullStream() {
|
|
Stream.call(this, new Uint8Array(0));
|
|
}
|
|
|
|
NullStream.prototype = Stream.prototype;
|
|
|
|
return NullStream;
|
|
})();
|
|
|
|
export {
|
|
Ascii85Stream,
|
|
AsciiHexStream,
|
|
DecryptStream,
|
|
DecodeStream,
|
|
FlateStream,
|
|
NullStream,
|
|
PredictorStream,
|
|
RunLengthStream,
|
|
Stream,
|
|
StreamsSequenceStream,
|
|
StringStream,
|
|
LZWStream,
|
|
};
|