Sakurai/pdf.js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Enable the no-var rule in the src/core/jbig2.js file

Browse Source 
These changes were made automatically, using `gulp lint --fix`.
This commit is contained in:
Jonas Jenwald 2021-05-05 12:12:35 +02:00
parent 52961197d3
commit 7ca3a34e1f
1 changed files with 175 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

343
src/core/jbig2.js
View File

@ -12,7 +12,6 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
/* eslint-disable no-var */
import { BaseException, shadow } from "../shared/util.js"; import { BaseException, shadow } from "../shared/util.js";
import { log2, readInt8, readUint16, readUint32 } from "./core_utils.js"; import { log2, readInt8, readUint16, readUint32 } from "./core_utils.js";
@ -25,7 +24,7 @@ class Jbig2Error extends BaseException {
} }
} }
var Jbig2Image = (function Jbig2ImageClosure() { const Jbig2Image = (function Jbig2ImageClosure() {
// Utility data structures // Utility data structures
function ContextCache() {} function ContextCache() {}
@ -46,11 +45,11 @@ var Jbig2Image = (function Jbig2ImageClosure() {
DecodingContext.prototype = { DecodingContext.prototype = {
get decoder() { get decoder() {
var decoder = new ArithmeticDecoder(this.data, this.start, this.end); const decoder = new ArithmeticDecoder(this.data, this.start, this.end);
return shadow(this, "decoder", decoder); return shadow(this, "decoder", decoder);
}, },
get contextCache() { get contextCache() {
var cache = new ContextCache(); const cache = new ContextCache();
return shadow(this, "contextCache", cache); return shadow(this, "contextCache", cache);
}, },
}; };
@ -58,13 +57,13 @@ var Jbig2Image = (function Jbig2ImageClosure() {
// Annex A. Arithmetic Integer Decoding Procedure // Annex A. Arithmetic Integer Decoding Procedure
// A.2 Procedure for decoding values // A.2 Procedure for decoding values
function decodeInteger(contextCache, procedure, decoder) { function decodeInteger(contextCache, procedure, decoder) {
var contexts = contextCache.getContexts(procedure); const contexts = contextCache.getContexts(procedure);
var prev = 1; let prev = 1;
function readBits(length) { function readBits(length) {
var v = 0; let v = 0;
for (var i = 0; i < length; i++) { for (let i = 0; i < length; i++) {
var bit = decoder.readBit(contexts, prev); const bit = decoder.readBit(contexts, prev);
prev = prev =
prev < 256 ? (prev << 1) | bit : (((prev << 1) | bit) & 511) | 256; prev < 256 ? (prev << 1) | bit : (((prev << 1) | bit) & 511) | 256;
v = (v << 1) | bit; v = (v << 1) | bit;
@ -72,10 +71,10 @@ var Jbig2Image = (function Jbig2ImageClosure() {
return v >>> 0; return v >>> 0;
} }
var sign = readBits(1); const sign = readBits(1);
// prettier-ignore // prettier-ignore
/* eslint-disable no-nested-ternary */ /* eslint-disable no-nested-ternary */
var value = readBits(1) ? const value = readBits(1) ?
(readBits(1) ? (readBits(1) ?
(readBits(1) ? (readBits(1) ?
(readBits(1) ? (readBits(1) ?
@ -97,11 +96,11 @@ var Jbig2Image = (function Jbig2ImageClosure() {
// A.3 The IAID decoding procedure // A.3 The IAID decoding procedure
function decodeIAID(contextCache, decoder, codeLength) { function decodeIAID(contextCache, decoder, codeLength) {
var contexts = contextCache.getContexts("IAID"); const contexts = contextCache.getContexts("IAID");
var prev = 1; let prev = 1;
for (var i = 0; i < codeLength; i++) { for (let i = 0; i < codeLength; i++) {
var bit = decoder.readBit(contexts, prev); const bit = decoder.readBit(contexts, prev);
prev = (prev << 1) | bit; prev = (prev << 1) | bit;
} }
if (codeLength < 31) { if (codeLength < 31) {
@ -111,7 +110,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
// 7.3 Segment types // 7.3 Segment types
var SegmentTypes = [ const SegmentTypes = [
"SymbolDictionary", "SymbolDictionary",
null, null,
null, null,
@ -177,7 +176,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
"Extension", "Extension",
]; ];
var CodingTemplates = [ const CodingTemplates = [
[ [
{ x: -1, y: -2 }, { x: -1, y: -2 },
{ x: 0, y: -2 }, { x: 0, y: -2 },
@ -230,7 +229,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
], ],
]; ];
var RefinementTemplates = [ const RefinementTemplates = [
{ {
coding: [ coding: [
{ x: 0, y: -1 }, { x: 0, y: -1 },
@ -267,22 +266,22 @@ var Jbig2Image = (function Jbig2ImageClosure() {
]; ];
// See 6.2.5.7 Decoding the bitmap. // See 6.2.5.7 Decoding the bitmap.
var ReusedContexts = [ const ReusedContexts = [
0x9b25, // 10011 0110010 0101 0x9b25, // 10011 0110010 0101
0x0795, // 0011 110010 101 0x0795, // 0011 110010 101
0x00e5, // 001 11001 01 0x00e5, // 001 11001 01
0x0195, // 011001 0101 0x0195, // 011001 0101
]; ];
var RefinementReusedContexts = [ const RefinementReusedContexts = [
0x0020, // '000' + '0' (coding) + '00010000' + '0' (reference) 0x0020, // '000' + '0' (coding) + '00010000' + '0' (reference)
0x0008, // '0000' + '001000' 0x0008, // '0000' + '001000'
]; ];
function decodeBitmapTemplate0(width, height, decodingContext) { function decodeBitmapTemplate0(width, height, decodingContext) {
var decoder = decodingContext.decoder; const decoder = decodingContext.decoder;
var contexts = decodingContext.contextCache.getContexts("GB"); const contexts = decodingContext.contextCache.getContexts("GB");
var contextLabel, let contextLabel,
i, i,
j, j,
pixel, pixel,
@ -294,7 +293,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
// ...ooooo.... // ...ooooo....
// ..ooooooo... Context template for current pixel (X) // ..ooooooo... Context template for current pixel (X)
// .ooooX...... (concatenate values of 'o'-pixels to get contextLabel) // .ooooX...... (concatenate values of 'o'-pixels to get contextLabel)
var OLD_PIXEL_MASK = 0x7bf7; // 01111 0111111 0111 const OLD_PIXEL_MASK = 0x7bf7; // 01111 0111111 0111
for (i = 0; i < height; i++) { for (i = 0; i < height; i++) {
row = bitmap[i] = new Uint8Array(width); row = bitmap[i] = new Uint8Array(width);
@ -366,8 +365,8 @@ var Jbig2Image = (function Jbig2ImageClosure() {
return decodeBitmapTemplate0(width, height, decodingContext); return decodeBitmapTemplate0(width, height, decodingContext);
} }
var useskip = !!skip; const useskip = !!skip;
var template = CodingTemplates[templateIndex].concat(at); const template = CodingTemplates[templateIndex].concat(at);
// Sorting is non-standard, and it is not required. But sorting increases // Sorting is non-standard, and it is not required. But sorting increases
// the number of template bits that can be reused from the previous // the number of template bits that can be reused from the previous
@ -376,15 +375,15 @@ var Jbig2Image = (function Jbig2ImageClosure() {
return a.y - b.y || a.x - b.x; return a.y - b.y || a.x - b.x;
}); });
var templateLength = template.length; const templateLength = template.length;
var templateX = new Int8Array(templateLength); const templateX = new Int8Array(templateLength);
var templateY = new Int8Array(templateLength); const templateY = new Int8Array(templateLength);
var changingTemplateEntries = []; const changingTemplateEntries = [];
var reuseMask = 0, let reuseMask = 0,
minX = 0, minX = 0,
maxX = 0, maxX = 0,
minY = 0; minY = 0;
var c, k; let c, k;
for (k = 0; k < templateLength; k++) { for (k = 0; k < templateLength; k++) {
templateX[k] = template[k].x; templateX[k] = template[k].x;
@ -405,11 +404,11 @@ var Jbig2Image = (function Jbig2ImageClosure() {
changingTemplateEntries.push(k); changingTemplateEntries.push(k);
} }
} }
var changingEntriesLength = changingTemplateEntries.length; const changingEntriesLength = changingTemplateEntries.length;
var changingTemplateX = new Int8Array(changingEntriesLength); const changingTemplateX = new Int8Array(changingEntriesLength);
var changingTemplateY = new Int8Array(changingEntriesLength); const changingTemplateY = new Int8Array(changingEntriesLength);
var changingTemplateBit = new Uint16Array(changingEntriesLength); const changingTemplateBit = new Uint16Array(changingEntriesLength);
for (c = 0; c < changingEntriesLength; c++) { for (c = 0; c < changingEntriesLength; c++) {
k = changingTemplateEntries[c]; k = changingTemplateEntries[c];
changingTemplateX[c] = template[k].x; changingTemplateX[c] = template[k].x;
@ -418,27 +417,27 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
// Get the safe bounding box edges from the width, height, minX, maxX, minY // Get the safe bounding box edges from the width, height, minX, maxX, minY
var sbb_left = -minX; const sbb_left = -minX;
var sbb_top = -minY; const sbb_top = -minY;
var sbb_right = width - maxX; const sbb_right = width - maxX;
var pseudoPixelContext = ReusedContexts[templateIndex]; const pseudoPixelContext = ReusedContexts[templateIndex];
var row = new Uint8Array(width); let row = new Uint8Array(width);
var bitmap = []; const bitmap = [];
var decoder = decodingContext.decoder; const decoder = decodingContext.decoder;
var contexts = decodingContext.contextCache.getContexts("GB"); const contexts = decodingContext.contextCache.getContexts("GB");
var ltp = 0, let ltp = 0,
j, j,
i0, i0,
j0, j0,
contextLabel = 0, contextLabel = 0,
bit, bit,
shift; shift;
for (var i = 0; i < height; i++) { for (let i = 0; i < height; i++) {
if (prediction) { if (prediction) {
var sltp = decoder.readBit(contexts, pseudoPixelContext); const sltp = decoder.readBit(contexts, pseudoPixelContext);
ltp ^= sltp; ltp ^= sltp;
if (ltp) { if (ltp) {
bitmap.push(row); // duplicate previous row bitmap.push(row); // duplicate previous row
@ -484,7 +483,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
} }
} }
var pixel = decoder.readBit(contexts, contextLabel); const pixel = decoder.readBit(contexts, contextLabel);
row[j] = pixel; row[j] = pixel;
} }
} }
@ -503,53 +502,53 @@ var Jbig2Image = (function Jbig2ImageClosure() {
at, at,
decodingContext decodingContext
) { ) {
var codingTemplate = RefinementTemplates[templateIndex].coding; let codingTemplate = RefinementTemplates[templateIndex].coding;
if (templateIndex === 0) { if (templateIndex === 0) {
codingTemplate = codingTemplate.concat([at[0]]); codingTemplate = codingTemplate.concat([at[0]]);
} }
var codingTemplateLength = codingTemplate.length; const codingTemplateLength = codingTemplate.length;
var codingTemplateX = new Int32Array(codingTemplateLength); const codingTemplateX = new Int32Array(codingTemplateLength);
var codingTemplateY = new Int32Array(codingTemplateLength); const codingTemplateY = new Int32Array(codingTemplateLength);
var k; let k;
for (k = 0; k < codingTemplateLength; k++) { for (k = 0; k < codingTemplateLength; k++) {
codingTemplateX[k] = codingTemplate[k].x; codingTemplateX[k] = codingTemplate[k].x;
codingTemplateY[k] = codingTemplate[k].y; codingTemplateY[k] = codingTemplate[k].y;
} }
var referenceTemplate = RefinementTemplates[templateIndex].reference; let referenceTemplate = RefinementTemplates[templateIndex].reference;
if (templateIndex === 0) { if (templateIndex === 0) {
referenceTemplate = referenceTemplate.concat([at[1]]); referenceTemplate = referenceTemplate.concat([at[1]]);
} }
var referenceTemplateLength = referenceTemplate.length; const referenceTemplateLength = referenceTemplate.length;
var referenceTemplateX = new Int32Array(referenceTemplateLength); const referenceTemplateX = new Int32Array(referenceTemplateLength);
var referenceTemplateY = new Int32Array(referenceTemplateLength); const referenceTemplateY = new Int32Array(referenceTemplateLength);
for (k = 0; k < referenceTemplateLength; k++) { for (k = 0; k < referenceTemplateLength; k++) {
referenceTemplateX[k] = referenceTemplate[k].x; referenceTemplateX[k] = referenceTemplate[k].x;
referenceTemplateY[k] = referenceTemplate[k].y; referenceTemplateY[k] = referenceTemplate[k].y;
} }
var referenceWidth = referenceBitmap[0].length; const referenceWidth = referenceBitmap[0].length;
var referenceHeight = referenceBitmap.length; const referenceHeight = referenceBitmap.length;
var pseudoPixelContext = RefinementReusedContexts[templateIndex]; const pseudoPixelContext = RefinementReusedContexts[templateIndex];
var bitmap = []; const bitmap = [];
var decoder = decodingContext.decoder; const decoder = decodingContext.decoder;
var contexts = decodingContext.contextCache.getContexts("GR"); const contexts = decodingContext.contextCache.getContexts("GR");
var ltp = 0; let ltp = 0;
for (var i = 0; i < height; i++) { for (let i = 0; i < height; i++) {
if (prediction) { if (prediction) {
var sltp = decoder.readBit(contexts, pseudoPixelContext); const sltp = decoder.readBit(contexts, pseudoPixelContext);
ltp ^= sltp; ltp ^= sltp;
if (ltp) { if (ltp) {
throw new Jbig2Error("prediction is not supported"); throw new Jbig2Error("prediction is not supported");
} }
} }
var row = new Uint8Array(width); const row = new Uint8Array(width);
bitmap.push(row); bitmap.push(row);
for (var j = 0; j < width; j++) { for (let j = 0; j < width; j++) {
var i0, j0; var i0, j0;
var contextLabel = 0; let contextLabel = 0;
for (k = 0; k < codingTemplateLength; k++) { for (k = 0; k < codingTemplateLength; k++) {
i0 = i + codingTemplateY[k]; i0 = i + codingTemplateY[k];
j0 = j + codingTemplateX[k]; j0 = j + codingTemplateX[k];
@ -573,7 +572,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
contextLabel = (contextLabel << 1) | referenceBitmap[i0][j0]; contextLabel = (contextLabel << 1) | referenceBitmap[i0][j0];
} }
} }
var pixel = decoder.readBit(contexts, contextLabel); const pixel = decoder.readBit(contexts, contextLabel);
row[j] = pixel; row[j] = pixel;
} }
} }
@ -600,12 +599,12 @@ var Jbig2Image = (function Jbig2ImageClosure() {
throw new Jbig2Error("symbol refinement with Huffman is not supported"); throw new Jbig2Error("symbol refinement with Huffman is not supported");
} }
var newSymbols = []; const newSymbols = [];
var currentHeight = 0; let currentHeight = 0;
var symbolCodeLength = log2(symbols.length + numberOfNewSymbols); let symbolCodeLength = log2(symbols.length + numberOfNewSymbols);
var decoder = decodingContext.decoder; const decoder = decodingContext.decoder;
var contextCache = decodingContext.contextCache; const contextCache = decodingContext.contextCache;
let tableB1, symbolWidths; let tableB1, symbolWidths;
if (huffman) { if (huffman) {
tableB1 = getStandardTable(1); // standard table B.1 tableB1 = getStandardTable(1); // standard table B.1
@ -614,7 +613,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
while (newSymbols.length < numberOfNewSymbols) { while (newSymbols.length < numberOfNewSymbols) {
var deltaHeight = huffman const deltaHeight = huffman
? huffmanTables.tableDeltaHeight.decode(huffmanInput) ? huffmanTables.tableDeltaHeight.decode(huffmanInput)
: decodeInteger(contextCache, "IADH", decoder); // 6.5.6 : decodeInteger(contextCache, "IADH", decoder); // 6.5.6
currentHeight += deltaHeight; currentHeight += deltaHeight;
@ -622,7 +621,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
totalWidth = 0; totalWidth = 0;
const firstSymbol = huffman ? symbolWidths.length : 0; const firstSymbol = huffman ? symbolWidths.length : 0;
while (true) { while (true) {
var deltaWidth = huffman const deltaWidth = huffman
? huffmanTables.tableDeltaWidth.decode(huffmanInput) ? huffmanTables.tableDeltaWidth.decode(huffmanInput)
: decodeInteger(contextCache, "IADW", decoder); // 6.5.7 : decodeInteger(contextCache, "IADW", decoder); // 6.5.7
if (deltaWidth === null) { if (deltaWidth === null) {
@ -633,7 +632,11 @@ var Jbig2Image = (function Jbig2ImageClosure() {
var bitmap; var bitmap;
if (refinement) { if (refinement) {
// 6.5.8.2 Refinement/aggregate-coded symbol bitmap // 6.5.8.2 Refinement/aggregate-coded symbol bitmap
var numberOfInstances = decodeInteger(contextCache, "IAAI", decoder); const numberOfInstances = decodeInteger(
contextCache,
"IAAI",
decoder
);
if (numberOfInstances > 1) { if (numberOfInstances > 1) {
bitmap = decodeTextRegion( bitmap = decodeTextRegion(
huffman, huffman,
@ -657,10 +660,14 @@ var Jbig2Image = (function Jbig2ImageClosure() {
huffmanInput huffmanInput
); );
} else { } else {
var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength); const symbolId = decodeIAID(
var rdx = decodeInteger(contextCache, "IARDX", decoder); // 6.4.11.3 contextCache,
var rdy = decodeInteger(contextCache, "IARDY", decoder); // 6.4.11.4 decoder,
var symbol = symbolCodeLength
);
const rdx = decodeInteger(contextCache, "IARDX", decoder); // 6.4.11.3
const rdy = decodeInteger(contextCache, "IARDY", decoder); // 6.4.11.4
const symbol =
symbolId < symbols.length symbolId < symbols.length
? symbols[symbolId] ? symbols[symbolId]
: newSymbols[symbolId - symbols.length]; : newSymbols[symbolId - symbols.length];
@ -749,12 +756,12 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
// 6.5.10 Exported symbols // 6.5.10 Exported symbols
var exportedSymbols = []; const exportedSymbols = [];
var flags = [], let flags = [],
currentFlag = false; currentFlag = false;
var totalSymbolsLength = symbols.length + numberOfNewSymbols; const totalSymbolsLength = symbols.length + numberOfNewSymbols;
while (flags.length < totalSymbolsLength) { while (flags.length < totalSymbolsLength) {
var runLength = huffman let runLength = huffman
? tableB1.decode(huffmanInput) ? tableB1.decode(huffmanInput)
: decodeInteger(contextCache, "IAEX", decoder); : decodeInteger(contextCache, "IAEX", decoder);
while (runLength--) { while (runLength--) {
@ -767,7 +774,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
exportedSymbols.push(symbols[i]); exportedSymbols.push(symbols[i]);
} }
} }
for (var j = 0; j < numberOfNewSymbols; i++, j++) { for (let j = 0; j < numberOfNewSymbols; i++, j++) {
if (flags[i]) { if (flags[i]) {
exportedSymbols.push(newSymbols[j]); exportedSymbols.push(newSymbols[j]);
} }
@ -801,37 +808,37 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
// Prepare bitmap // Prepare bitmap
var bitmap = []; const bitmap = [];
var i, row; let i, row;
for (i = 0; i < height; i++) { for (i = 0; i < height; i++) {
row = new Uint8Array(width); row = new Uint8Array(width);
if (defaultPixelValue) { if (defaultPixelValue) {
for (var j = 0; j < width; j++) { for (let j = 0; j < width; j++) {
row[j] = defaultPixelValue; row[j] = defaultPixelValue;
} }
} }
bitmap.push(row); bitmap.push(row);
} }
var decoder = decodingContext.decoder; const decoder = decodingContext.decoder;
var contextCache = decodingContext.contextCache; const contextCache = decodingContext.contextCache;
var stripT = huffman let stripT = huffman
? -huffmanTables.tableDeltaT.decode(huffmanInput) ? -huffmanTables.tableDeltaT.decode(huffmanInput)
: -decodeInteger(contextCache, "IADT", decoder); // 6.4.6 : -decodeInteger(contextCache, "IADT", decoder); // 6.4.6
var firstS = 0; let firstS = 0;
i = 0; i = 0;
while (i < numberOfSymbolInstances) { while (i < numberOfSymbolInstances) {
var deltaT = huffman const deltaT = huffman
? huffmanTables.tableDeltaT.decode(huffmanInput) ? huffmanTables.tableDeltaT.decode(huffmanInput)
: decodeInteger(contextCache, "IADT", decoder); // 6.4.6 : decodeInteger(contextCache, "IADT", decoder); // 6.4.6
stripT += deltaT; stripT += deltaT;
var deltaFirstS = huffman const deltaFirstS = huffman
? huffmanTables.tableFirstS.decode(huffmanInput) ? huffmanTables.tableFirstS.decode(huffmanInput)
: decodeInteger(contextCache, "IAFS", decoder); // 6.4.7 : decodeInteger(contextCache, "IAFS", decoder); // 6.4.7
firstS += deltaFirstS; firstS += deltaFirstS;
var currentS = firstS; let currentS = firstS;
do { do {
let currentT = 0; // 6.4.9 let currentT = 0; // 6.4.9
if (stripSize > 1) { if (stripSize > 1) {
@ -839,23 +846,23 @@ var Jbig2Image = (function Jbig2ImageClosure() {
? huffmanInput.readBits(logStripSize) ? huffmanInput.readBits(logStripSize)
: decodeInteger(contextCache, "IAIT", decoder); : decodeInteger(contextCache, "IAIT", decoder);
} }
var t = stripSize * stripT + currentT; const t = stripSize * stripT + currentT;
var symbolId = huffman const symbolId = huffman
? huffmanTables.symbolIDTable.decode(huffmanInput) ? huffmanTables.symbolIDTable.decode(huffmanInput)
: decodeIAID(contextCache, decoder, symbolCodeLength); : decodeIAID(contextCache, decoder, symbolCodeLength);
var applyRefinement = const applyRefinement =
refinement && refinement &&
(huffman (huffman
? huffmanInput.readBit() ? huffmanInput.readBit()
: decodeInteger(contextCache, "IARI", decoder)); : decodeInteger(contextCache, "IARI", decoder));
var symbolBitmap = inputSymbols[symbolId]; let symbolBitmap = inputSymbols[symbolId];
var symbolWidth = symbolBitmap[0].length; let symbolWidth = symbolBitmap[0].length;
var symbolHeight = symbolBitmap.length; let symbolHeight = symbolBitmap.length;
if (applyRefinement) { if (applyRefinement) {
var rdw = decodeInteger(contextCache, "IARDW", decoder); // 6.4.11.1 const rdw = decodeInteger(contextCache, "IARDW", decoder); // 6.4.11.1
var rdh = decodeInteger(contextCache, "IARDH", decoder); // 6.4.11.2 const rdh = decodeInteger(contextCache, "IARDH", decoder); // 6.4.11.2
var rdx = decodeInteger(contextCache, "IARDX", decoder); // 6.4.11.3 const rdx = decodeInteger(contextCache, "IARDX", decoder); // 6.4.11.3
var rdy = decodeInteger(contextCache, "IARDY", decoder); // 6.4.11.4 const rdy = decodeInteger(contextCache, "IARDY", decoder); // 6.4.11.4
symbolWidth += rdw; symbolWidth += rdw;
symbolHeight += rdh; symbolHeight += rdh;
symbolBitmap = decodeRefinement( symbolBitmap = decodeRefinement(
@ -870,8 +877,8 @@ var Jbig2Image = (function Jbig2ImageClosure() {
decodingContext decodingContext
); );
} }
var offsetT = t - (referenceCorner & 1 ? 0 : symbolHeight - 1); const offsetT = t - (referenceCorner & 1 ? 0 : symbolHeight - 1);
var offsetS = currentS - (referenceCorner & 2 ? symbolWidth - 1 : 0); const offsetS = currentS - (referenceCorner & 2 ? symbolWidth - 1 : 0);
var s2, t2, symbolRow; var s2, t2, symbolRow;
if (transposed) { if (transposed) {
// Place Symbol Bitmap from T1,S1 // Place Symbol Bitmap from T1,S1
@ -883,7 +890,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
symbolRow = symbolBitmap[s2]; symbolRow = symbolBitmap[s2];
// To ignore Parts of Symbol bitmap which goes // To ignore Parts of Symbol bitmap which goes
// outside bitmap region // outside bitmap region
var maxWidth = Math.min(width - offsetT, symbolWidth); const maxWidth = Math.min(width - offsetT, symbolWidth);
switch (combinationOperator) { switch (combinationOperator) {
case 0: // OR case 0: // OR
for (t2 = 0; t2 < maxWidth; t2++) { for (t2 = 0; t2 < maxWidth; t2++) {
@ -929,7 +936,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
currentS += symbolWidth - 1; currentS += symbolWidth - 1;
} }
i++; i++;
var deltaS = huffman const deltaS = huffman
? huffmanTables.tableDeltaS.decode(huffmanInput) ? huffmanTables.tableDeltaS.decode(huffmanInput)
: decodeInteger(contextCache, "IADS", decoder); // 6.4.8 : decodeInteger(contextCache, "IADS", decoder); // 6.4.8
if (deltaS === null) { if (deltaS === null) {
@ -1142,10 +1149,10 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
function readSegmentHeader(data, start) { function readSegmentHeader(data, start) {
var segmentHeader = {}; const segmentHeader = {};
segmentHeader.number = readUint32(data, start); segmentHeader.number = readUint32(data, start);
var flags = data[start + 4]; const flags = data[start + 4];
var segmentType = flags & 0x3f; const segmentType = flags & 0x3f;
if (!SegmentTypes[segmentType]) { if (!SegmentTypes[segmentType]) {
throw new Jbig2Error("invalid segment type: " + segmentType); throw new Jbig2Error("invalid segment type: " + segmentType);
} }
@ -1153,15 +1160,15 @@ var Jbig2Image = (function Jbig2ImageClosure() {
segmentHeader.typeName = SegmentTypes[segmentType]; segmentHeader.typeName = SegmentTypes[segmentType];
segmentHeader.deferredNonRetain = !!(flags & 0x80); segmentHeader.deferredNonRetain = !!(flags & 0x80);
var pageAssociationFieldSize = !!(flags & 0x40); const pageAssociationFieldSize = !!(flags & 0x40);
var referredFlags = data[start + 5]; const referredFlags = data[start + 5];
var referredToCount = (referredFlags >> 5) & 7; let referredToCount = (referredFlags >> 5) & 7;
var retainBits = [referredFlags & 31]; const retainBits = [referredFlags & 31];
var position = start + 6; let position = start + 6;
if (referredFlags === 7) { if (referredFlags === 7) {
referredToCount = readUint32(data, position - 1) & 0x1fffffff; referredToCount = readUint32(data, position - 1) & 0x1fffffff;
position += 3; position += 3;
var bytes = (referredToCount + 7) >> 3; let bytes = (referredToCount + 7) >> 3;
retainBits[0] = data[position++]; retainBits[0] = data[position++];
while (--bytes > 0) { while (--bytes > 0) {
retainBits.push(data[position++]); retainBits.push(data[position++]);
@ -1178,8 +1185,8 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} else if (segmentHeader.number <= 65536) { } else if (segmentHeader.number <= 65536) {
referredToSegmentNumberSize = 2; referredToSegmentNumberSize = 2;
} }
var referredTo = []; const referredTo = [];
var i, ii; let i, ii;
for (i = 0; i < referredToCount; i++) { for (i = 0; i < referredToCount; i++) {
let number; let number;
if (referredToSegmentNumberSize === 1) { if (referredToSegmentNumberSize === 1) {
@ -1206,13 +1213,13 @@ var Jbig2Image = (function Jbig2ImageClosure() {
// 7.2.7 Segment data length, unknown segment length // 7.2.7 Segment data length, unknown segment length
if (segmentType === 38) { if (segmentType === 38) {
// ImmediateGenericRegion // ImmediateGenericRegion
var genericRegionInfo = readRegionSegmentInformation(data, position); const genericRegionInfo = readRegionSegmentInformation(data, position);
var genericRegionSegmentFlags = const genericRegionSegmentFlags =
data[position + RegionSegmentInformationFieldLength]; data[position + RegionSegmentInformationFieldLength];
var genericRegionMmr = !!(genericRegionSegmentFlags & 1); const genericRegionMmr = !!(genericRegionSegmentFlags & 1);
// searching for the segment end // searching for the segment end
var searchPatternLength = 6; const searchPatternLength = 6;
var searchPattern = new Uint8Array(searchPatternLength); const searchPattern = new Uint8Array(searchPatternLength);
if (!genericRegionMmr) { if (!genericRegionMmr) {
searchPattern[0] = 0xff; searchPattern[0] = 0xff;
searchPattern[1] = 0xac; searchPattern[1] = 0xac;
@ -1222,7 +1229,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
searchPattern[4] = (genericRegionInfo.height >> 8) & 0xff; searchPattern[4] = (genericRegionInfo.height >> 8) & 0xff;
searchPattern[5] = genericRegionInfo.height & 0xff; searchPattern[5] = genericRegionInfo.height & 0xff;
for (i = position, ii = data.length; i < ii; i++) { for (i = position, ii = data.length; i < ii; i++) {
var j = 0; let j = 0;
while (j < searchPatternLength && searchPattern[j] === data[i + j]) { while (j < searchPatternLength && searchPattern[j] === data[i + j]) {
j++; j++;
} }
@ -1243,12 +1250,12 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
function readSegments(header, data, start, end) { function readSegments(header, data, start, end) {
var segments = []; const segments = [];
var position = start; let position = start;
while (position < end) { while (position < end) {
var segmentHeader = readSegmentHeader(data, position); const segmentHeader = readSegmentHeader(data, position);
position = segmentHeader.headerEnd; position = segmentHeader.headerEnd;
var segment = { const segment = {
header: segmentHeader, header: segmentHeader,
data, data,
}; };
@ -1263,7 +1270,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
} }
if (header.randomAccess) { if (header.randomAccess) {
for (var i = 0, ii = segments.length; i < ii; i++) { for (let i = 0, ii = segments.length; i < ii; i++) {
segments[i].start = position; segments[i].start = position;
position += segments[i].header.length; position += segments[i].header.length;
segments[i].end = position; segments[i].end = position;
@ -1285,12 +1292,12 @@ var Jbig2Image = (function Jbig2ImageClosure() {
var RegionSegmentInformationFieldLength = 17; var RegionSegmentInformationFieldLength = 17;
function processSegment(segment, visitor) { function processSegment(segment, visitor) {
var header = segment.header; const header = segment.header;
var data = segment.data, let data = segment.data,
position = segment.start, position = segment.start,
end = segment.end; end = segment.end;
var args, at, i, atLength; let args, at, i, atLength;
switch (header.type) { switch (header.type) {
case 0: // SymbolDictionary case 0: // SymbolDictionary
// 7.4.2 Symbol dictionary segment syntax // 7.4.2 Symbol dictionary segment syntax
@ -1361,7 +1368,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
textRegion.dsOffset = (textRegionSegmentFlags << 17) >> 27; textRegion.dsOffset = (textRegionSegmentFlags << 17) >> 27;
textRegion.refinementTemplate = (textRegionSegmentFlags >> 15) & 1; textRegion.refinementTemplate = (textRegionSegmentFlags >> 15) & 1;
if (textRegion.huffman) { if (textRegion.huffman) {
var textRegionHuffmanFlags = readUint16(data, position); const textRegionHuffmanFlags = readUint16(data, position);
position += 2; position += 2;
textRegion.huffmanFS = textRegionHuffmanFlags & 3; textRegion.huffmanFS = textRegionHuffmanFlags & 3;
textRegion.huffmanDS = (textRegionHuffmanFlags >> 2) & 3; textRegion.huffmanDS = (textRegionHuffmanFlags >> 2) & 3;
@ -1488,23 +1495,23 @@ var Jbig2Image = (function Jbig2ImageClosure() {
" is not implemented" " is not implemented"
); );
} }
var callbackName = "on" + header.typeName; const callbackName = "on" + header.typeName;
if (callbackName in visitor) { if (callbackName in visitor) {
visitor[callbackName].apply(visitor, args); visitor[callbackName].apply(visitor, args);
} }
} }
function processSegments(segments, visitor) { function processSegments(segments, visitor) {
for (var i = 0, ii = segments.length; i < ii; i++) { for (let i = 0, ii = segments.length; i < ii; i++) {
processSegment(segments[i], visitor); processSegment(segments[i], visitor);
} }
} }
function parseJbig2Chunks(chunks) { function parseJbig2Chunks(chunks) {
var visitor = new SimpleSegmentVisitor(); const visitor = new SimpleSegmentVisitor();
for (var i = 0, ii = chunks.length; i < ii; i++) { for (let i = 0, ii = chunks.length; i < ii; i++) {
var chunk = chunks[i]; const chunk = chunks[i];
var segments = readSegments({}, chunk.data, chunk.start, chunk.end); const segments = readSegments({}, chunk.data, chunk.start, chunk.end);
processSegments(segments, visitor); processSegments(segments, visitor);
} }
return visitor.buffer; return visitor.buffer;
@ -1566,29 +1573,29 @@ var Jbig2Image = (function Jbig2ImageClosure() {
SimpleSegmentVisitor.prototype = { SimpleSegmentVisitor.prototype = {
onPageInformation: function SimpleSegmentVisitor_onPageInformation(info) { onPageInformation: function SimpleSegmentVisitor_onPageInformation(info) {
this.currentPageInfo = info; this.currentPageInfo = info;
var rowSize = (info.width + 7) >> 3; const rowSize = (info.width + 7) >> 3;
var buffer = new Uint8ClampedArray(rowSize * info.height); const buffer = new Uint8ClampedArray(rowSize * info.height);
// The contents of ArrayBuffers are initialized to 0. // The contents of ArrayBuffers are initialized to 0.
// Fill the buffer with 0xFF only if info.defaultPixelValue is set // Fill the buffer with 0xFF only if info.defaultPixelValue is set
if (info.defaultPixelValue) { if (info.defaultPixelValue) {
for (var i = 0, ii = buffer.length; i < ii; i++) { for (let i = 0, ii = buffer.length; i < ii; i++) {
buffer[i] = 0xff; buffer[i] = 0xff;
} }
} }
this.buffer = buffer; this.buffer = buffer;
}, },
drawBitmap: function SimpleSegmentVisitor_drawBitmap(regionInfo, bitmap) { drawBitmap: function SimpleSegmentVisitor_drawBitmap(regionInfo, bitmap) {
var pageInfo = this.currentPageInfo; const pageInfo = this.currentPageInfo;
var width = regionInfo.width, const width = regionInfo.width,
height = regionInfo.height; height = regionInfo.height;
var rowSize = (pageInfo.width + 7) >> 3; const rowSize = (pageInfo.width + 7) >> 3;
var combinationOperator = pageInfo.combinationOperatorOverride const combinationOperator = pageInfo.combinationOperatorOverride
? regionInfo.combinationOperator ? regionInfo.combinationOperator
: pageInfo.combinationOperator; : pageInfo.combinationOperator;
var buffer = this.buffer; const buffer = this.buffer;
var mask0 = 128 >> (regionInfo.x & 7); const mask0 = 128 >> (regionInfo.x & 7);
var offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3); let offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3);
var i, j, mask, offset; let i, j, mask, offset;
switch (combinationOperator) { switch (combinationOperator) {
case 0: // OR case 0: // OR
for (i = 0; i < height; i++) { for (i = 0; i < height; i++) {
@ -1636,9 +1643,9 @@ var Jbig2Image = (function Jbig2ImageClosure() {
start, start,
end end
) { ) {
var regionInfo = region.info; const regionInfo = region.info;
var decodingContext = new DecodingContext(data, start, end); const decodingContext = new DecodingContext(data, start, end);
var bitmap = decodeBitmap( const bitmap = decodeBitmap(
region.mmr, region.mmr,
regionInfo.width, regionInfo.width,
regionInfo.height, regionInfo.height,
@ -1672,13 +1679,13 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
// Combines exported symbols from all referred segments // Combines exported symbols from all referred segments
var symbols = this.symbols; let symbols = this.symbols;
if (!symbols) { if (!symbols) {
this.symbols = symbols = {}; this.symbols = symbols = {};
} }
var inputSymbols = []; let inputSymbols = [];
for (var i = 0, ii = referredSegments.length; i < ii; i++) { for (let i = 0, ii = referredSegments.length; i < ii; i++) {
const referredSymbols = symbols[referredSegments[i]]; const referredSymbols = symbols[referredSegments[i]];
// referredSymbols is undefined when we have a reference to a Tables // referredSymbols is undefined when we have a reference to a Tables
// segment instead of a SymbolDictionary. // segment instead of a SymbolDictionary.
@ -1687,7 +1694,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
} }
} }
var decodingContext = new DecodingContext(data, start, end); const decodingContext = new DecodingContext(data, start, end);
symbols[currentSegment] = decodeSymbolDictionary( symbols[currentSegment] = decodeSymbolDictionary(
dictionary.huffman, dictionary.huffman,
dictionary.refinement, dictionary.refinement,
@ -1710,13 +1717,13 @@ var Jbig2Image = (function Jbig2ImageClosure() {
start, start,
end end
) { ) {
var regionInfo = region.info; const regionInfo = region.info;
let huffmanTables, huffmanInput; let huffmanTables, huffmanInput;
// Combines exported symbols from all referred segments // Combines exported symbols from all referred segments
var symbols = this.symbols; const symbols = this.symbols;
var inputSymbols = []; let inputSymbols = [];
for (var i = 0, ii = referredSegments.length; i < ii; i++) { for (let i = 0, ii = referredSegments.length; i < ii; i++) {
const referredSymbols = symbols[referredSegments[i]]; const referredSymbols = symbols[referredSegments[i]];
// referredSymbols is undefined when we have a reference to a Tables // referredSymbols is undefined when we have a reference to a Tables
// segment instead of a SymbolDictionary. // segment instead of a SymbolDictionary.
@ -1724,7 +1731,7 @@ var Jbig2Image = (function Jbig2ImageClosure() {
inputSymbols = inputSymbols.concat(referredSymbols); inputSymbols = inputSymbols.concat(referredSymbols);
} }
} }
var symbolCodeLength = log2(inputSymbols.length); const symbolCodeLength = log2(inputSymbols.length);
if (region.huffman) { if (region.huffman) {
huffmanInput = new Reader(data, start, end); huffmanInput = new Reader(data, start, end);
huffmanTables = getTextRegionHuffmanTables( huffmanTables = getTextRegionHuffmanTables(
@ -1736,8 +1743,8 @@ var Jbig2Image = (function Jbig2ImageClosure() {
); );
} }
var decodingContext = new DecodingContext(data, start, end); const decodingContext = new DecodingContext(data, start, end);
var bitmap = decodeTextRegion( const bitmap = decodeTextRegion(
region.huffman, region.huffman,
region.refinement, region.refinement,
regionInfo.width, regionInfo.width,