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

Enable the no-var linting rule in src/core/function.js

Browse Source 
This is done automatically with `gulp lint --fix` and the following
manual changes:

```diff
diff --git a/src/core/function.js b/src/core/function.js
index 878001057..b7e3e6ccf 100644
--- a/src/core/function.js
+++ b/src/core/function.js
@@ -131,7 +131,7 @@ function toNumberArray(arr) {
   return arr;
 }

-var PDFFunction = (function PDFFunctionClosure() {
+const PDFFunction = (function PDFFunctionClosure() {
   const CONSTRUCT_SAMPLED = 0;
   const CONSTRUCT_INTERPOLATED = 2;
   const CONSTRUCT_STICHED = 3;
@@ -484,7 +484,9 @@ var PDFFunction = (function PDFFunctionClosure() {
         // clip to domain
         const v = clip(src[srcOffset], domain[0], domain[1]);
         // calculate which bound the value is in
-        for (var i = 0, ii = bounds.length; i < ii; ++i) {
+        const length = bounds.length;
+        let i;
+        for (i = 0; i < length; ++i) {
           if (v < bounds[i]) {
             break;
           }
@@ -673,23 +675,21 @@ const PostScriptStack = (function PostScriptStackClosure() {
     roll(n, p) {
       const stack = this.stack;
       const l = stack.length - n;
-      let r = stack.length - 1,
-        c = l + (p - Math.floor(p / n) * n),
-        i,
-        j,
-        t;
-      for (i = l, j = r; i < j; i++, j--) {
-        t = stack[i];
+      const r = stack.length - 1;
+      const c = l + (p - Math.floor(p / n) * n);
+
+      for (let i = l, j = r; i < j; i++, j--) {
+        const t = stack[i];
         stack[i] = stack[j];
         stack[j] = t;
       }
-      for (i = l, j = c - 1; i < j; i++, j--) {
-        t = stack[i];
+      for (let i = l, j = c - 1; i < j; i++, j--) {
+        const t = stack[i];
         stack[i] = stack[j];
         stack[j] = t;
       }
-      for (i = c, j = r; i < j; i++, j--) {
-        t = stack[i];
+      for (let i = c, j = r; i < j; i++, j--) {
+        const t = stack[i];
         stack[i] = stack[j];
         stack[j] = t;
       }
@@ -939,7 +939,7 @@ class PostScriptEvaluator {
 // We can compile most of such programs, and at the same moment, we can
 // optimize some expressions using basic math properties. Keeping track of
 // min/max values will allow us to avoid extra Math.min/Math.max calls.
-var PostScriptCompiler = (function PostScriptCompilerClosure() {
+const PostScriptCompiler = (function PostScriptCompilerClosure() {
   class AstNode {
     constructor(type) {
       this.type = type;
```
This commit is contained in:
Tim van der Meij 2021-05-01 19:56:51 +02:00
parent f6f335173d
commit 58e568fe62
No known key found for this signature in database
GPG Key ID: 8C3FD2925A5F2762
1 changed files with 145 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

