diff --git a/src/core/pattern.js b/src/core/pattern.js
index 9c83b5ad1..eedd8b686 100644
--- a/src/core/pattern.js
+++ b/src/core/pattern.js
@@ -12,7 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/* eslint-disable no-var */
 
 import {
   assert,
@@ -27,7 +26,7 @@ import { ColorSpace } from "./colorspace.js";
 import { isStream } from "./primitives.js";
 import { MissingDataException } from "./core_utils.js";
 
-var ShadingType = {
+const ShadingType = {
   FUNCTION_BASED: 1,
   AXIAL: 2,
   RADIAL: 3,
@@ -37,7 +36,7 @@ var ShadingType = {
   TENSOR_PATCH_MESH: 7,
 };
 
-var Pattern = (function PatternClosure() {
+const Pattern = (function PatternClosure() {
   // Constructor should define this.getPattern
   // eslint-disable-next-line no-shadow
   function Pattern() {
@@ -61,8 +60,8 @@ var Pattern = (function PatternClosure() {
     pdfFunctionFactory,
     localColorSpaceCache
   ) {
-    var dict = isStream(shading) ? shading.dict : shading;
-    var type = dict.get("ShadingType");
+    const dict = isStream(shading) ? shading.dict : shading;
+    const type = dict.get("ShadingType");
 
     try {
       switch (type) {
@@ -106,7 +105,7 @@ var Pattern = (function PatternClosure() {
   return Pattern;
 })();
 
-var Shadings = {};
+const Shadings = {};
 
 // A small number to offset the first/last color stops so we can insert ones to
 // support extend. Number.MIN_VALUE is too small and breaks the extend.
@@ -142,18 +141,18 @@ Shadings.RadialAxial = (function RadialAxialClosure() {
       this.bbox = null;
     }
 
-    var t0 = 0.0,
+    let t0 = 0.0,
       t1 = 1.0;
     if (dict.has("Domain")) {
-      var domainArr = dict.getArray("Domain");
+      const domainArr = dict.getArray("Domain");
       t0 = domainArr[0];
       t1 = domainArr[1];
     }
 
-    var extendStart = false,
+    let extendStart = false,
       extendEnd = false;
     if (dict.has("Extend")) {
-      var extendArr = dict.getArray("Extend");
+      const extendArr = dict.getArray("Extend");
       extendStart = extendArr[0];
       extendEnd = extendArr[1];
     }
@@ -174,8 +173,8 @@ Shadings.RadialAxial = (function RadialAxialClosure() {
     this.extendStart = extendStart;
     this.extendEnd = extendEnd;
 
-    var fnObj = dict.getRaw("Function");
-    var fn = pdfFunctionFactory.createFromArray(fnObj);
+    const fnObj = dict.getRaw("Function");
+    const fn = pdfFunctionFactory.createFromArray(fnObj);
 
     // 10 samples seems good enough for now, but probably won't work
     // if there are sharp color changes. Ideally, we would implement
@@ -183,7 +182,7 @@ Shadings.RadialAxial = (function RadialAxialClosure() {
     const NUMBER_OF_SAMPLES = 10;
     const step = (t1 - t0) / NUMBER_OF_SAMPLES;
 
-    var colorStops = (this.colorStops = []);
+    const colorStops = (this.colorStops = []);
 
     // Protect against bad domains.
     if (t0 >= t1 || step <= 0) {
@@ -193,18 +192,18 @@ Shadings.RadialAxial = (function RadialAxialClosure() {
       return;
     }
 
-    var color = new Float32Array(cs.numComps),
+    const color = new Float32Array(cs.numComps),
       ratio = new Float32Array(1);
-    var rgbColor;
+    let rgbColor;
     for (let i = 0; i <= NUMBER_OF_SAMPLES; i++) {
       ratio[0] = t0 + i * step;
       fn(ratio, 0, color, 0);
       rgbColor = cs.getRgb(color, 0);
-      var cssColor = Util.makeHexColor(rgbColor[0], rgbColor[1], rgbColor[2]);
+      const cssColor = Util.makeHexColor(rgbColor[0], rgbColor[1], rgbColor[2]);
       colorStops.push([i / NUMBER_OF_SAMPLES, cssColor]);
     }
 
-    var background = "transparent";
+    let background = "transparent";
     if (dict.has("Background")) {
       rgbColor = cs.getRgb(dict.get("Background"), 0);
       background = Util.makeHexColor(rgbColor[0], rgbColor[1], rgbColor[2]);
@@ -227,9 +226,9 @@ Shadings.RadialAxial = (function RadialAxialClosure() {
 
   RadialAxial.prototype = {
     getIR: function RadialAxial_getIR() {
-      var coordsArr = this.coordsArr;
-      var shadingType = this.shadingType;
-      var type, p0, p1, r0, r1;
+      const coordsArr = this.coordsArr;
+      const shadingType = this.shadingType;
+      let type, p0, p1, r0, r1;
       if (shadingType === ShadingType.AXIAL) {
         p0 = [coordsArr[0], coordsArr[1]];
         p1 = [coordsArr[2], coordsArr[3]];
@@ -246,12 +245,12 @@ Shadings.RadialAxial = (function RadialAxialClosure() {
         unreachable(`getPattern type unknown: ${shadingType}`);
       }
 
-      var matrix = this.matrix;
+      const matrix = this.matrix;
       if (matrix) {
         p0 = Util.applyTransform(p0, matrix);
         p1 = Util.applyTransform(p1, matrix);
         if (shadingType === ShadingType.RADIAL) {
-          var scale = Util.singularValueDecompose2dScale(matrix);
+          const scale = Util.singularValueDecompose2dScale(matrix);
           r0 *= scale[0];
           r1 *= scale[1];
         }
@@ -273,9 +272,9 @@ Shadings.Mesh = (function MeshClosure() {
     this.buffer = 0;
     this.bufferLength = 0;
 
-    var numComps = context.numComps;
+    const numComps = context.numComps;
     this.tmpCompsBuf = new Float32Array(numComps);
-    var csNumComps = context.colorSpace.numComps;
+    const csNumComps = context.colorSpace.numComps;
     this.tmpCsCompsBuf = context.colorFn
       ? new Float32Array(csNumComps)
       : this.tmpCompsBuf;
@@ -288,7 +287,7 @@ Shadings.Mesh = (function MeshClosure() {
       if (this.bufferLength > 0) {
         return true;
       }
-      var nextByte = this.stream.getByte();
+      const nextByte = this.stream.getByte();
       if (nextByte < 0) {
         return false;
       }
@@ -297,8 +296,8 @@ Shadings.Mesh = (function MeshClosure() {
       return true;
     },
     readBits: function MeshStreamReader_readBits(n) {
-      var buffer = this.buffer;
-      var bufferLength = this.bufferLength;
+      let buffer = this.buffer;
+      let bufferLength = this.bufferLength;
       if (n === 32) {
         if (bufferLength === 0) {
           return (
@@ -314,7 +313,7 @@ Shadings.Mesh = (function MeshClosure() {
           (this.stream.getByte() << 16) |
           (this.stream.getByte() << 8) |
           this.stream.getByte();
-        var nextByte = this.stream.getByte();
+        const nextByte = this.stream.getByte();
         this.buffer = nextByte & ((1 << bufferLength) - 1);
         return (
           ((buffer << (8 - bufferLength)) |
@@ -342,11 +341,11 @@ Shadings.Mesh = (function MeshClosure() {
       return this.readBits(this.context.bitsPerFlag);
     },
     readCoordinate: function MeshStreamReader_readCoordinate() {
-      var bitsPerCoordinate = this.context.bitsPerCoordinate;
-      var xi = this.readBits(bitsPerCoordinate);
-      var yi = this.readBits(bitsPerCoordinate);
-      var decode = this.context.decode;
-      var scale =
+      const bitsPerCoordinate = this.context.bitsPerCoordinate;
+      const xi = this.readBits(bitsPerCoordinate);
+      const yi = this.readBits(bitsPerCoordinate);
+      const decode = this.context.decode;
+      const scale =
         bitsPerCoordinate < 32
           ? 1 / ((1 << bitsPerCoordinate) - 1)
           : 2.3283064365386963e-10; // 2 ^ -32
@@ -356,19 +355,19 @@ Shadings.Mesh = (function MeshClosure() {
       ];
     },
     readComponents: function MeshStreamReader_readComponents() {
-      var numComps = this.context.numComps;
-      var bitsPerComponent = this.context.bitsPerComponent;
-      var scale =
+      const numComps = this.context.numComps;
+      const bitsPerComponent = this.context.bitsPerComponent;
+      const scale =
         bitsPerComponent < 32
           ? 1 / ((1 << bitsPerComponent) - 1)
           : 2.3283064365386963e-10; // 2 ^ -32
-      var decode = this.context.decode;
-      var components = this.tmpCompsBuf;
-      for (var i = 0, j = 4; i < numComps; i++, j += 2) {
-        var ci = this.readBits(bitsPerComponent);
+      const decode = this.context.decode;
+      const components = this.tmpCompsBuf;
+      for (let i = 0, j = 4; i < numComps; i++, j += 2) {
+        const ci = this.readBits(bitsPerComponent);
         components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j];
       }
-      var color = this.tmpCsCompsBuf;
+      const color = this.tmpCsCompsBuf;
       if (this.context.colorFn) {
         this.context.colorFn(components, 0, color, 0);
       }
@@ -377,15 +376,15 @@ Shadings.Mesh = (function MeshClosure() {
   };
 
   function decodeType4Shading(mesh, reader) {
-    var coords = mesh.coords;
-    var colors = mesh.colors;
-    var operators = [];
-    var ps = []; // not maintaining cs since that will match ps
-    var verticesLeft = 0; // assuming we have all data to start a new triangle
+    const coords = mesh.coords;
+    const colors = mesh.colors;
+    const operators = [];
+    const ps = []; // not maintaining cs since that will match ps
+    let verticesLeft = 0; // assuming we have all data to start a new triangle
     while (reader.hasData) {
-      var f = reader.readFlag();
-      var coord = reader.readCoordinate();
-      var color = reader.readComponents();
+      const f = reader.readFlag();
+      const coord = reader.readCoordinate();
+      const color = reader.readComponents();
       if (verticesLeft === 0) {
         // ignoring flags if we started a triangle
         if (!(0 <= f && f <= 2)) {
@@ -421,12 +420,12 @@ Shadings.Mesh = (function MeshClosure() {
   }
 
   function decodeType5Shading(mesh, reader, verticesPerRow) {
-    var coords = mesh.coords;
-    var colors = mesh.colors;
-    var ps = []; // not maintaining cs since that will match ps
+    const coords = mesh.coords;
+    const colors = mesh.colors;
+    const ps = []; // not maintaining cs since that will match ps
     while (reader.hasData) {
-      var coord = reader.readCoordinate();
-      var color = reader.readComponents();
+      const coord = reader.readCoordinate();
+      const color = reader.readComponents();
       ps.push(coords.length);
       coords.push(coord);
       colors.push(color);
@@ -439,16 +438,16 @@ Shadings.Mesh = (function MeshClosure() {
     });
   }
 
-  var MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
-  var MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
+  const MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
+  const MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
 
-  var TRIANGLE_DENSITY = 20; // count of triangles per entire mesh bounds
+  const TRIANGLE_DENSITY = 20; // count of triangles per entire mesh bounds
 
-  var getB = (function getBClosure() {
+  const getB = (function getBClosure() {
     function buildB(count) {
-      var lut = [];
-      for (var i = 0; i <= count; i++) {
-        var t = i / count,
+      const lut = [];
+      for (let i = 0; i <= count; i++) {
+        const t = i / count,
           t_ = 1 - t;
         lut.push(
           new Float32Array([
@@ -461,7 +460,7 @@ Shadings.Mesh = (function MeshClosure() {
       }
       return lut;
     }
-    var cache = [];
+    const cache = [];
 
     // eslint-disable-next-line no-shadow
     return function getB(count) {
@@ -473,39 +472,39 @@ Shadings.Mesh = (function MeshClosure() {
   })();
 
   function buildFigureFromPatch(mesh, index) {
-    var figure = mesh.figures[index];
+    const figure = mesh.figures[index];
     assert(figure.type === "patch", "Unexpected patch mesh figure");
 
-    var coords = mesh.coords,
+    const coords = mesh.coords,
       colors = mesh.colors;
-    var pi = figure.coords;
-    var ci = figure.colors;
+    const pi = figure.coords;
+    const ci = figure.colors;
 
-    var figureMinX = Math.min(
+    const figureMinX = Math.min(
       coords[pi[0]][0],
       coords[pi[3]][0],
       coords[pi[12]][0],
       coords[pi[15]][0]
     );
-    var figureMinY = Math.min(
+    const figureMinY = Math.min(
       coords[pi[0]][1],
       coords[pi[3]][1],
       coords[pi[12]][1],
       coords[pi[15]][1]
     );
-    var figureMaxX = Math.max(
+    const figureMaxX = Math.max(
       coords[pi[0]][0],
       coords[pi[3]][0],
       coords[pi[12]][0],
       coords[pi[15]][0]
     );
-    var figureMaxY = Math.max(
+    const figureMaxY = Math.max(
       coords[pi[0]][1],
       coords[pi[3]][1],
       coords[pi[12]][1],
       coords[pi[15]][1]
     );
-    var splitXBy = Math.ceil(
+    let splitXBy = Math.ceil(
       ((figureMaxX - figureMinX) * TRIANGLE_DENSITY) /
         (mesh.bounds[2] - mesh.bounds[0])
     );
@@ -513,7 +512,7 @@ Shadings.Mesh = (function MeshClosure() {
       MIN_SPLIT_PATCH_CHUNKS_AMOUNT,
       Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitXBy)
     );
-    var splitYBy = Math.ceil(
+    let splitYBy = Math.ceil(
       ((figureMaxY - figureMinY) * TRIANGLE_DENSITY) /
         (mesh.bounds[3] - mesh.bounds[1])
     );
@@ -522,19 +521,19 @@ Shadings.Mesh = (function MeshClosure() {
       Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitYBy)
     );
 
-    var verticesPerRow = splitXBy + 1;
-    var figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
-    var figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
-    var k = 0;
-    var cl = new Uint8Array(3),
+    const verticesPerRow = splitXBy + 1;
+    const figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
+    const figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
+    let k = 0;
+    const cl = new Uint8Array(3),
       cr = new Uint8Array(3);
-    var c0 = colors[ci[0]],
+    const c0 = colors[ci[0]],
       c1 = colors[ci[1]],
       c2 = colors[ci[2]],
       c3 = colors[ci[3]];
-    var bRow = getB(splitYBy),
+    const bRow = getB(splitYBy),
       bCol = getB(splitXBy);
-    for (var row = 0; row <= splitYBy; row++) {
+    for (let row = 0; row <= splitYBy; row++) {
       cl[0] = ((c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy) | 0;
       cl[1] = ((c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy) | 0;
       cl[2] = ((c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy) | 0;
@@ -543,19 +542,19 @@ Shadings.Mesh = (function MeshClosure() {
       cr[1] = ((c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy) | 0;
       cr[2] = ((c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy) | 0;
 
-      for (var col = 0; col <= splitXBy; col++, k++) {
+      for (let col = 0; col <= splitXBy; col++, k++) {
         if (
           (row === 0 || row === splitYBy) &&
           (col === 0 || col === splitXBy)
         ) {
           continue;
         }
-        var x = 0,
+        let x = 0,
           y = 0;
-        var q = 0;
-        for (var i = 0; i <= 3; i++) {
-          for (var j = 0; j <= 3; j++, q++) {
-            var m = bRow[row][i] * bCol[col][j];
+        let q = 0;
+        for (let i = 0; i <= 3; i++) {
+          for (let j = 0; j <= 3; j++, q++) {
+            const m = bRow[row][i] * bCol[col][j];
             x += coords[pi[q]][0] * m;
             y += coords[pi[q]][1] * m;
           }
@@ -563,7 +562,7 @@ Shadings.Mesh = (function MeshClosure() {
         figureCoords[k] = coords.length;
         coords.push([x, y]);
         figureColors[k] = colors.length;
-        var newColor = new Uint8Array(3);
+        const newColor = new Uint8Array(3);
         newColor[0] = ((cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy) | 0;
         newColor[1] = ((cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy) | 0;
         newColor[2] = ((cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy) | 0;
@@ -589,25 +588,24 @@ Shadings.Mesh = (function MeshClosure() {
 
   function decodeType6Shading(mesh, reader) {
     // A special case of Type 7. The p11, p12, p21, p22 automatically filled
-    var coords = mesh.coords;
-    var colors = mesh.colors;
-    var ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33
-    var cs = new Int32Array(4); // c00, c30, c03, c33
+    const coords = mesh.coords;
+    const colors = mesh.colors;
+    const ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33
+    const cs = new Int32Array(4); // c00, c30, c03, c33
     while (reader.hasData) {
-      var f = reader.readFlag();
+      const f = reader.readFlag();
       if (!(0 <= f && f <= 3)) {
         throw new FormatError("Unknown type6 flag");
       }
-      var i, ii;
-      var pi = coords.length;
-      for (i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
+      const pi = coords.length;
+      for (let i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
         coords.push(reader.readCoordinate());
       }
-      var ci = colors.length;
-      for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+      const ci = colors.length;
+      for (let i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
         colors.push(reader.readComponents());
       }
-      var tmp1, tmp2, tmp3, tmp4;
+      let tmp1, tmp2, tmp3, tmp4;
       switch (f) {
         // prettier-ignore
         case 0:
@@ -721,25 +719,24 @@ Shadings.Mesh = (function MeshClosure() {
   }
 
   function decodeType7Shading(mesh, reader) {
-    var coords = mesh.coords;
-    var colors = mesh.colors;
-    var ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33
-    var cs = new Int32Array(4); // c00, c30, c03, c33
+    const coords = mesh.coords;
+    const colors = mesh.colors;
+    const ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33
+    const cs = new Int32Array(4); // c00, c30, c03, c33
     while (reader.hasData) {
-      var f = reader.readFlag();
+      const f = reader.readFlag();
       if (!(0 <= f && f <= 3)) {
         throw new FormatError("Unknown type7 flag");
       }
-      var i, ii;
-      var pi = coords.length;
-      for (i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
+      const pi = coords.length;
+      for (let i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
         coords.push(reader.readCoordinate());
       }
-      var ci = colors.length;
-      for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+      const ci = colors.length;
+      for (let i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
         colors.push(reader.readComponents());
       }
-      var tmp1, tmp2, tmp3, tmp4;
+      let tmp1, tmp2, tmp3, tmp4;
       switch (f) {
         // prettier-ignore
         case 0:
@@ -792,12 +789,12 @@ Shadings.Mesh = (function MeshClosure() {
   }
 
   function updateBounds(mesh) {
-    var minX = mesh.coords[0][0],
+    let minX = mesh.coords[0][0],
       minY = mesh.coords[0][1],
       maxX = minX,
       maxY = minY;
-    for (var i = 1, ii = mesh.coords.length; i < ii; i++) {
-      var x = mesh.coords[i][0],
+    for (let i = 1, ii = mesh.coords.length; i < ii; i++) {
+      const x = mesh.coords[i][0],
         y = mesh.coords[i][1];
       minX = minX > x ? x : minX;
       minY = minY > y ? y : minY;
@@ -808,30 +805,30 @@ Shadings.Mesh = (function MeshClosure() {
   }
 
   function packData(mesh) {
-    var i, ii, j, jj;
+    let i, ii, j, jj;
 
-    var coords = mesh.coords;
-    var coordsPacked = new Float32Array(coords.length * 2);
+    const coords = mesh.coords;
+    const coordsPacked = new Float32Array(coords.length * 2);
     for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
-      var xy = coords[i];
+      const xy = coords[i];
       coordsPacked[j++] = xy[0];
       coordsPacked[j++] = xy[1];
     }
     mesh.coords = coordsPacked;
 
-    var colors = mesh.colors;
-    var colorsPacked = new Uint8Array(colors.length * 3);
+    const colors = mesh.colors;
+    const colorsPacked = new Uint8Array(colors.length * 3);
     for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
-      var c = colors[i];
+      const c = colors[i];
       colorsPacked[j++] = c[0];
       colorsPacked[j++] = c[1];
       colorsPacked[j++] = c[2];
     }
     mesh.colors = colorsPacked;
 
-    var figures = mesh.figures;
+    const figures = mesh.figures;
     for (i = 0, ii = figures.length; i < ii; i++) {
-      var figure = figures[i],
+      const figure = figures[i],
         ps = figure.coords,
         cs = figure.colors;
       for (j = 0, jj = ps.length; j < jj; j++) {
@@ -852,7 +849,7 @@ Shadings.Mesh = (function MeshClosure() {
     if (!isStream(stream)) {
       throw new FormatError("Mesh data is not a stream");
     }
-    var dict = stream.dict;
+    const dict = stream.dict;
     this.matrix = matrix;
     this.shadingType = dict.get("ShadingType");
     this.type = "Pattern";
@@ -874,14 +871,14 @@ Shadings.Mesh = (function MeshClosure() {
       ? cs.getRgb(dict.get("Background"), 0)
       : null;
 
-    var fnObj = dict.getRaw("Function");
-    var fn = fnObj ? pdfFunctionFactory.createFromArray(fnObj) : null;
+    const fnObj = dict.getRaw("Function");
+    const fn = fnObj ? pdfFunctionFactory.createFromArray(fnObj) : null;
 
     this.coords = [];
     this.colors = [];
     this.figures = [];
 
-    var decodeContext = {
+    const decodeContext = {
       bitsPerCoordinate: dict.get("BitsPerCoordinate"),
       bitsPerComponent: dict.get("BitsPerComponent"),
       bitsPerFlag: dict.get("BitsPerFlag"),
@@ -890,15 +887,15 @@ Shadings.Mesh = (function MeshClosure() {
       colorSpace: cs,
       numComps: fn ? 1 : cs.numComps,
     };
-    var reader = new MeshStreamReader(stream, decodeContext);
+    const reader = new MeshStreamReader(stream, decodeContext);
 
-    var patchMesh = false;
+    let patchMesh = false;
     switch (this.shadingType) {
       case ShadingType.FREE_FORM_MESH:
         decodeType4Shading(this, reader);
         break;
       case ShadingType.LATTICE_FORM_MESH:
-        var verticesPerRow = dict.get("VerticesPerRow") | 0;
+        const verticesPerRow = dict.get("VerticesPerRow") | 0;
         if (verticesPerRow < 2) {
           throw new FormatError("Invalid VerticesPerRow");
         }
@@ -920,7 +917,7 @@ Shadings.Mesh = (function MeshClosure() {
     if (patchMesh) {
       // dirty bounds calculation for determining, how dense shall be triangles
       updateBounds(this);
-      for (var i = 0, ii = this.figures.length; i < ii; i++) {
+      for (let i = 0, ii = this.figures.length; i < ii; i++) {
         buildFigureFromPatch(this, i);
       }
     }