Replace all occurences of var with let/const in src/core/colorspace.js

src/core/colorspace.js

@@ -29,13 +29,13 @@ import { isDict, isName, isStream } from './primitives';
  * @param {Number} alpha01 - Size reserved for the alpha channel.
  */
 function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
-  var COMPONENTS = 3;
+  const COMPONENTS = 3;
   alpha01 = alpha01 !== 1 ? 0 : alpha01;
-  var xRatio = w1 / w2;
+  let xRatio = w1 / w2;
-  var yRatio = h1 / h2;
+  let yRatio = h1 / h2;
-  var newIndex = 0, oldIndex;
+  let newIndex = 0, oldIndex;
-  var xScaled = new Uint16Array(w2);
+  let xScaled = new Uint16Array(w2);
-  var w1Scanline = w1 * COMPONENTS;
+  let w1Scanline = w1 * COMPONENTS;
 
   for (let i = 0; i < w2; i++) {
     xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
@@ -121,10 +121,10 @@ class ColorSpace {
       assert(dest instanceof Uint8ClampedArray,
              'ColorSpace.fillRgb: Unsupported "dest" type.');
     }
-    var count = originalWidth * originalHeight;
+    let count = originalWidth * originalHeight;
-    var rgbBuf = null;
+    let rgbBuf = null;
-    var numComponentColors = 1 << bpc;
+    let numComponentColors = 1 << bpc;
-    var needsResizing = originalHeight !== height || originalWidth !== width;
+    let needsResizing = originalHeight !== height || originalWidth !== width;
 
     if (this.isPassthrough(bpc)) {
       rgbBuf = comps;
@@ -139,12 +139,12 @@ class ColorSpace {
       // TODO it may be worth while to cache the color map. While running
       // testing I never hit a cache so I will leave that out for now (perhaps
       // we are reparsing colorspaces too much?).
-      var allColors = bpc <= 8 ? new Uint8Array(numComponentColors) :
+      let allColors = bpc <= 8 ? new Uint8Array(numComponentColors) :
                                  new Uint16Array(numComponentColors);
       for (let i = 0; i < numComponentColors; i++) {
         allColors[i] = i;
       }
-      var colorMap = new Uint8ClampedArray(numComponentColors * 3);
+      let colorMap = new Uint8ClampedArray(numComponentColors * 3);
       this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc,
                         /* alpha01 = */ 0);
 
@@ -210,8 +210,8 @@ class ColorSpace {
   }
 
   static fromIR(IR) {
-    var name = Array.isArray(IR) ? IR[0] : IR;
+    let name = Array.isArray(IR) ? IR[0] : IR;
-    var whitePoint, blackPoint, gamma;
+    let whitePoint, blackPoint, gamma;
 
     switch (name) {
       case 'DeviceGrayCS':
@@ -229,28 +229,28 @@ class ColorSpace {
         whitePoint = IR[1];
         blackPoint = IR[2];
         gamma = IR[3];
-        var matrix = IR[4];
+        let matrix = IR[4];
         return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
       case 'PatternCS':
-        var basePatternCS = IR[1];
+        let basePatternCS = IR[1];
         if (basePatternCS) {
           basePatternCS = this.fromIR(basePatternCS);
         }
         return new PatternCS(basePatternCS);
       case 'IndexedCS':
-        var baseIndexedCS = IR[1];
+        let baseIndexedCS = IR[1];
-        var hiVal = IR[2];
+        let hiVal = IR[2];
-        var lookup = IR[3];
+        let lookup = IR[3];
         return new IndexedCS(this.fromIR(baseIndexedCS), hiVal, lookup);
       case 'AlternateCS':
-        var numComps = IR[1];
+        let numComps = IR[1];
-        var alt = IR[2];
+        let alt = IR[2];
-        var tintFn = IR[3];
+        let tintFn = IR[3];
         return new AlternateCS(numComps, this.fromIR(alt), tintFn);
       case 'LabCS':
         whitePoint = IR[1];
         blackPoint = IR[2];
-        var range = IR[3];
+        let range = IR[3];
         return new LabCS(whitePoint, blackPoint, range);
       default:
         throw new FormatError(`Unknown colorspace name: ${name}`);
@@ -290,8 +290,8 @@ class ColorSpace {
       }
     }
     if (Array.isArray(cs)) {
-      var mode = xref.fetchIfRef(cs[0]).name;
+      let mode = xref.fetchIfRef(cs[0]).name;
-      var numComps, params, alt, whitePoint, blackPoint, gamma;
+      let numComps, params, alt, whitePoint, blackPoint, gamma;
 
       switch (mode) {
         case 'DeviceGray':
@@ -314,18 +314,18 @@ class ColorSpace {
           whitePoint = params.getArray('WhitePoint');
           blackPoint = params.getArray('BlackPoint');
           gamma = params.getArray('Gamma');
-          var matrix = params.getArray('Matrix');
+          let matrix = params.getArray('Matrix');
           return ['CalRGBCS', whitePoint, blackPoint, gamma, matrix];
         case 'ICCBased':
-          var stream = xref.fetchIfRef(cs[1]);
+          let stream = xref.fetchIfRef(cs[1]);
-          var dict = stream.dict;
+          let dict = stream.dict;
           numComps = dict.get('N');
           alt = dict.get('Alternate');
           if (alt) {
-            var altIR = this.parseToIR(alt, xref, res, pdfFunctionFactory);
+            let altIR = this.parseToIR(alt, xref, res, pdfFunctionFactory);
             // Parse the /Alternate CS to ensure that the number of components
             // are correct, and also (indirectly) that it is not a PatternCS.
-            var altCS = this.fromIR(altIR, pdfFunctionFactory);
+            let altCS = this.fromIR(altIR, pdfFunctionFactory);
             if (altCS.numComps === numComps) {
               return altIR;
             }
@@ -340,7 +340,7 @@ class ColorSpace {
           }
           break;
         case 'Pattern':
-          var basePatternCS = cs[1] || null;
+          let basePatternCS = cs[1] || null;
           if (basePatternCS) {
             basePatternCS = this.parseToIR(basePatternCS, xref, res,
                                            pdfFunctionFactory);
@@ -348,17 +348,17 @@ class ColorSpace {
           return ['PatternCS', basePatternCS];
         case 'Indexed':
         case 'I':
-          var baseIndexedCS = this.parseToIR(cs[1], xref, res,
+          let baseIndexedCS = this.parseToIR(cs[1], xref, res,
                                              pdfFunctionFactory);
-          var hiVal = xref.fetchIfRef(cs[2]) + 1;
+          let hiVal = xref.fetchIfRef(cs[2]) + 1;
-          var lookup = xref.fetchIfRef(cs[3]);
+          let lookup = xref.fetchIfRef(cs[3]);
           if (isStream(lookup)) {
             lookup = lookup.getBytes();
           }
           return ['IndexedCS', baseIndexedCS, hiVal, lookup];
         case 'Separation':
         case 'DeviceN':
-          var name = xref.fetchIfRef(cs[1]);
+          let name = xref.fetchIfRef(cs[1]);
           numComps = Array.isArray(name) ? name.length : 1;
           alt = this.parseToIR(cs[2], xref, res, pdfFunctionFactory);
           let tintFn = pdfFunctionFactory.create(xref.fetchIfRef(cs[3]));
@@ -367,7 +367,7 @@ class ColorSpace {
           params = xref.fetchIfRef(cs[1]);
           whitePoint = params.getArray('WhitePoint');
           blackPoint = params.getArray('BlackPoint');
-          var range = params.getArray('Range');
+          let range = params.getArray('Range');
           return ['LabCS', whitePoint, blackPoint, range];
         default:
           throw new FormatError(`unimplemented color space object "${mode}"`);
@@ -394,7 +394,7 @@ class ColorSpace {
       warn('The decode map is not the correct length');
       return true;
     }
-    for (var i = 0, ii = decode.length; i < ii; i += 2) {
+    for (let i = 0, ii = decode.length; i < ii; i += 2) {
       if (decode[i] !== 0 || decode[i + 1] !== 1) {
         return false;
       }
@@ -439,7 +439,7 @@ class AlternateCS extends ColorSpace {
       assert(dest instanceof Uint8ClampedArray,
              'AlternateCS.getRgbItem: Unsupported "dest" type.');
     }
-    var tmpBuf = this.tmpBuf;
+    let tmpBuf = this.tmpBuf;
     this.tintFn(src, srcOffset, tmpBuf, 0);
     this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
   }
@@ -450,21 +450,21 @@ class AlternateCS extends ColorSpace {
       assert(dest instanceof Uint8ClampedArray,
              'AlternateCS.getRgbBuffer: Unsupported "dest" type.');
     }
-    var tintFn = this.tintFn;
+    let tintFn = this.tintFn;
-    var base = this.base;
+    let base = this.base;
-    var scale = 1 / ((1 << bits) - 1);
+    let scale = 1 / ((1 << bits) - 1);
-    var baseNumComps = base.numComps;
+    let baseNumComps = base.numComps;
-    var usesZeroToOneRange = base.usesZeroToOneRange;
+    let usesZeroToOneRange = base.usesZeroToOneRange;
-    var isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) &&
+    let isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) &&
                         alpha01 === 0;
-    var pos = isPassthrough ? destOffset : 0;
+    let pos = isPassthrough ? destOffset : 0;
     let baseBuf = isPassthrough ?
                   dest : new Uint8ClampedArray(baseNumComps * count);
-    var numComps = this.numComps;
+    let numComps = this.numComps;
 
-    var scaled = new Float32Array(numComps);
+    let scaled = new Float32Array(numComps);
-    var tinted = new Float32Array(baseNumComps);
+    let tinted = new Float32Array(baseNumComps);
-    var i, j;
+    let i, j;
 
     for (i = 0; i < count; i++) {
       for (j = 0; j < numComps; j++) {
@@ -513,16 +513,16 @@ class IndexedCS extends ColorSpace {
     this.base = base;
     this.highVal = highVal;
 
-    var baseNumComps = base.numComps;
+    let baseNumComps = base.numComps;
-    var length = baseNumComps * highVal;
+    let length = baseNumComps * highVal;
 
     if (isStream(lookup)) {
       this.lookup = new Uint8Array(length);
-      var bytes = lookup.getBytes(length);
+      let bytes = lookup.getBytes(length);
       this.lookup.set(bytes);
     } else if (isString(lookup)) {
       this.lookup = new Uint8Array(length);
-      for (var i = 0; i < length; ++i) {
+      for (let i = 0; i < length; ++i) {
         this.lookup[i] = lookup.charCodeAt(i);
       }
     } else if (lookup instanceof Uint8Array) {
@@ -538,8 +538,8 @@ class IndexedCS extends ColorSpace {
       assert(dest instanceof Uint8ClampedArray,
              'IndexedCS.getRgbItem: Unsupported "dest" type.');
     }
-    var numComps = this.base.numComps;
+    let numComps = this.base.numComps;
-    var start = src[srcOffset] * numComps;
+    let start = src[srcOffset] * numComps;
     this.base.getRgbBuffer(this.lookup, start, 1, dest, destOffset, 8, 0);
   }
 
@@ -549,13 +549,13 @@ class IndexedCS extends ColorSpace {
       assert(dest instanceof Uint8ClampedArray,
              'IndexedCS.getRgbBuffer: Unsupported "dest" type.');
     }
-    var base = this.base;
+    let base = this.base;
-    var numComps = base.numComps;
+    let numComps = base.numComps;
-    var outputDelta = base.getOutputLength(numComps, alpha01);
+    let outputDelta = base.getOutputLength(numComps, alpha01);
-    var lookup = this.lookup;
+    let lookup = this.lookup;
 
-    for (var i = 0; i < count; ++i) {
+    for (let i = 0; i < count; ++i) {
-      var lookupPos = src[srcOffset++] * numComps;
+      let lookupPos = src[srcOffset++] * numComps;
       base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);
       destOffset += outputDelta;
     }
@@ -594,9 +594,9 @@ class DeviceGrayCS extends ColorSpace {
       assert(dest instanceof Uint8ClampedArray,
              'DeviceGrayCS.getRgbBuffer: Unsupported "dest" type.');
     }
-    var scale = 255 / ((1 << bits) - 1);
+    let scale = 255 / ((1 << bits) - 1);
-    var j = srcOffset, q = destOffset;
+    let j = srcOffset, q = destOffset;
-    for (var i = 0; i < count; ++i) {
+    for (let i = 0; i < count; ++i) {
       let c = scale * src[j++];
       dest[q++] = c;
       dest[q++] = c;
@@ -643,9 +643,9 @@ class DeviceRgbCS extends ColorSpace {
       dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);
       return;
     }
-    var scale = 255 / ((1 << bits) - 1);
+    let scale = 255 / ((1 << bits) - 1);
-    var j = srcOffset, q = destOffset;
+    let j = srcOffset, q = destOffset;
-    for (var i = 0; i < count; ++i) {
+    for (let i = 0; i < count; ++i) {
       dest[q++] = scale * src[j++];
       dest[q++] = scale * src[j++];
       dest[q++] = scale * src[j++];
@@ -677,10 +677,10 @@ const DeviceCmykCS = (function DeviceCmykCSClosure() {
   // CMYK color conversion using the estimation below:
   //   f(A, B,.. N) = Acc+Bcm+Ccy+Dck+c+Fmm+Gmy+Hmk+Im+Jyy+Kyk+Ly+Mkk+Nk+255
   function convertToRgb(src, srcOffset, srcScale, dest, destOffset) {
-    var c = src[srcOffset] * srcScale;
+    let c = src[srcOffset] * srcScale;
-    var m = src[srcOffset + 1] * srcScale;
+    let m = src[srcOffset + 1] * srcScale;
-    var y = src[srcOffset + 2] * srcScale;
+    let y = src[srcOffset + 2] * srcScale;
-    var k = src[srcOffset + 3] * srcScale;
+    let k = src[srcOffset + 3] * srcScale;
 
     dest[destOffset] = 255 +
       c * (-4.387332384609988 * c + 54.48615194189176 * m +
@@ -732,8 +732,8 @@ const DeviceCmykCS = (function DeviceCmykCSClosure() {
         assert(dest instanceof Uint8ClampedArray,
                'DeviceCmykCS.getRgbBuffer: Unsupported "dest" type.');
       }
-      var scale = 1 / ((1 << bits) - 1);
+      let scale = 1 / ((1 << bits) - 1);
-      for (var i = 0; i < count; i++) {
+      for (let i = 0; i < count; i++) {
         convertToRgb(src, srcOffset, scale, dest, destOffset);
         srcOffset += 4;
         destOffset += 3 + alpha01;
@@ -760,12 +760,12 @@ const CalGrayCS = (function CalGrayCSClosure() {
   function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
     // A represents a gray component of a calibrated gray space.
     // A <---> AG in the spec
-    var A = src[srcOffset] * scale;
+    let A = src[srcOffset] * scale;
-    var AG = Math.pow(A, cs.G);
+    let AG = Math.pow(A, cs.G);
 
     // Computes L as per spec. ( = cs.YW * AG )
     // Except if other than default BlackPoint values are used.
-    var L = cs.YW * AG;
+    let L = cs.YW * AG;
     // http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html, Ch 4.
     // Convert values to rgb range [0, 255].
     let val = Math.max(295.8 * Math.pow(L, 0.333333333333333333) - 40.8, 0);
@@ -834,9 +834,9 @@ const CalGrayCS = (function CalGrayCSClosure() {
         assert(dest instanceof Uint8ClampedArray,
                'CalGrayCS.getRgbBuffer: Unsupported "dest" type.');
       }
-      var scale = 1 / ((1 << bits) - 1);
+      let scale = 1 / ((1 << bits) - 1);
 
-      for (var i = 0; i < count; ++i) {
+      for (let i = 0; i < count; ++i) {
         convertToRgb(this, src, srcOffset, dest, destOffset, scale);
         srcOffset += 1;
         destOffset += 3 + alpha01;
@@ -862,29 +862,29 @@ const CalGrayCS = (function CalGrayCSClosure() {
 const CalRGBCS = (function CalRGBCSClosure() {
   // See http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html for these
   // matrices.
-  var BRADFORD_SCALE_MATRIX = new Float32Array([
+  const BRADFORD_SCALE_MATRIX = new Float32Array([
     0.8951, 0.2664, -0.1614,
     -0.7502, 1.7135, 0.0367,
     0.0389, -0.0685, 1.0296]);
 
-  var BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([
+  const BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([
     0.9869929, -0.1470543, 0.1599627,
     0.4323053, 0.5183603, 0.0492912,
     -0.0085287, 0.0400428, 0.9684867]);
 
   // See http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html.
-  var SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([
+  const SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([
     3.2404542, -1.5371385, -0.4985314,
     -0.9692660, 1.8760108, 0.0415560,
     0.0556434, -0.2040259, 1.0572252]);
 
-  var FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
+  const FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
 
-  var tempNormalizeMatrix = new Float32Array(3);
+  let tempNormalizeMatrix = new Float32Array(3);
-  var tempConvertMatrix1 = new Float32Array(3);
+  let tempConvertMatrix1 = new Float32Array(3);
-  var tempConvertMatrix2 = new Float32Array(3);
+  let tempConvertMatrix2 = new Float32Array(3);
 
-  var DECODE_L_CONSTANT = Math.pow(((8 + 16) / 116), 3) / 8.0;
+  const DECODE_L_CONSTANT = Math.pow(((8 + 16) / 116), 3) / 8.0;
 
   function matrixProduct(a, b, result) {
     result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
@@ -899,9 +899,9 @@ const CalRGBCS = (function CalRGBCSClosure() {
   }
 
   function convertToD65(sourceWhitePoint, LMS, result) {
-    var D65X = 0.95047;
+    const D65X = 0.95047;
-    var D65Y = 1;
+    const D65Y = 1;
-    var D65Z = 1.08883;
+    const D65Z = 1.08883;
 
     result[0] = LMS[0] * D65X / sourceWhitePoint[0];
     result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
@@ -945,25 +945,25 @@ const CalRGBCS = (function CalRGBCSClosure() {
     // http://www.adobe.com/content/dam/Adobe/en/devnet/photoshop/sdk/
     // AdobeBPC.pdf.
     // The destination blackPoint is the default blackPoint [0, 0, 0].
-    var zeroDecodeL = decodeL(0);
+    let zeroDecodeL = decodeL(0);
 
-    var X_DST = zeroDecodeL;
+    let X_DST = zeroDecodeL;
-    var X_SRC = decodeL(sourceBlackPoint[0]);
+    let X_SRC = decodeL(sourceBlackPoint[0]);
 
-    var Y_DST = zeroDecodeL;
+    let Y_DST = zeroDecodeL;
-    var Y_SRC = decodeL(sourceBlackPoint[1]);
+    let Y_SRC = decodeL(sourceBlackPoint[1]);
 
-    var Z_DST = zeroDecodeL;
+    let Z_DST = zeroDecodeL;
-    var Z_SRC = decodeL(sourceBlackPoint[2]);
+    let Z_SRC = decodeL(sourceBlackPoint[2]);
 
-    var X_Scale = (1 - X_DST) / (1 - X_SRC);
+    let X_Scale = (1 - X_DST) / (1 - X_SRC);
-    var X_Offset = 1 - X_Scale;
+    let X_Offset = 1 - X_Scale;
 
-    var Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
+    let Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
-    var Y_Offset = 1 - Y_Scale;
+    let Y_Offset = 1 - Y_Scale;
 
-    var Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
+    let Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
-    var Z_Offset = 1 - Z_Scale;
+    let Z_Offset = 1 - Z_Scale;
 
     result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
     result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
@@ -980,20 +980,20 @@ const CalRGBCS = (function CalRGBCSClosure() {
       return;
     }
 
-    var LMS = result;
+    let LMS = result;
     matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
 
-    var LMS_Flat = tempNormalizeMatrix;
+    let LMS_Flat = tempNormalizeMatrix;
     convertToFlat(sourceWhitePoint, LMS, LMS_Flat);
 
     matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
   }
 
   function normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
-    var LMS = result;
+    let LMS = result;
     matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
 
-    var LMS_D65 = tempNormalizeMatrix;
+    let LMS_D65 = tempNormalizeMatrix;
     convertToD65(sourceWhitePoint, LMS, LMS_D65);
 
     matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
@@ -1002,41 +1002,41 @@ const CalRGBCS = (function CalRGBCSClosure() {
   function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
     // A, B and C represent a red, green and blue components of a calibrated
     // rgb space.
-    var A = adjustToRange(0, 1, src[srcOffset] * scale);
+    let A = adjustToRange(0, 1, src[srcOffset] * scale);
-    var B = adjustToRange(0, 1, src[srcOffset + 1] * scale);
+    let B = adjustToRange(0, 1, src[srcOffset + 1] * scale);
-    var C = adjustToRange(0, 1, src[srcOffset + 2] * scale);
+    let C = adjustToRange(0, 1, src[srcOffset + 2] * scale);
 
     // A <---> AGR in the spec
     // B <---> BGG in the spec
     // C <---> CGB in the spec
-    var AGR = Math.pow(A, cs.GR);
+    let AGR = Math.pow(A, cs.GR);
-    var BGG = Math.pow(B, cs.GG);
+    let BGG = Math.pow(B, cs.GG);
-    var CGB = Math.pow(C, cs.GB);
+    let CGB = Math.pow(C, cs.GB);
 
     // Computes intermediate variables L, M, N as per spec.
     // To decode X, Y, Z values map L, M, N directly to them.
-    var X = cs.MXA * AGR + cs.MXB * BGG + cs.MXC * CGB;
+    let X = cs.MXA * AGR + cs.MXB * BGG + cs.MXC * CGB;
-    var Y = cs.MYA * AGR + cs.MYB * BGG + cs.MYC * CGB;
+    let Y = cs.MYA * AGR + cs.MYB * BGG + cs.MYC * CGB;
-    var Z = cs.MZA * AGR + cs.MZB * BGG + cs.MZC * CGB;
+    let Z = cs.MZA * AGR + cs.MZB * BGG + cs.MZC * CGB;
 
     // The following calculations are based on this document:
     // http://www.adobe.com/content/dam/Adobe/en/devnet/photoshop/sdk/
     // AdobeBPC.pdf.
-    var XYZ = tempConvertMatrix1;
+    let XYZ = tempConvertMatrix1;
     XYZ[0] = X;
     XYZ[1] = Y;
     XYZ[2] = Z;
-    var XYZ_Flat = tempConvertMatrix2;
+    let XYZ_Flat = tempConvertMatrix2;
 
     normalizeWhitePointToFlat(cs.whitePoint, XYZ, XYZ_Flat);
 
-    var XYZ_Black = tempConvertMatrix1;
+    let XYZ_Black = tempConvertMatrix1;
     compensateBlackPoint(cs.blackPoint, XYZ_Flat, XYZ_Black);
 
-    var XYZ_D65 = tempConvertMatrix2;
+    let XYZ_D65 = tempConvertMatrix2;
     normalizeWhitePointToD65(FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);
 
-    var SRGB = tempConvertMatrix1;
+    let SRGB = tempConvertMatrix1;
     matrixProduct(SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
 
     // Convert the values to rgb range [0, 255].
@@ -1058,14 +1058,14 @@ const CalRGBCS = (function CalRGBCSClosure() {
       matrix = matrix || new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
 
       // Translate arguments to spec variables.
-      var XW = whitePoint[0];
+      let XW = whitePoint[0];
-      var YW = whitePoint[1];
+      let YW = whitePoint[1];
-      var ZW = whitePoint[2];
+      let ZW = whitePoint[2];
       this.whitePoint = whitePoint;
 
-      var XB = blackPoint[0];
+      let XB = blackPoint[0];
-      var YB = blackPoint[1];
+      let YB = blackPoint[1];
-      var ZB = blackPoint[2];
+      let ZB = blackPoint[2];
       this.blackPoint = blackPoint;
 
       this.GR = gamma[0];
@@ -1116,9 +1116,9 @@ const CalRGBCS = (function CalRGBCSClosure() {
         assert(dest instanceof Uint8ClampedArray,
               'CalRGBCS.getRgbBuffer: Unsupported "dest" type.');
       }
-      var scale = 1 / ((1 << bits) - 1);
+      let scale = 1 / ((1 << bits) - 1);
 
-      for (var i = 0; i < count; ++i) {
+      for (let i = 0; i < count; ++i) {
         convertToRgb(this, src, srcOffset, dest, destOffset, scale);
         srcOffset += 3;
         destOffset += 3 + alpha01;
@@ -1144,7 +1144,7 @@ const CalRGBCS = (function CalRGBCSClosure() {
 const LabCS = (function LabCSClosure() {
   // Function g(x) from spec
   function fn_g(x) {
-    var result;
+    let result;
     if (x >= 6 / 29) {
       result = x * x * x;
     } else {
@@ -1165,9 +1165,9 @@ const LabCS = (function LabCSClosure() {
     // converting an image we have to map the values to the correct range given
     // above.
     // Ls,as,bs <---> L*,a*,b* in the spec
-    var Ls = src[srcOffset];
+    let Ls = src[srcOffset];
-    var as = src[srcOffset + 1];
+    let as = src[srcOffset + 1];
-    var bs = src[srcOffset + 2];
+    let bs = src[srcOffset + 2];
     if (maxVal !== false) {
       Ls = decode(Ls, maxVal, 0, 100);
       as = decode(as, maxVal, cs.amin, cs.amax);
@@ -1179,15 +1179,15 @@ const LabCS = (function LabCSClosure() {
     bs = bs > cs.bmax ? cs.bmax : bs < cs.bmin ? cs.bmin : bs;
 
     // Computes intermediate variables X,Y,Z as per spec
-    var M = (Ls + 16) / 116;
+    let M = (Ls + 16) / 116;
-    var L = M + (as / 500);
+    let L = M + (as / 500);
-    var N = M - (bs / 200);
+    let N = M - (bs / 200);
 
-    var X = cs.XW * fn_g(L);
+    let X = cs.XW * fn_g(L);
-    var Y = cs.YW * fn_g(M);
+    let Y = cs.YW * fn_g(M);
-    var Z = cs.ZW * fn_g(N);
+    let Z = cs.ZW * fn_g(N);
 
-    var r, g, b;
+    let r, g, b;
     // Using different conversions for D50 and D65 white points,
     // per http://www.color.org/srgb.pdf
     if (cs.ZW < 1) {
@@ -1268,8 +1268,8 @@ const LabCS = (function LabCSClosure() {
         assert(dest instanceof Uint8ClampedArray,
                'LabCS.getRgbBuffer: Unsupported "dest" type.');
       }
-      var maxVal = (1 << bits) - 1;
+      let maxVal = (1 << bits) - 1;
-      for (var i = 0; i < count; i++) {
+      for (let i = 0; i < count; i++) {
         convertToRgb(this, src, srcOffset, maxVal, dest, destOffset);
         srcOffset += 3;
         destOffset += 3 + alpha01;