291
src/core/function.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 { Dict, isDict, isStream, Ref } from "./primitives.js"; import { Dict, isDict, isStream, Ref } from "./primitives.js";
import { import {
@ -132,7 +131,7 @@ function toNumberArray(arr) {
return arr; return arr;
} }
var PDFFunction = (function PDFFunctionClosure() { const PDFFunction = (function PDFFunctionClosure() {
const CONSTRUCT_SAMPLED = 0; const CONSTRUCT_SAMPLED = 0;
const CONSTRUCT_INTERPOLATED = 2; const CONSTRUCT_INTERPOLATED = 2;
const CONSTRUCT_STICHED = 3; const CONSTRUCT_STICHED = 3;
@ -140,21 +139,21 @@ var PDFFunction = (function PDFFunctionClosure() {
return { return {
getSampleArray(size, outputSize, bps, stream) { getSampleArray(size, outputSize, bps, stream) {
var i, ii; let i, ii;
var length = 1; let length = 1;
for (i = 0, ii = size.length; i < ii; i++) { for (i = 0, ii = size.length; i < ii; i++) {
length *= size[i]; length *= size[i];
} }
length *= outputSize; length *= outputSize;
var array = new Array(length); const array = new Array(length);
var codeSize = 0; let codeSize = 0;
var codeBuf = 0; let codeBuf = 0;
// 32 is a valid bps so shifting won't work // 32 is a valid bps so shifting won't work
var sampleMul = 1.0 / (2.0 ** bps - 1); const sampleMul = 1.0 / (2.0 ** bps - 1);
var strBytes = stream.getBytes((length * bps + 7) / 8); const strBytes = stream.getBytes((length * bps + 7) / 8);
var strIdx = 0; let strIdx = 0;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
while (codeSize < bps) { while (codeSize < bps) {
codeBuf <<= 8; codeBuf <<= 8;
@ -169,12 +168,12 @@ var PDFFunction = (function PDFFunctionClosure() {
}, },
getIR({ xref, isEvalSupported, fn }) { getIR({ xref, isEvalSupported, fn }) {
var dict = fn.dict; let dict = fn.dict;
if (!dict) { if (!dict) {
dict = fn; dict = fn;
} }
var types = [ const types = [
this.constructSampled, this.constructSampled,
null, null,
this.constructInterpolated, this.constructInterpolated,
@ -182,8 +181,8 @@ var PDFFunction = (function PDFFunctionClosure() {
this.constructPostScript, this.constructPostScript,
]; ];
var typeNum = dict.get("FunctionType"); const typeNum = dict.get("FunctionType");
var typeFn = types[typeNum]; const typeFn = types[typeNum];
if (!typeFn) { if (!typeFn) {
throw new FormatError("Unknown type of function"); throw new FormatError("Unknown type of function");
} }
@ -192,7 +191,7 @@ var PDFFunction = (function PDFFunctionClosure() {
}, },
fromIR({ xref, isEvalSupported, IR }) { fromIR({ xref, isEvalSupported, IR }) {
var type = IR[0]; const type = IR[0];
switch (type) { switch (type) {
case CONSTRUCT_SAMPLED: case CONSTRUCT_SAMPLED:
return this.constructSampledFromIR({ xref, isEvalSupported, IR }); return this.constructSampledFromIR({ xref, isEvalSupported, IR });
@ -221,14 +220,14 @@ var PDFFunction = (function PDFFunctionClosure() {
return this.parse({ xref, isEvalSupported, fn: fnObj }); return this.parse({ xref, isEvalSupported, fn: fnObj });
} }
var fnArray = []; const fnArray = [];
for (var j = 0, jj = fnObj.length; j < jj; j++) { for (let j = 0, jj = fnObj.length; j < jj; j++) {
fnArray.push( fnArray.push(
this.parse({ xref, isEvalSupported, fn: xref.fetchIfRef(fnObj[j]) }) this.parse({ xref, isEvalSupported, fn: xref.fetchIfRef(fnObj[j]) })
); );
} }
return function (src, srcOffset, dest, destOffset) { return function (src, srcOffset, dest, destOffset) {
for (var i = 0, ii = fnArray.length; i < ii; i++) { for (let i = 0, ii = fnArray.length; i < ii; i++) {
fnArray[i](src, srcOffset, dest, destOffset + i); fnArray[i](src, srcOffset, dest, destOffset + i);
} }
}; };
@ -236,55 +235,55 @@ var PDFFunction = (function PDFFunctionClosure() {
constructSampled({ xref, isEvalSupported, fn, dict }) { constructSampled({ xref, isEvalSupported, fn, dict }) {
function toMultiArray(arr) { function toMultiArray(arr) {
var inputLength = arr.length; const inputLength = arr.length;
var out = []; const out = [];
var index = 0; let index = 0;
for (var i = 0; i < inputLength; i += 2) { for (let i = 0; i < inputLength; i += 2) {
out[index] = [arr[i], arr[i + 1]]; out[index] = [arr[i], arr[i + 1]];
++index; ++index;
} }
return out; return out;
} }
var domain = toNumberArray(dict.getArray("Domain")); let domain = toNumberArray(dict.getArray("Domain"));
var range = toNumberArray(dict.getArray("Range")); let range = toNumberArray(dict.getArray("Range"));
if (!domain || !range) { if (!domain || !range) {
throw new FormatError("No domain or range"); throw new FormatError("No domain or range");
} }
var inputSize = domain.length / 2; const inputSize = domain.length / 2;
var outputSize = range.length / 2; const outputSize = range.length / 2;
domain = toMultiArray(domain); domain = toMultiArray(domain);
range = toMultiArray(range); range = toMultiArray(range);
var size = toNumberArray(dict.getArray("Size")); const size = toNumberArray(dict.getArray("Size"));
var bps = dict.get("BitsPerSample"); const bps = dict.get("BitsPerSample");
var order = dict.get("Order") || 1; const order = dict.get("Order") || 1;
if (order !== 1) { if (order !== 1) {
// No description how cubic spline interpolation works in PDF32000:2008 // No description how cubic spline interpolation works in PDF32000:2008
// As in poppler, ignoring order, linear interpolation may work as good // As in poppler, ignoring order, linear interpolation may work as good
info("No support for cubic spline interpolation: " + order); info("No support for cubic spline interpolation: " + order);
} }
var encode = toNumberArray(dict.getArray("Encode")); let encode = toNumberArray(dict.getArray("Encode"));
if (!encode) { if (!encode) {
encode = []; encode = [];
for (var i = 0; i < inputSize; ++i) { for (let i = 0; i < inputSize; ++i) {
encode.push([0, size[i] - 1]); encode.push([0, size[i] - 1]);
} }
} else { } else {
encode = toMultiArray(encode); encode = toMultiArray(encode);
} }
var decode = toNumberArray(dict.getArray("Decode")); let decode = toNumberArray(dict.getArray("Decode"));
if (!decode) { if (!decode) {
decode = range; decode = range;
} else { } else {
decode = toMultiArray(decode); decode = toMultiArray(decode);
} }
var samples = this.getSampleArray(size, outputSize, bps, fn); const samples = this.getSampleArray(size, outputSize, bps, fn);
return [ return [
CONSTRUCT_SAMPLED, CONSTRUCT_SAMPLED,
@ -313,41 +312,41 @@ var PDFFunction = (function PDFFunctionClosure() {
destOffset destOffset
) { ) {
// See chapter 3, page 110 of the PDF reference. // See chapter 3, page 110 of the PDF reference.
var m = IR[1]; const m = IR[1];
var domain = IR[2]; const domain = IR[2];
var encode = IR[3]; const encode = IR[3];
var decode = IR[4]; const decode = IR[4];
var samples = IR[5]; const samples = IR[5];
var size = IR[6]; const size = IR[6];
var n = IR[7]; const n = IR[7];
// var mask = IR[8]; // var mask = IR[8];
var range = IR[9]; const range = IR[9];
// Building the cube vertices: its part and sample index // Building the cube vertices: its part and sample index
// http://rjwagner49.com/Mathematics/Interpolation.pdf // http://rjwagner49.com/Mathematics/Interpolation.pdf
var cubeVertices = 1 << m; const cubeVertices = 1 << m;
var cubeN = new Float64Array(cubeVertices); const cubeN = new Float64Array(cubeVertices);
var cubeVertex = new Uint32Array(cubeVertices); const cubeVertex = new Uint32Array(cubeVertices);
var i, j; let i, j;
for (j = 0; j < cubeVertices; j++) { for (j = 0; j < cubeVertices; j++) {
cubeN[j] = 1; cubeN[j] = 1;
} }
var k = n, let k = n,
pos = 1; pos = 1;
// Map x_i to y_j for 0 <= i < m using the sampled function. // Map x_i to y_j for 0 <= i < m using the sampled function.
for (i = 0; i < m; ++i) { for (i = 0; i < m; ++i) {
// x_i' = min(max(x_i, Domain_2i), Domain_2i+1) // x_i' = min(max(x_i, Domain_2i), Domain_2i+1)
var domain_2i = domain[i][0]; const domain_2i = domain[i][0];
var domain_2i_1 = domain[i][1]; const domain_2i_1 = domain[i][1];
var xi = Math.min( const xi = Math.min(
Math.max(src[srcOffset + i], domain_2i), Math.max(src[srcOffset + i], domain_2i),
domain_2i_1 domain_2i_1
); );
// e_i = Interpolate(x_i', Domain_2i, Domain_2i+1, // e_i = Interpolate(x_i', Domain_2i, Domain_2i+1,
// Encode_2i, Encode_2i+1) // Encode_2i, Encode_2i+1)
var e = interpolate( let e = interpolate(
xi, xi,
domain_2i, domain_2i,
domain_2i_1, domain_2i_1,
@ -356,15 +355,15 @@ var PDFFunction = (function PDFFunctionClosure() {
); );
// e_i' = min(max(e_i, 0), Size_i - 1) // e_i' = min(max(e_i, 0), Size_i - 1)
var size_i = size[i]; const size_i = size[i];
e = Math.min(Math.max(e, 0), size_i - 1); e = Math.min(Math.max(e, 0), size_i - 1);
// Adjusting the cube: N and vertex sample index // Adjusting the cube: N and vertex sample index
var e0 = e < size_i - 1 ? Math.floor(e) : e - 1; // e1 = e0 + 1; const e0 = e < size_i - 1 ? Math.floor(e) : e - 1; // e1 = e0 + 1;
var n0 = e0 + 1 - e; // (e1 - e) / (e1 - e0); const n0 = e0 + 1 - e; // (e1 - e) / (e1 - e0);
var n1 = e - e0; // (e - e0) / (e1 - e0); const n1 = e - e0; // (e - e0) / (e1 - e0);
var offset0 = e0 * k; const offset0 = e0 * k;
var offset1 = offset0 + k; // e1 * k const offset1 = offset0 + k; // e1 * k
for (j = 0; j < cubeVertices; j++) { for (j = 0; j < cubeVertices; j++) {
if (j & pos) { if (j & pos) {
cubeN[j] *= n1; cubeN[j] *= n1;
@ -381,7 +380,7 @@ var PDFFunction = (function PDFFunctionClosure() {
for (j = 0; j < n; ++j) { for (j = 0; j < n; ++j) {
// Sum all cube vertices' samples portions // Sum all cube vertices' samples portions
var rj = 0; let rj = 0;
for (i = 0; i < cubeVertices; i++) { for (i = 0; i < cubeVertices; i++) {
rj += samples[cubeVertex[i] + j] * cubeN[i]; rj += samples[cubeVertex[i] + j] * cubeN[i];
} }
@ -400,13 +399,13 @@ var PDFFunction = (function PDFFunctionClosure() {
}, },
constructInterpolated({ xref, isEvalSupported, fn, dict }) { constructInterpolated({ xref, isEvalSupported, fn, dict }) {
var c0 = toNumberArray(dict.getArray("C0")) || [0]; const c0 = toNumberArray(dict.getArray("C0")) || [0];
var c1 = toNumberArray(dict.getArray("C1")) || [1]; const c1 = toNumberArray(dict.getArray("C1")) || [1];
var n = dict.get("N"); const n = dict.get("N");
var length = c0.length; const length = c0.length;
var diff = []; const diff = [];
for (var i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
diff.push(c1[i] - c0[i]); diff.push(c1[i] - c0[i]);
} }
@ -414,11 +413,11 @@ var PDFFunction = (function PDFFunctionClosure() {
}, },
constructInterpolatedFromIR({ xref, isEvalSupported, IR }) { constructInterpolatedFromIR({ xref, isEvalSupported, IR }) {
var c0 = IR[1]; const c0 = IR[1];
var diff = IR[2]; const diff = IR[2];
var n = IR[3]; const n = IR[3];
var length = diff.length; const length = diff.length;
return function constructInterpolatedFromIRResult( return function constructInterpolatedFromIRResult(
src, src,
@ -426,46 +425,46 @@ var PDFFunction = (function PDFFunctionClosure() {
dest, dest,
destOffset destOffset
) { ) {
var x = n === 1 ? src[srcOffset] : src[srcOffset] ** n; const x = n === 1 ? src[srcOffset] : src[srcOffset] ** n;
for (var j = 0; j < length; ++j) { for (let j = 0; j < length; ++j) {
dest[destOffset + j] = c0[j] + x * diff[j]; dest[destOffset + j] = c0[j] + x * diff[j];
} }
}; };
}, },
constructStiched({ xref, isEvalSupported, fn, dict }) { constructStiched({ xref, isEvalSupported, fn, dict }) {
var domain = toNumberArray(dict.getArray("Domain")); const domain = toNumberArray(dict.getArray("Domain"));
if (!domain) { if (!domain) {
throw new FormatError("No domain"); throw new FormatError("No domain");
} }
var inputSize = domain.length / 2; const inputSize = domain.length / 2;
if (inputSize !== 1) { if (inputSize !== 1) {
throw new FormatError("Bad domain for stiched function"); throw new FormatError("Bad domain for stiched function");
} }
var fnRefs = dict.get("Functions"); const fnRefs = dict.get("Functions");
var fns = []; const fns = [];
for (var i = 0, ii = fnRefs.length; i < ii; ++i) { for (let i = 0, ii = fnRefs.length; i < ii; ++i) {
fns.push( fns.push(
this.parse({ xref, isEvalSupported, fn: xref.fetchIfRef(fnRefs[i]) }) this.parse({ xref, isEvalSupported, fn: xref.fetchIfRef(fnRefs[i]) })
); );
} }
var bounds = toNumberArray(dict.getArray("Bounds")); const bounds = toNumberArray(dict.getArray("Bounds"));
var encode = toNumberArray(dict.getArray("Encode")); const encode = toNumberArray(dict.getArray("Encode"));
return [CONSTRUCT_STICHED, domain, bounds, encode, fns]; return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
}, },
constructStichedFromIR({ xref, isEvalSupported, IR }) { constructStichedFromIR({ xref, isEvalSupported, IR }) {
var domain = IR[1]; const domain = IR[1];
var bounds = IR[2]; const bounds = IR[2];
var encode = IR[3]; const encode = IR[3];
var fns = IR[4]; const fns = IR[4];
var tmpBuf = new Float32Array(1); const tmpBuf = new Float32Array(1);
return function constructStichedFromIRResult( return function constructStichedFromIRResult(
src, src,
@ -473,7 +472,7 @@ var PDFFunction = (function PDFFunctionClosure() {
dest, dest,
destOffset destOffset
) { ) {
var clip = function constructStichedFromIRClip(v, min, max) { const clip = function constructStichedFromIRClip(v, min, max) {
if (v > max) { if (v > max) {
v = max; v = max;
} else if (v < min) { } else if (v < min) {
@ -483,26 +482,28 @@ var PDFFunction = (function PDFFunctionClosure() {
}; };
// clip to domain // clip to domain
var v = clip(src[srcOffset], domain[0], domain[1]); const v = clip(src[srcOffset], domain[0], domain[1]);
// calculate which bound the value is in // calculate which bound the value is in
for (var i = 0, ii = bounds.length; i < ii; ++i) { const length = bounds.length;
let i;
for (i = 0; i < length; ++i) {
if (v < bounds[i]) { if (v < bounds[i]) {
break; break;
} }
} }
// encode value into domain of function // encode value into domain of function
var dmin = domain[0]; let dmin = domain[0];
if (i > 0) { if (i > 0) {
dmin = bounds[i - 1]; dmin = bounds[i - 1];
} }
var dmax = domain[1]; let dmax = domain[1];
if (i < bounds.length) { if (i < bounds.length) {
dmax = bounds[i]; dmax = bounds[i];
} }
var rmin = encode[2 * i]; const rmin = encode[2 * i];
var rmax = encode[2 * i + 1]; const rmax = encode[2 * i + 1];
// Prevent the value from becoming NaN as a result // Prevent the value from becoming NaN as a result
// of division by zero (fixes issue6113.pdf). // of division by zero (fixes issue6113.pdf).
@ -517,8 +518,8 @@ var PDFFunction = (function PDFFunctionClosure() {
}, },
constructPostScript({ xref, isEvalSupported, fn, dict }) { constructPostScript({ xref, isEvalSupported, fn, dict }) {
var domain = toNumberArray(dict.getArray("Domain")); const domain = toNumberArray(dict.getArray("Domain"));
var range = toNumberArray(dict.getArray("Range")); const range = toNumberArray(dict.getArray("Range"));
if (!domain) { if (!domain) {
throw new FormatError("No domain."); throw new FormatError("No domain.");
@ -528,17 +529,17 @@ var PDFFunction = (function PDFFunctionClosure() {
throw new FormatError("No range."); throw new FormatError("No range.");
} }
var lexer = new PostScriptLexer(fn); const lexer = new PostScriptLexer(fn);
var parser = new PostScriptParser(lexer); const parser = new PostScriptParser(lexer);
var code = parser.parse(); const code = parser.parse();
return [CONSTRUCT_POSTSCRIPT, domain, range, code]; return [CONSTRUCT_POSTSCRIPT, domain, range, code];
}, },
constructPostScriptFromIR({ xref, isEvalSupported, IR }) { constructPostScriptFromIR({ xref, isEvalSupported, IR }) {
var domain = IR[1]; const domain = IR[1];
var range = IR[2]; const range = IR[2];
var code = IR[3]; const code = IR[3];
if (isEvalSupported && IsEvalSupportedCached.value) { if (isEvalSupported && IsEvalSupportedCached.value) {
const compiled = new PostScriptCompiler().compile(code, domain, range); const compiled = new PostScriptCompiler().compile(code, domain, range);
@ -558,17 +559,17 @@ var PDFFunction = (function PDFFunctionClosure() {
} }
info("Unable to compile PS function"); info("Unable to compile PS function");
var numOutputs = range.length >> 1; const numOutputs = range.length >> 1;
var numInputs = domain.length >> 1; const numInputs = domain.length >> 1;
var evaluator = new PostScriptEvaluator(code); const evaluator = new PostScriptEvaluator(code);
// Cache the values for a big speed up, the cache size is limited though // Cache the values for a big speed up, the cache size is limited though
// since the number of possible values can be huge from a PS function. // since the number of possible values can be huge from a PS function.
var cache = Object.create(null); const cache = Object.create(null);
// The MAX_CACHE_SIZE is set to ~4x the maximum number of distinct values // The MAX_CACHE_SIZE is set to ~4x the maximum number of distinct values
// seen in our tests. // seen in our tests.
var MAX_CACHE_SIZE = 2048 * 4; const MAX_CACHE_SIZE = 2048 * 4;
var cache_available = MAX_CACHE_SIZE; let cache_available = MAX_CACHE_SIZE;
var tmpBuf = new Float32Array(numInputs); const tmpBuf = new Float32Array(numInputs);
return function constructPostScriptFromIRResult( return function constructPostScriptFromIRResult(
src, src,
@ -576,27 +577,27 @@ var PDFFunction = (function PDFFunctionClosure() {
dest, dest,
destOffset destOffset
) { ) {
var i, value; let i, value;
var key = ""; let key = "";
var input = tmpBuf; const input = tmpBuf;
for (i = 0; i < numInputs; i++) { for (i = 0; i < numInputs; i++) {
value = src[srcOffset + i]; value = src[srcOffset + i];
input[i] = value; input[i] = value;
key += value + "_"; key += value + "_";
} }
var cachedValue = cache[key]; const cachedValue = cache[key];
if (cachedValue !== undefined) { if (cachedValue !== undefined) {
dest.set(cachedValue, destOffset); dest.set(cachedValue, destOffset);
return; return;
} }
var output = new Float32Array(numOutputs); const output = new Float32Array(numOutputs);
var stack = evaluator.execute(input); const stack = evaluator.execute(input);
var stackIndex = stack.length - numOutputs; const stackIndex = stack.length - numOutputs;
for (i = 0; i < numOutputs; i++) { for (i = 0; i < numOutputs; i++) {
value = stack[stackIndex + i]; value = stack[stackIndex + i];
var bound = range[i * 2]; let bound = range[i * 2];
if (value < bound) { if (value < bound) {
value = bound; value = bound;
} else { } else {
@ -618,7 +619,7 @@ var PDFFunction = (function PDFFunctionClosure() {
})(); })();
function isPDFFunction(v) { function isPDFFunction(v) {
var fnDict; let fnDict;
if (typeof v !== "object") { if (typeof v !== "object") {
return false; return false;
} else if (isDict(v)) { } else if (isDict(v)) {
@ -631,8 +632,8 @@ function isPDFFunction(v) {
return fnDict.has("FunctionType"); return fnDict.has("FunctionType");
} }
var PostScriptStack = (function PostScriptStackClosure() { const PostScriptStack = (function PostScriptStackClosure() {
var MAX_STACK_SIZE = 100; const MAX_STACK_SIZE = 100;
// eslint-disable-next-line no-shadow // eslint-disable-next-line no-shadow
class PostScriptStack { class PostScriptStack {
@ -660,8 +661,8 @@ var PostScriptStack = (function PostScriptStackClosure() {
if (this.stack.length + n >= MAX_STACK_SIZE) { if (this.stack.length + n >= MAX_STACK_SIZE) {
throw new Error("PostScript function stack overflow."); throw new Error("PostScript function stack overflow.");
} }
var stack = this.stack; const stack = this.stack;
for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) { for (let i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
stack.push(stack[i]); stack.push(stack[i]);
} }
} }
@ -672,25 +673,23 @@ var PostScriptStack = (function PostScriptStackClosure() {
// rotate the last n stack elements p times // rotate the last n stack elements p times
roll(n, p) { roll(n, p) {
var stack = this.stack; const stack = this.stack;
var l = stack.length - n; const l = stack.length - n;
var r = stack.length - 1, const r = stack.length - 1;
c = l + (p - Math.floor(p / n) * n), const c = l + (p - Math.floor(p / n) * n);
i,
j, for (let i = l, j = r; i < j; i++, j--) {
t; const t = stack[i];
for (i = l, j = r; i < j; i++, j--) {
t = stack[i];
stack[i] = stack[j]; stack[i] = stack[j];
stack[j] = t; stack[j] = t;
} }
for (i = l, j = c - 1; i < j; i++, j--) { for (let i = l, j = c - 1; i < j; i++, j--) {
t = stack[i]; const t = stack[i];
stack[i] = stack[j]; stack[i] = stack[j];
stack[j] = t; stack[j] = t;
} }
for (i = c, j = r; i < j; i++, j--) { for (let i = c, j = r; i < j; i++, j--) {
t = stack[i]; const t = stack[i];
stack[i] = stack[j]; stack[i] = stack[j];
stack[j] = t; stack[j] = t;
} }
@ -706,11 +705,11 @@ class PostScriptEvaluator {
} }
execute(initialStack) { execute(initialStack) {
var stack = new PostScriptStack(initialStack); const stack = new PostScriptStack(initialStack);
var counter = 0; let counter = 0;
var operators = this.operators; const operators = this.operators;
var length = operators.length; const length = operators.length;
var operator, a, b; let operator, a, b;
while (counter < length) { while (counter < length) {
operator = operators[counter++]; operator = operators[counter++];
if (typeof operator === "number") { if (typeof operator === "number") {
@ -940,7 +939,7 @@ class PostScriptEvaluator {
// We can compile most of such programs, and at the same moment, we can // We can compile most of such programs, and at the same moment, we can
// optimize some expressions using basic math properties. Keeping track of // optimize some expressions using basic math properties. Keeping track of
// min/max values will allow us to avoid extra Math.min/Math.max calls. // min/max values will allow us to avoid extra Math.min/Math.max calls.
var PostScriptCompiler = (function PostScriptCompilerClosure() { const PostScriptCompiler = (function PostScriptCompilerClosure() {
class AstNode { class AstNode {
constructor(type) { constructor(type) {
this.type = type; this.type = type;
@ -1124,13 +1123,13 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
return num2; // and it's 1 return num2; // and it's 1
} }
} }
var min = Math.min( const min = Math.min(
num1.min * num2.min, num1.min * num2.min,
num1.min * num2.max, num1.min * num2.max,
num1.max * num2.min, num1.max * num2.min,
num1.max * num2.max num1.max * num2.max
); );
var max = Math.max( const max = Math.max(
num1.min * num2.min, num1.min * num2.min,
num1.min * num2.max, num1.min * num2.max,
num1.max * num2.min, num1.max * num2.min,
@ -1183,13 +1182,13 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
// eslint-disable-next-line no-shadow // eslint-disable-next-line no-shadow
class PostScriptCompiler { class PostScriptCompiler {
compile(code, domain, range) { compile(code, domain, range) {
var stack = []; const stack = [];
var instructions = []; const instructions = [];
var inputSize = domain.length >> 1, const inputSize = domain.length >> 1,
outputSize = range.length >> 1; outputSize = range.length >> 1;
var lastRegister = 0; let lastRegister = 0;
var n, j; let n, j;
var num1, num2, ast1, ast2, tmpVar, item; let num1, num2, ast1, ast2, tmpVar, item;
for (let i = 0; i < inputSize; i++) { for (let i = 0; i < inputSize; i++) {
stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1])); stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1]));
} }
@ -1336,7 +1335,7 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
return null; return null;
} }
var result = []; const result = [];
for (const instruction of instructions) { for (const instruction of instructions) {
const statementBuilder = new ExpressionBuilderVisitor(); const statementBuilder = new ExpressionBuilderVisitor();
instruction.visit(statementBuilder); instruction.visit(statementBuilder);
@ -1346,9 +1345,9 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
const expr = stack[i], const expr = stack[i],
statementBuilder = new ExpressionBuilderVisitor(); statementBuilder = new ExpressionBuilderVisitor();
expr.visit(statementBuilder); expr.visit(statementBuilder);
var min = range[i * 2], const min = range[i * 2],
max = range[i * 2 + 1]; max = range[i * 2 + 1];
var out = [statementBuilder.toString()]; const out = [statementBuilder.toString()];
if (min > expr.min) { if (min > expr.min) {
out.unshift("Math.max(", min, ", "); out.unshift("Math.max(", min, ", ");
out.push(")"); out.push(")");