@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/qrcode/encodings/encoders/utf8-encoder.js

@@ -3,71 +3,65 @@ import { EncodingResult } from '../encoding-result';
 import { DataModeInstances } from '../data-modes/data-mode-instances';
 import { extend } from '../../utils';
 import { toBitsString } from '../../utils';
-import { getVersion } from '../encoding';
+import { getVersion } from '../utils/index';
 
-var BYTE = "byte";
+const BYTE = "byte";
 
-export var Utf8Encoder = (function (Class) {
-    function Utf8Encoder() {
-        Class.call(this);
+export class Utf8Encoder extends Class {
+    constructor() {
+        super();
 
         this.initProperties();
 
         this.mode = DataModeInstances[this.encodingMode];
     }
 
-    if ( Class ) Utf8Encoder.__proto__ = Class;
-    Utf8Encoder.prototype = Object.create( Class && Class.prototype );
-    Utf8Encoder.prototype.constructor = Utf8Encoder;
-
-    Utf8Encoder.prototype.initProperties = function initProperties () {
+    initProperties() {
         extend(this, {
             encodingMode: BYTE,
             utfBOM: "111011111011101110111111",
             initialModeCountStringLength: 20,
             ranges: [128, 2048, 65536, 2097152, 67108864]
         });
-    };
+    }
 
-    Utf8Encoder.prototype.getEncodingResult = function getEncodingResult (inputString, errorCorrectionLevel) {
-        var data = this.encode(inputString),
+    getEncodingResult(inputString, errorCorrectionLevel) {
+        let data = this.encode(inputString),
             dataCodewordsCount = this.getDataCodewordsCount(data),
             version = getVersion(dataCodewordsCount, errorCorrectionLevel),
             dataString = this.mode.getModeCountString(data.length / 8, version) + data;
 
         return new EncodingResult(dataString, version);
-    };
+    }
 
-    Utf8Encoder.prototype.getDataCodewordsCount = function getDataCodewordsCount (data) {
-        var dataLength = data.length,
+    getDataCodewordsCount(data) {
+        let dataLength = data.length,
             dataCodewordsCount = Math.ceil((this.initialModeCountStringLength + dataLength) / 8);
 
         return dataCodewordsCount;
-    };
-
-    Utf8Encoder.prototype.encode = function encode (str) {
-        var this$1 = this;
+    }
 
-        var result = this.utfBOM;
+    encode(str) {
+        let result = this.utfBOM;
 
-        for (var i = 0; i < str.length; i++) {
-            result += this$1.encodeCharacter(str.charCodeAt(i));
+        for (let i = 0; i < str.length; i++) {
+            result += this.encodeCharacter(str.charCodeAt(i));
         }
 
         return result;
-    };
+    }
 
-    Utf8Encoder.prototype.encodeCharacter = function encodeCharacter (code) {
-        var bytesCount = this.getBytesCount(code),
+    encodeCharacter(code) {
+        let bytesCount = this.getBytesCount(code),
             bc = bytesCount - 1,
             result = "";
 
         if (bytesCount === 1) {
             result = toBitsString(code, 8);
         } else {
-            var significantOnes = 8 - bytesCount;
+            let significantOnes = 8 - bytesCount;
 
-            for (var i = 0; i < bc; i++) {
+            for (let i = 0; i < bc; i++) {
                 result = toBitsString(code >> (i * 6) & 63 | 128, 8) + result;
             }
 
@@ -75,17 +69,15 @@ export var Utf8Encoder = (function (Class) {
         }
 
         return result;
-    };
+    }
 
-    Utf8Encoder.prototype.getBytesCount = function getBytesCount (code) {
-        var ranges = this.ranges;
+    getBytesCount(code) {
+        let ranges = this.ranges;
 
-        for (var i = 0; i < ranges.length; i++) {
+        for (let i = 0; i < ranges.length; i++) {
             if (code < ranges[i]) {
                 return i + 1;
             }
         }
-    };
-
-    return Utf8Encoder;
-}(Class));
+    }
+}

package/dist/es/qrcode/encodings/encoding-result.js

@@ -1,16 +1,10 @@
 import { Class } from '../../common';
 
-export var EncodingResult = (function (Class) {
-    function EncodingResult(dataString, version) {
-        Class.call(this);
+export class EncodingResult extends Class {
+    constructor(dataString, version) {
+        super();
 
         this.dataString = dataString;
         this.version = version;
     }
-
-    if ( Class ) EncodingResult.__proto__ = Class;
-    EncodingResult.prototype = Object.create( Class && Class.prototype );
-    EncodingResult.prototype.constructor = EncodingResult;
-
-    return EncodingResult;
-}(Class));
+}

package/dist/es/qrcode/encodings/encoding.js

@@ -6,12 +6,8 @@ import { FreeCellVisitor } from './free-cell-visitor';
 import { IsoEncoder } from './encoders/iso-encoder';
 import { Utf8Encoder } from './encoders/utf8-encoder';
 import { VersionsCodewordsInformation } from './version-codewords';
-import { DataModeInstances } from './data-modes/data-mode-instances';
 
-var terminator = "0000",
-    NUMERIC = "numeric",
-    ALPHA_NUMERIC = "alphanumeric",
-    BYTE = "byte",
+let terminator = "0000",
     powersOfTwo = { "1": 0 },
     powersOfTwoResult = { "0": 1 },
     irregularAlignmentPatternsStartDistance = {
@@ -30,57 +26,45 @@ var terminator = "0000",
     /* eslint-disable arrow-body-style */
     /* eslint-disable no-unused-vars */
     maskPatternConditions = [
-        function (row, column) { return (row + column) % 2 === 0; },
-        function (row, column) { return row % 2 === 0; },
-        function (row, column) { return column % 3 === 0; },
-        function (row, column) { return (row + column) % 3 === 0; },
-        function (row, column) { return (Math.floor(row / 2) + Math.floor(column / 3)) % 2 === 0; },
-        function (row, column) { return ((row * column) % 2) + ((row * column) % 3) === 0; },
-        function (row, column) { return (((row * column) % 2) + ((row * column) % 3)) % 2 === 0; },
-        function (row, column) { return (((row + column) % 2) + ((row * column) % 3)) % 2 === 0; }
-    ],
-    /* eslint-enable no-unused-vars */
-    /* eslint-enable arrow-body-style */
-    numberRegex = /^\d+/,
-    alphaPattern = "A-Z0-9 $%*+./:-",
-    alphaExclusiveSet = "A-Z $%*+./:-",
-    alphaRegex = new RegExp("^[" + alphaExclusiveSet + "]+"),
-    alphaNumericRegex = new RegExp("^[" + alphaPattern + "]+"),
-    byteRegex = new RegExp("^[^" + alphaPattern + "]+"),
-    initMinNumericBeforeAlpha = 8,
-    initMinNumericBeforeByte = 5,
-    initMinAlphaBeforeByte = 8,
-    minNumericBeforeAlpha = 17,
-    minNumericBeforeByte = 9,
-    minAlphaBeforeByte = 16;
-
-export var generatorPolynomials = [[1, 0], [1, 25, 0]];
+        (row, column) => { return (row + column) % 2 === 0; },
+        (row, column) => { return row % 2 === 0; },
+        (row, column) => { return column % 3 === 0; },
+        (row, column) => { return (row + column) % 3 === 0; },
+        (row, column) => { return (Math.floor(row / 2) + Math.floor(column / 3)) % 2 === 0; },
+        (row, column) => { return ((row * column) % 2) + ((row * column) % 3) === 0; },
+        (row, column) => { return (((row * column) % 2) + ((row * column) % 3)) % 2 === 0; },
+        (row, column) => { return (((row + column) % 2) + ((row * column) % 3)) % 2 === 0; }
+    ];
+/* eslint-enable no-unused-vars */
+/* eslint-enable arrow-body-style */
+
+export const generatorPolynomials = [[1, 0], [1, 25, 0]];
 
 export function fillFunctionCell(matrices, bit, x, y) {
-    for (var i = 0; i < matrices.length; i++) {
+    for (let i = 0; i < matrices.length; i++) {
         matrices[i][x][y] = bit;
     }
 }
 
 export function fillDataCell(matrices, bit, x, y) {
-    for (var i = 0; i < maskPatternConditions.length; i++) {
+    for (let i = 0; i < maskPatternConditions.length; i++) {
         matrices[i][x][y] = maskPatternConditions[i](x, y) ? bit ^ 1 : parseInt(bit, 10);
     }
 }
 
 export function fillData(matrices, blocks) {
-    var cellVisitor = new FreeCellVisitor(matrices[0]),
+    let cellVisitor = new FreeCellVisitor(matrices[0]),
         block,
         codewordIdx,
         cell;
 
-    for (var blockIdx = 0; blockIdx < blocks.length; blockIdx++) {
+    for (let blockIdx = 0; blockIdx < blocks.length; blockIdx++) {
         block = blocks[blockIdx];
         codewordIdx = 0;
 
         while (block.length > 0) {
-            for (var i = 0; i < block.length; i++) {
-                for (var j = 0; j < 8; j++) {
+            for (let i = 0; i < block.length; i++) {
+                for (let j = 0; j < 8; j++) {
                     cell = cellVisitor.getNextCell();
                     fillDataCell(matrices, block[i][codewordIdx].charAt(j), cell.row, cell.column);
                 }
@@ -100,10 +84,10 @@ export function fillData(matrices, blocks) {
 }
 
 export function padDataString(initialDataString, totalDataCodewords) {
-    var dataBitsCount = totalDataCodewords * 8,
+    let dataBitsCount = totalDataCodewords * 8,
         terminatorIndex = 0,
         paddingCodewordIndex = 0;
-    var dataString = initialDataString;
+    let dataString = initialDataString;
 
     while (dataString.length < dataBitsCount && terminatorIndex < terminator.length) {
         dataString += terminator.charAt(terminatorIndex++);
@@ -122,8 +106,8 @@ export function padDataString(initialDataString, totalDataCodewords) {
 }
 
 export function generatePowersOfTwo() {
-    var result;
-    var power;
+    let result;
+    let power;
 
     for (power = 1; power < 255; power++) {
         result = powersOfTwoResult[power - 1] * 2;
@@ -141,10 +125,10 @@ export function generatePowersOfTwo() {
 }
 
 export function xorPolynomials(x, y) {
-    var result = [],
+    let result = [],
         idx = x.length - 2;
 
-    for (var i = idx; i >= 0; i--) {
+    for (let i = idx; i >= 0; i--) {
         result[i] = x[i] ^ y[i];
     }
 
@@ -152,10 +136,10 @@ export function xorPolynomials(x, y) {
 }
 
 export function multiplyPolynomials(x, y) {
-    var result = [];
+    let result = [];
 
-    for (var i = 0; i < x.length; i++) {
-        for (var j = 0; j < y.length; j++) {
+    for (let i = 0; i < x.length; i++) {
+        for (let j = 0; j < y.length; j++) {
             if (result[i + j] === undefined) {
                 result[i + j] = (x[i] + (y[j] >= 0 ? y[j] : 0)) % 255;
             } else {
@@ -168,10 +152,10 @@ export function multiplyPolynomials(x, y) {
 }
 
 export function generateGeneratorPolynomials() {
-    var maxErrorCorrectionCodeWordsCount = 68;
+    let maxErrorCorrectionCodeWordsCount = 68;
 
-    for (var idx = 2; idx <= maxErrorCorrectionCodeWordsCount; idx++) {
-        var firstPolynomial = generatorPolynomials[idx - 1],
+    for (let idx = 2; idx <= maxErrorCorrectionCodeWordsCount; idx++) {
+        let firstPolynomial = generatorPolynomials[idx - 1],
             secondPolynomial = [idx, 0];
 
         generatorPolynomials[idx] = multiplyPolynomials(firstPolynomial, secondPolynomial);
@@ -183,7 +167,7 @@ generatePowersOfTwo();
 generateGeneratorPolynomials();
 
 export function multiplyByConstant(polynomial, power) {
-    var result = [],
+    let result = [],
         idx = polynomial.length - 1;
 
     do {
@@ -196,7 +180,7 @@ export function multiplyByConstant(polynomial, power) {
 }
 
 export function generateErrorCodewords(data, errorCodewordsCount) {
-    var generator = generatorPolynomials[errorCodewordsCount - 1],
+    let generator = generatorPolynomials[errorCodewordsCount - 1],
         result = new Array(errorCodewordsCount).concat(data),
         generatorPolynomial = new Array(result.length - generator.length).concat(generator),
         steps = data.length,
@@ -219,7 +203,7 @@ export function generateErrorCodewords(data, errorCodewordsCount) {
 }
 
 export function getBlocks(dataStream, versionCodewordsInformation) {
-    var codewordStart = 0,
+    let codewordStart = 0,
         dataBlocks = [],
         errorBlocks = [],
         dataBlock,
@@ -229,15 +213,15 @@ export function getBlocks(dataStream, versionCodewordsInformation) {
         messagePolynomial,
         codeword;
 
-    for (var groupIdx = 0; groupIdx < versionGroups.length; groupIdx++) {
+    for (let groupIdx = 0; groupIdx < versionGroups.length; groupIdx++) {
         groupBlocksCount = versionGroups[groupIdx][0];
 
-        for (var blockIdx = 0; blockIdx < groupBlocksCount; blockIdx++) {
+        for (let blockIdx = 0; blockIdx < groupBlocksCount; blockIdx++) {
             blockCodewordsCount = versionGroups[groupIdx][1];
             dataBlock = [];
             messagePolynomial = [];
 
-            for (var codewordIdx = 1; codewordIdx <= blockCodewordsCount; codewordIdx++) {
+            for (let codewordIdx = 1; codewordIdx <= blockCodewordsCount; codewordIdx++) {
                 codeword = dataStream.substring(codewordStart, codewordStart + 8);
                 dataBlock.push(codeword);
                 messagePolynomial[blockCodewordsCount - codewordIdx] = toDecimal(codeword);
@@ -252,117 +236,9 @@ export function getBlocks(dataStream, versionCodewordsInformation) {
     return [dataBlocks, errorBlocks];
 }
 
-export function chooseMode(str, minNumericBeforeAlpha, minNumericBeforeByte, minAlphaBeforeByte, previousMode) {
-    var numeric = numberRegex.exec(str),
-        numericMatch = numeric ? numeric[0] : "",
-        alpha = alphaRegex.exec(str),
-        alphaMatch = alpha ? alpha[0] : "",
-        alphaNumeric = alphaNumericRegex.exec(str),
-        alphaNumericMatch = alphaNumeric ? alphaNumeric[0] : "",
-        mode,
-        modeString;
-
-    if (numericMatch &&
-        (numericMatch.length >= minNumericBeforeAlpha || str.length === numericMatch.length ||
-        (numericMatch.length >= minNumericBeforeByte && !alphaNumericRegex.test(str.charAt(numericMatch.length))))) {
-        mode = NUMERIC;
-        modeString = numericMatch;
-    } else if (alphaNumericMatch && (str.length === alphaNumericMatch.length ||
-        alphaNumericMatch.length >= minAlphaBeforeByte || previousMode === ALPHA_NUMERIC)) {
-        mode = ALPHA_NUMERIC;
-        modeString = numericMatch || alphaMatch;
-    } else {
-        mode = BYTE;
-
-        if (alphaNumericMatch) {
-            modeString = alphaNumericMatch + byteRegex.exec(str.substring(alphaNumericMatch.length))[0];
-        } else {
-            modeString = byteRegex.exec(str)[0];
-        }
-    }
-
-    return {
-        mode: mode,
-        modeString: modeString
-    };
-}
-
-export function getModes(inputString) {
-    var modes = [],
-        previousMode,
-        idx = 0;
-    var str = inputString;
-
-    modes.push(chooseMode(str, initMinNumericBeforeAlpha, initMinNumericBeforeByte, initMinAlphaBeforeByte, previousMode));
-    previousMode = modes[0].mode;
-    str = str.substr(modes[0].modeString.length);
-
-    while (str.length > 0) {
-        var nextMode = chooseMode(str, minNumericBeforeAlpha, minNumericBeforeByte, minAlphaBeforeByte, previousMode);
-
-        if (nextMode.mode !== previousMode) {
-            previousMode = nextMode.mode;
-            modes.push(nextMode);
-            idx++;
-        } else {
-            modes[idx].modeString += nextMode.modeString;
-        }
-
-        str = str.substr(nextMode.modeString.length);
-    }
-
-    return modes;
-}
-
-export function getDataCodewordsCount(modes) {
-    var length = 0,
-        mode;
-
-    for (var i = 0; i < modes.length; i++) {
-        mode = DataModeInstances[modes[i].mode];
-        length += mode.getStringBitsLength(modes[i].modeString.length);
-    }
-
-    return Math.ceil(length / 8);
-}
-
-export function getVersion(dataCodewordsCount, errorCorrectionLevel) {
-    var x = 0,
-        y = VersionsCodewordsInformation.length - 1,
-        version = Math.floor(VersionsCodewordsInformation.length / 2);
-
-    do {
-        if (dataCodewordsCount < VersionsCodewordsInformation[version][errorCorrectionLevel].totalDataCodewords) {
-            y = version;
-        } else {
-            x = version;
-        }
-
-        version = x + Math.floor((y - x) / 2);
-    } while (y - x > 1);
-
-    if (dataCodewordsCount <= VersionsCodewordsInformation[x][errorCorrectionLevel].totalDataCodewords) {
-        return version + 1;
-    }
-
-    return y + 1;
-}
-
-export function getDataString(modes, version) {
-    var dataString = "",
-        mode;
-
-    for (var i = 0; i < modes.length; i++) {
-        mode = DataModeInstances[modes[i].mode];
-        dataString += mode.encode(modes[i].modeString, version);
-    }
-
-    return dataString;
-}
-
 //fix case all zeros
 export function encodeFormatInformation(format) {
-    var formatNumber = toDecimal(format),
+    let formatNumber = toDecimal(format),
         encodedString,
         result = "";
 
@@ -372,7 +248,7 @@ export function encodeFormatInformation(format) {
 
     encodedString = encodeBCH(toDecimal(format), formatGeneratorPolynomial, 15);
 
-    for (var i = 0; i < encodedString.length; i++) {
+    for (let i = 0; i < encodedString.length; i++) {
         result += encodedString.charAt(i) ^ formatMaskPattern.charAt(i);
     }
 
@@ -380,7 +256,7 @@ export function encodeFormatInformation(format) {
 }
 
 export function encodeBCH(value, generatorPolynomial, codeLength) {
-    var generatorNumber = toDecimal(generatorPolynomial),
+    let generatorNumber = toDecimal(generatorPolynomial),
         polynomialLength = generatorPolynomial.length - 1,
         valueNumber = value << polynomialLength,
         length = codeLength - polynomialLength,
@@ -393,9 +269,9 @@ export function encodeBCH(value, generatorPolynomial, codeLength) {
 }
 
 export function dividePolynomials(numberX, numberY) {
-    var yLength = numberY.toString(2).length,
+    let yLength = numberY.toString(2).length,
         xLength = numberX.toString(2).length;
-    var x = numberX;
+    let x = numberX;
 
     do {
         x ^= numberY << xLength - yLength;
@@ -411,13 +287,13 @@ export function getNumberAt(str, idx) {
 }
 
 export function initMatrices(version) {
-    var matrices = [],
+    let matrices = [],
         modules = 17 + 4 * version;
 
-    for (var i = 0; i < maskPatternConditions.length; i++) {
+    for (let i = 0; i < maskPatternConditions.length; i++) {
         matrices[i] = new Array(modules);
 
-        for (var j = 0; j < modules; j++) {
+        for (let j = 0; j < modules; j++) {
             matrices[i][j] = new Array(modules);
         }
     }
@@ -426,7 +302,7 @@ export function initMatrices(version) {
 }
 
 export function addFormatInformation(matrices, formatString) {
-    var matrix = matrices[0],
+    let matrix = matrices[0],
         x,
         y,
         idx = 0,
@@ -462,7 +338,7 @@ export function encodeVersionInformation(version) {
 }
 
 export function addVersionInformation(matrices, dataString) {
-    var matrix = matrices[0],
+    let matrix = matrices[0],
         modules = matrix.length,
         x1 = 0,
         y1 = modules - 11,
@@ -472,7 +348,7 @@ export function addVersionInformation(matrices, dataString) {
         mod,
         value;
 
-    for (var idx = 0; idx < dataString.length; idx++) {
+    for (let idx = 0; idx < dataString.length; idx++) {
         quotient = Math.floor(idx / 3);
         mod = idx % 3;
         value = getNumberAt(dataString, dataString.length - idx - 1);
@@ -483,12 +359,12 @@ export function addVersionInformation(matrices, dataString) {
 }
 
 export function addCentricPattern(matrices, pattern, x, y) {
-    var size = pattern.length + 2,
+    let size = pattern.length + 2,
         length = pattern.length + 1,
         value;
 
-    for (var i = 0; i < pattern.length; i++) {
-        for (var j = i; j < size - i; j++) {
+    for (let i = 0; i < pattern.length; i++) {
+        for (let j = i; j < size - i; j++) {
             value = pattern[i];
 
             fillFunctionCell(matrices, value, x + j, y + i);
@@ -500,7 +376,7 @@ export function addCentricPattern(matrices, pattern, x, y) {
 }
 
 export function addFinderSeparator(matrices, direction, x, y) {
-    var nextX = x,
+    let nextX = x,
         nextY = y,
         matrix = matrices[0];
 
@@ -514,7 +390,7 @@ export function addFinderSeparator(matrices, direction, x, y) {
 }
 
 export function addFinderPatterns(matrices) {
-    var modules = matrices[0].length;
+    let modules = matrices[0].length;
 
     addCentricPattern(matrices, finderPattern, 0, 0);
     addFinderSeparator(matrices, [-1, -1], 7, 7);
@@ -529,7 +405,7 @@ export function addAlignmentPatterns(matrices, version) {
         return;
     }
 
-    var matrix = matrices[0],
+    let matrix = matrices[0],
         modules = matrix.length,
         pointsCount = Math.floor(version / 7),
         points = [6],
@@ -549,8 +425,8 @@ export function addAlignmentPatterns(matrices, version) {
         points.push(points[idx++] + distance);
     }
 
-    for (var i = 0; i < points.length; i++) {
-        for (var j = 0; j < points.length; j++) {
+    for (let i = 0; i < points.length; i++) {
+        for (let j = 0; j < points.length; j++) {
             if (matrix[points[i]][points[j]] === undefined) {
                 addCentricPattern(matrices, alignmentPattern, points[i] - 2, points[j] - 2);
             }
@@ -559,12 +435,12 @@ export function addAlignmentPatterns(matrices, version) {
 }
 
 export function addTimingFunctions(matrices) {
-    var row = 6,
+    let row = 6,
         column = 6,
         value = 1,
         modules = matrices[0].length;
 
-    for (var i = 8; i < modules - 8; i++) {
+    for (let i = 8; i < modules - 8; i++) {
         fillFunctionCell(matrices, value, row, i);
         fillFunctionCell(matrices, value, i, column);
         value ^= 1;
@@ -572,7 +448,7 @@ export function addTimingFunctions(matrices) {
 }
 
 export function scoreMaskMatrixes(matrices) {
-    var scores = [],
+    let scores = [],
         previousBits = [],
         darkModules = [],
         patterns = [],
@@ -591,9 +467,9 @@ export function scoreMaskMatrixes(matrices) {
         previousBits[i] = [];
     }
 
-    for (var rowIndex = 0; rowIndex < modulesLength; rowIndex++) {
-        for (var columnIndex = 0; columnIndex < modulesLength; columnIndex++) {
-            for (var matrixIndex = 0; matrixIndex < matrices.length; matrixIndex++) {
+    for (let rowIndex = 0; rowIndex < modulesLength; rowIndex++) {
+        for (let columnIndex = 0; columnIndex < modulesLength; columnIndex++) {
+            for (let matrixIndex = 0; matrixIndex < matrices.length; matrixIndex++) {
                 matrix = matrices[matrixIndex];
                 darkModules[matrixIndex] += parseInt(matrix[rowIndex][columnIndex], 10);
 
@@ -613,7 +489,7 @@ export function scoreMaskMatrixes(matrices) {
         }
     }
 
-    var total = modulesLength * modulesLength,
+    let total = modulesLength * modulesLength,
         minIdx,
         min = Number.MAX_VALUE;
 
@@ -652,7 +528,7 @@ export function scoreAdjacentSameBits(idx, scores, previousBits, bit, adjacentBi
 }
 
 export function calculateDarkModulesRatioScore(darkModules, total) {
-    var percent = Math.floor((darkModules / total) * 100),
+    let percent = Math.floor((darkModules / total) * 100),
         mod5 = percent % 5,
         previous = Math.abs(percent - mod5 - 50),
         next = Math.abs(percent + 5 - mod5 - 50),
@@ -670,7 +546,7 @@ export function createQRCodeDataEncoder(encoding) {
 }
 
 export function encodeData(inputString, errorCorrectionLevel, encoding) {
-    var encoder = createQRCodeDataEncoder(encoding),
+    let encoder = createQRCodeDataEncoder(encoding),
         encodingResult = encoder.getEncodingResult(inputString, errorCorrectionLevel),
         version = encodingResult.version,
         versionInformation = VersionsCodewordsInformation[version - 1][errorCorrectionLevel],
@@ -689,14 +565,14 @@ export function encodeData(inputString, errorCorrectionLevel, encoding) {
     addFormatInformation(matrices, toBitsString(0, 15));
     fillData(matrices, blocks);
 
-    var minIdx = scoreMaskMatrixes(matrices),
+    let minIdx = scoreMaskMatrixes(matrices),
         optimalMatrix = matrices[minIdx];
 
     if (version >= 7) {
         addVersionInformation([optimalMatrix], encodeVersionInformation(version));
     }
 
-    var formatString = errorCorrectionPatterns[errorCorrectionLevel] + toBitsString(minIdx, 3);
+    let formatString = errorCorrectionPatterns[errorCorrectionLevel] + toBitsString(minIdx, 3);
     addFormatInformation([optimalMatrix], encodeFormatInformation(formatString));
 
     return optimalMatrix;