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