@progress/kendo-charts 1.19.1 → 1.20.0-dev.202111121622

package/dist/es/core/logarithmic-axis.js

@@ -7,10 +7,11 @@ import createAxisTick from './utils/create-axis-tick';
 import createAxisGridLine from './utils/create-axis-grid-line';
 import limitCoordinate from './utils/limit-coordinate';
 
-import { DEFAULT_PRECISION, BLACK, X, Y } from '../common/constants';
-import { deepExtend, defined, inArray, limitValue, round, setDefaultOptions } from '../common';
+import { DEFAULT_PRECISION, BLACK } from '../common/constants';
+import { deepExtend, defined, inArray, limitValue, round, setDefaultOptions, valueOrDefault } from '../common';
 
 var DEFAULT_MAJOR_UNIT = 10;
+var MIN_VALUE_RANGE = 1e-6;
 
 var LogarithmicAxis = (function (Axis) {
     function LogarithmicAxis(seriesMin, seriesMax, options, chartService) {
@@ -59,51 +60,37 @@ var LogarithmicAxis = (function (Axis) {
         var options = ref.options;
         var logMin = ref.logMin;
         var logMax = ref.logMax;
-        var reverse = options.reverse;
-        var vertical = options.vertical;
         var base = options.majorUnit;
-        var valueAxis = vertical ? Y : X;
-        var lineBox = this.lineBox();
-        var lineStart = lineBox[valueAxis + (reverse ? 2 : 1)];
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
-        var dir = reverse ? -1 : 1;
-        var step = dir * (lineSize / (logMax - logMin));
-        var slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
-        var start = a;
-        var end = b;
-
-        if (!defined(start)) {
-            start = end || 1;
-        }
-
-        if (!defined(end)) {
-            end = start || 1;
-        }
+        var min = options.min;
+        var max = options.max;
+        var ref$1 = this.lineInfo();
+        var axis = ref$1.axis;
+        var axisDir = ref$1.axisDir;
+        var lineBox = ref$1.lineBox;
+        var lineSize = ref$1.lineSize;
+        var lineStart = ref$1.lineStart;
+        var step = axisDir * (lineSize / (logMax - logMin));
+        var start = valueOrDefault(a, b || 1);
+        var end = valueOrDefault(b, a || 1);
 
         if (start <= 0 || end <= 0) {
             return null;
         }
 
         if (limit) {
-            start = Math.max(Math.min(start, options.max), options.min);
-            end = Math.max(Math.min(end, options.max), options.min);
+            start = limitValue(start, min, max);
+            end = limitValue(end, min, max);
         }
 
         start = log(start, base);
         end = log(end, base);
 
-        var p1, p2;
-
-        if (vertical) {
-            p1 = logMax - Math.max(start, end);
-            p2 = logMax - Math.min(start, end);
-        } else {
-            p1 = Math.min(start, end) - logMin;
-            p2 = Math.max(start, end) - logMin;
-        }
+        var p1 = Math.min(start, end) - logMin;
+        var p2 = Math.max(start, end) - logMin;
 
-        slotBox[valueAxis + 1] = limitCoordinate(lineStart + step * (reverse ? p2 : p1));
-        slotBox[valueAxis + 2] = limitCoordinate(lineStart + step * (reverse ? p1 : p2));
+        var slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
+        slotBox[axis + 1] = limitCoordinate(lineStart + step * (axisDir > 0 ? p1 : p2));
+        slotBox[axis + 2] = limitCoordinate(lineStart + step * (axisDir > 0 ? p2 : p1));
 
         return slotBox;
     };
@@ -113,17 +100,14 @@ var LogarithmicAxis = (function (Axis) {
         var options = ref.options;
         var logMin = ref.logMin;
         var logMax = ref.logMax;
-        var reverse = options.reverse;
-        var vertical = options.vertical;
         var base = options.majorUnit;
-        var lineBox = this.lineBox();
-        var dir = vertical === reverse ? 1 : -1;
-        var startEdge = dir === 1 ? 1 : 2;
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
+        var ref$1 = this.lineInfo();
+        var axis = ref$1.axis;
+        var axisDir = ref$1.axisDir;
+        var lineStart = ref$1.lineStart;
+        var lineSize = ref$1.lineSize;
         var step = ((logMax - logMin) / lineSize);
-        var valueAxis = vertical ? Y : X;
-        var lineStart = lineBox[valueAxis + startEdge];
-        var offset = dir * (point[valueAxis] - lineStart);
+        var offset = axisDir * (point[axis] - lineStart);
         var valueOffset = offset * step;
 
         if (offset < 0 || offset > lineSize) {
@@ -140,16 +124,6 @@ var LogarithmicAxis = (function (Axis) {
         return { min: options.min, max: options.max };
     };
 
-    LogarithmicAxis.prototype.scaleRange = function scaleRange (delta) {
-        var base = this.options.majorUnit;
-        var offset = -delta;
-
-        return {
-            min: Math.pow(base, this.logMin - offset),
-            max: Math.pow(base, this.logMax + offset)
-        };
-    };
-
     LogarithmicAxis.prototype.translateRange = function translateRange (delta) {
         var ref = this;
         var options = ref.options;
@@ -259,7 +233,7 @@ var LogarithmicAxis = (function (Axis) {
     };
 
     LogarithmicAxis.prototype.traverseMajorTicksPositions = function traverseMajorTicksPositions (callback, tickOptions) {
-        var ref = this._lineOptions();
+        var ref = this.lineInfo();
         var lineStart = ref.lineStart;
         var step = ref.step;
         var ref$1 = this;
@@ -280,7 +254,7 @@ var LogarithmicAxis = (function (Axis) {
         var max = ref.max;
         var minorUnit = ref.minorUnit;
         var base = ref.majorUnit;
-        var ref$1 = this._lineOptions();
+        var ref$1 = this.lineInfo();
         var lineStart = ref$1.lineStart;
         var step = ref$1.step;
         var ref$2 = this;
@@ -333,24 +307,36 @@ var LogarithmicAxis = (function (Axis) {
         };
     };
 
-    LogarithmicAxis.prototype.zoomRange = function zoomRange (delta) {
+    LogarithmicAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
+        var ref = this.options;
+        var base = ref.majorUnit;
+        var logMin = log(this.options.min, base);
+        var logMax = log(this.options.max, base);
+        var position = Math.abs(this.pointOffset(cursor));
+        var delta = (logMax - logMin) * Math.min(1, scale);
+        var min = Math.pow(base, logMin + position * delta);
+        var max = Math.pow(base, logMax - (1 - position) * delta);
+
+        if (max - min < MIN_VALUE_RANGE) {
+            max = min + MIN_VALUE_RANGE;
+        }
+
+        return {
+            min: min,
+            max: max
+        };
+    };
+
+    LogarithmicAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
+        var range = this.scaleRange(scale, cursor);
         var ref = this;
-        var options = ref.options;
         var totalMin = ref.totalMin;
         var totalMax = ref.totalMax;
-        var newRange = this.scaleRange(delta);
-        var min = limitValue(newRange.min, totalMin, totalMax);
-        var max = limitValue(newRange.max, totalMin, totalMax);
-        var base = options.majorUnit;
-        var acceptOptionsRange = max > min && options.min && options.max && (round(log(options.max, base) - log(options.min, base), DEFAULT_PRECISION) < 1);
-        var acceptNewRange = !(options.min === totalMin && options.max === totalMax) && round(log(max, base) - log(min, base), DEFAULT_PRECISION) >= 1;
-
-        if (acceptOptionsRange || acceptNewRange) {
-            return {
-                min: min,
-                max: max
-            };
-        }
+
+        return {
+            min: limitValue(range.min, totalMin, totalMax),
+            max: limitValue(range.max, totalMin, totalMax)
+        };
     };
 
     LogarithmicAxis.prototype._minorIntervalOptions = function _minorIntervalOptions (power) {
@@ -368,23 +354,11 @@ var LogarithmicAxis = (function (Axis) {
         };
     };
 
-    LogarithmicAxis.prototype._lineOptions = function _lineOptions () {
-        var ref = this.options;
-        var reverse = ref.reverse;
-        var vertical = ref.vertical;
-        var valueAxis = vertical ? Y : X;
-        var lineBox = this.lineBox();
-        var dir = vertical === reverse ? 1 : -1;
-        var startEdge = dir === 1 ? 1 : 2;
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
-        var step = dir * (lineSize / (this.logMax - this.logMin));
-        var lineStart = lineBox[valueAxis + startEdge];
+    LogarithmicAxis.prototype.lineInfo = function lineInfo () {
+        var info = Axis.prototype.lineInfo.call(this);
+        info.step = info.axisDir * (info.lineSize / (this.logMax - this.logMin));
 
-        return {
-            step: step,
-            lineStart: lineStart,
-            lineBox: lineBox
-        };
+        return info;
     };
 
     return LogarithmicAxis;
@@ -445,8 +419,8 @@ function throwNegativeValuesError() {
     throw new Error("Non positive values cannot be used for a logarithmic axis");
 }
 
-function log(y, x) {
-    return Math.log(y) / Math.log(x);
+function log(x, base) {
+    return Math.log(x) / Math.log(base);
 }
 
 setDefaultOptions(LogarithmicAxis, {

package/dist/es/core/numeric-axis.js

@@ -3,8 +3,8 @@ import Axis from './axis';
 import AxisLabel from './axis-label';
 import Box from './box';
 
-import { BLACK, DEFAULT_PRECISION, COORD_PRECISION, X, Y } from '../common/constants';
-import { deepExtend, defined, limitValue, round, setDefaultOptions } from '../common';
+import { BLACK, DEFAULT_PRECISION, COORD_PRECISION } from '../common/constants';
+import { deepExtend, defined, limitValue, round, setDefaultOptions, valueOrDefault } from '../common';
 
 import autoMajorUnit from './utils/auto-major-unit';
 import autoAxisMin from './utils/auto-axis-min';
@@ -73,18 +73,17 @@ var NumericAxis = (function (Axis) {
 
     NumericAxis.prototype.getTickPositions = function getTickPositions (unit, skipUnit) {
         var options = this.options;
-        var vertical = options.vertical;
-        var reverse = options.reverse;
-        var lineBox = this.lineBox();
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
+        var ref = this.lineInfo();
+        var axisDir = ref.axisDir;
+        var axisOrigin = ref.axisOrigin;
+        var lineBox = ref.lineBox;
+        var lineSize = ref.lineSize;
         var range = options.max - options.min;
         var scale = lineSize / range;
         var step = unit * scale;
         var divisions = this.getDivisions(unit);
-        var dir = (vertical ? -1 : 1) * (reverse ? -1 : 1);
-        var startEdge = dir === 1 ? 1 : 2;
         var positions = [];
-        var pos = lineBox[(vertical ? Y : X) + startEdge];
+        var pos = lineBox[axisOrigin];
         var skipStep = 0;
 
         if (skipUnit) {
@@ -96,7 +95,7 @@ var NumericAxis = (function (Axis) {
                 positions.push(round(pos, COORD_PRECISION));
             }
 
-            pos = pos + step * dir;
+            pos = pos + step * axisDir;
         }
 
         return positions;
@@ -114,71 +113,44 @@ var NumericAxis = (function (Axis) {
         if ( limit === void 0 ) limit = false;
 
         var options = this.options;
-        var vertical = options.vertical;
-        var reverse = options.reverse;
-        var valueAxis = vertical ? Y : X;
-        var lineBox = this.lineBox();
-        var lineStart = lineBox[valueAxis + (reverse ? 2 : 1)];
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
-        var dir = reverse ? -1 : 1;
-        var step = dir * (lineSize / (options.max - options.min));
-        var slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
+        var ref = this.lineInfo();
+        var axis = ref.axis;
+        var axisDir = ref.axisDir;
+        var lineBox = ref.lineBox;
+        var lineSize = ref.lineSize;
+        var lineStart = ref.lineStart;
+        var step = axisDir * (lineSize / (options.max - options.min));
 
-        var start = a;
-        var end = b;
-
-        if (!defined(start)) {
-            start = end || 0;
-        }
-
-        if (!defined(end)) {
-            end = start || 0;
-        }
+        var start = valueOrDefault(a, b || 0);
+        var end = valueOrDefault(b, a || 0);
 
         if (limit) {
-            start = Math.max(Math.min(start, options.max), options.min);
-            end = Math.max(Math.min(end, options.max), options.min);
+            start = limitValue(start, options.min, options.max);
+            end = limitValue(end, options.min, options.max);
         }
 
-        var p1, p2;
+        var p1 = Math.min(start, end) - options.min;
+        var p2 = Math.max(start, end) - options.min;
 
-        if (vertical) {
-            p1 = options.max - Math.max(start, end);
-            p2 = options.max - Math.min(start, end);
-        } else {
-            p1 = Math.min(start, end) - options.min;
-            p2 = Math.max(start, end) - options.min;
-        }
-
-        slotBox[valueAxis + 1] = limitCoordinate(lineStart + step * (reverse ? p2 : p1));
-        slotBox[valueAxis + 2] = limitCoordinate(lineStart + step * (reverse ? p1 : p2));
+        var slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
+        slotBox[axis + 1] = limitCoordinate(lineStart + step * (axisDir > 0 ? p1 : p2));
+        slotBox[axis + 2] = limitCoordinate(lineStart + step * (axisDir > 0 ? p2 : p1));
 
         return slotBox;
     };
 
     NumericAxis.prototype.getValue = function getValue (point) {
         var options = this.options;
-        var vertical = options.vertical;
-        var reverse = options.reverse;
         var max = Number(options.max);
         var min = Number(options.min);
-        var valueAxis = vertical ? Y : X;
-        var lineBox = this.lineBox();
-        var lineStart = lineBox[valueAxis + (reverse ? 2 : 1)];
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
-        var dir = reverse ? -1 : 1;
-        var offset = dir * (point[valueAxis] - lineStart);
-        var step = (max - min) / lineSize;
-        var valueOffset = offset * step;
-
-        if (offset < 0 || offset > lineSize) {
+        var offset = this.pointOffset(point);
+        var valueOffset = offset * (max - min);
+
+        if (offset < 0 || offset > 1) {
             return null;
         }
 
-        var value = vertical ?
-                max - valueOffset :
-                min + valueOffset;
-
+        var value = min + valueOffset;
         return round(value, DEFAULT_PRECISION);
     };
 
@@ -188,10 +160,10 @@ var NumericAxis = (function (Axis) {
         var reverse = options.reverse;
         var max = options.max;
         var min = options.min;
-        var lineBox = this.lineBox();
-        var size = vertical ? lineBox.height() : lineBox.width();
+        var ref = this.lineInfo();
+        var lineSize = ref.lineSize;
         var range = max - min;
-        var scale = size / range;
+        var scale = lineSize / range;
         var offset = round(delta / scale, DEFAULT_PRECISION);
 
         if ((vertical || reverse) && !(vertical && reverse )) {
@@ -205,16 +177,6 @@ var NumericAxis = (function (Axis) {
         };
     };
 
-    NumericAxis.prototype.scaleRange = function scaleRange (delta) {
-        var options = this.options;
-        var offset = -delta * options.majorUnit;
-
-        return {
-            min: options.min - offset,
-            max: options.max + offset
-        };
-    };
-
     NumericAxis.prototype.labelsCount = function labelsCount () {
         return this.getDivisions(this.options.majorUnit);
     };
@@ -251,20 +213,34 @@ var NumericAxis = (function (Axis) {
         }
     };
 
-    NumericAxis.prototype.zoomRange = function zoomRange (delta) {
+    NumericAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
+        var position = Math.abs(this.pointOffset(cursor));
+        var delta = (this.options.max - this.options.min) * Math.min(1, scale);
+        var minDelta = position * delta;
+        var maxDelta = (1 - position) * delta;
+        var min = this.options.min + minDelta;
+        var max = this.options.max - maxDelta;
+
+        if (max - min < MIN_VALUE_RANGE) {
+            max = min + MIN_VALUE_RANGE;
+        }
+
+        return {
+            min: min,
+            max: max
+        };
+    };
+
+    NumericAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
         var ref = this;
         var totalMin = ref.totalMin;
         var totalMax = ref.totalMax;
-        var newRange = this.scaleRange(delta);
-        var min = limitValue(newRange.min, totalMin, totalMax);
-        var max = limitValue(newRange.max, totalMin, totalMax);
+        var range = this.scaleRange(scale, cursor);
 
-        if (this.isValidRange(min, max)) {
-            return {
-                min: min,
-                max: max
-            };
-        }
+        return {
+            min: limitValue(range.min, totalMin, totalMax),
+            max: limitValue(range.max, totalMin, totalMax)
+        };
     };
 
     NumericAxis.prototype.isValidRange = function isValidRange (min, max) {

package/dist/es/main.js

@@ -5,6 +5,7 @@ export * from './sparkline';
 export * from './stock';
 export * from './gauges';
 export * from './barcode';
+export * from './qrcode';
 export * from './common';
 
 export { baseTheme as chartBaseTheme } from './chart/base-theme';

package/dist/es/qrcode/encodings/data-modes/alpha-numeric-data-mode.js

@@ -0,0 +1,103 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString,
+    splitInto
+} from '../../utils';
+
+export var AlphaNumericQRDataMode = (function (QRDataMode) {
+    function AlphaNumericQRDataMode () {
+        QRDataMode.apply(this, arguments);
+    }
+
+    if ( QRDataMode ) AlphaNumericQRDataMode.__proto__ = QRDataMode;
+    AlphaNumericQRDataMode.prototype = Object.create( QRDataMode && QRDataMode.prototype );
+    AlphaNumericQRDataMode.prototype.constructor = AlphaNumericQRDataMode;
+
+    AlphaNumericQRDataMode.prototype.initProperties = function initProperties () {
+        QRDataMode.prototype.initProperties.call(this);
+
+        extend(this, {
+            characters: {
+                "0": 0,
+                "1": 1,
+                "2": 2,
+                "3": 3,
+                "4": 4,
+                "5": 5,
+                "6": 6,
+                "7": 7,
+                "8": 8,
+                "9": 9,
+                "A": 10,
+                "B": 11,
+                "C": 12,
+                "D": 13,
+                "E": 14,
+                "F": 15,
+                "G": 16,
+                "H": 17,
+                "I": 18,
+                "J": 19,
+                "K": 20,
+                "L": 21,
+                "M": 22,
+                "N": 23,
+                "O": 24,
+                "P": 25,
+                "Q": 26,
+                "R": 27,
+                "S": 28,
+                "T": 29,
+                "U": 30,
+                "V": 31,
+                "W": 32,
+                "X": 33,
+                "Y": 34,
+                "Z": 35,
+                " ": 36,
+                "$": 37,
+                "%": 38,
+                "*": 39,
+                "+": 40,
+                "-": 41,
+                ".": 42,
+                "/": 43,
+                ":": 44
+            },
+            bitsInCharacterCount: [9, 11, 13],
+            modeIndicator: "0010"
+        });
+    };
+
+    AlphaNumericQRDataMode.prototype.getValue = function getValue (character) {
+        return this.characters[character];
+    };
+
+    AlphaNumericQRDataMode.prototype.encode = function encode (str, version) {
+        var this$1 = this;
+
+        var
+            parts = splitInto(str, 2),
+            result = this.getModeCountString(str.length, version),
+            value;
+        var i;
+
+        for (i = 0; i < parts.length - 1; i++) {
+            value = 45 * this$1.getValue(parts[i].charAt(0)) + this$1.getValue(parts[i].charAt(1));
+            result += toBitsString(value, 11);
+        }
+
+        value = parts[i].length === 2 ?
+            45 * this.getValue(parts[i].charAt(0)) + this.getValue(parts[i].charAt(1)) :
+            this.getValue(parts[i].charAt(0));
+
+        return result + toBitsString(value, 1 + 5 * parts[i].length);
+    };
+
+    AlphaNumericQRDataMode.prototype.getStringBitsLength = function getStringBitsLength (inputLength, version) {
+        return 4 + this.getBitsCharacterCount(version) + 11 * Math.floor(inputLength / 2) + 6 * (inputLength % 2);
+    };
+
+    return AlphaNumericQRDataMode;
+}(QRDataMode));

package/dist/es/qrcode/encodings/data-modes/byte-data-mode.js

@@ -0,0 +1,51 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString
+} from '../../utils';
+
+export var ByteQRDataMode = (function (QRDataMode) {
+    function ByteQRDataMode () {
+        QRDataMode.apply(this, arguments);
+    }
+
+    if ( QRDataMode ) ByteQRDataMode.__proto__ = QRDataMode;
+    ByteQRDataMode.prototype = Object.create( QRDataMode && QRDataMode.prototype );
+    ByteQRDataMode.prototype.constructor = ByteQRDataMode;
+
+    ByteQRDataMode.prototype.initProperties = function initProperties () {
+        QRDataMode.prototype.initProperties.call(this);
+
+        extend(this, {
+            bitsInCharacterCount: [8, 16, 16],
+            modeIndicator: "0100"
+        });
+    };
+
+    ByteQRDataMode.prototype.getValue = function getValue (character) {
+        var code = character.charCodeAt(0);
+
+        if (code <= 127 || (160 <= code && code <= 255)) {
+            return code;
+        }
+
+        throw new Error("Unsupported character: " + character);
+    };
+
+    ByteQRDataMode.prototype.encode = function encode (str, version) {
+        var mode = this,
+            result = mode.getModeCountString(str.length, version);
+
+        for (var i = 0; i < str.length; i++) {
+            result += toBitsString(mode.getValue(str.charAt(i)), 8);
+        }
+
+        return result;
+    };
+
+    ByteQRDataMode.prototype.getStringBitsLength = function getStringBitsLength (inputLength, version) {
+        return 4 + this.getBitsCharacterCount(version) + 8 * inputLength;
+    };
+
+    return ByteQRDataMode;
+}(QRDataMode));

package/dist/es/qrcode/encodings/data-modes/data-mode-instances.js

@@ -0,0 +1,12 @@
+import { NumericQRDataMode } from './numeric-data-mode';
+import { AlphaNumericQRDataMode } from './alpha-numeric-data-mode';
+import { ByteQRDataMode } from './byte-data-mode';
+
+var NUMERIC = "numeric";
+var ALPHA_NUMERIC = "alphanumeric";
+var BYTE = "byte";
+
+export var DataModeInstances = {};
+DataModeInstances[NUMERIC] = new NumericQRDataMode();
+DataModeInstances[ALPHA_NUMERIC] = new AlphaNumericQRDataMode();
+DataModeInstances[BYTE] = new ByteQRDataMode();

package/dist/es/qrcode/encodings/data-modes/numeric-data-mode.js

@@ -0,0 +1,49 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString,
+    splitInto
+} from '../../utils';
+
+export var NumericQRDataMode = (function (QRDataMode) {
+    function NumericQRDataMode () {
+        QRDataMode.apply(this, arguments);
+    }
+
+    if ( QRDataMode ) NumericQRDataMode.__proto__ = QRDataMode;
+    NumericQRDataMode.prototype = Object.create( QRDataMode && QRDataMode.prototype );
+    NumericQRDataMode.prototype.constructor = NumericQRDataMode;
+
+    NumericQRDataMode.prototype.initProperties = function initProperties () {
+        QRDataMode.prototype.initProperties.call(this);
+
+        extend(this, {
+            bitsInCharacterCount: [10, 12, 14],
+            modeIndicator: "0001"
+        });
+    };
+
+    NumericQRDataMode.prototype.getValue = function getValue (character) {
+        return parseInt(character, 10);
+    };
+
+    NumericQRDataMode.prototype.encode = function encode (str, version) {
+        var mode = this,
+            parts = splitInto(str, 3),
+            result = mode.getModeCountString(str.length, version);
+        var i;
+
+        for (i = 0; i < parts.length - 1; i++) {
+            result += toBitsString(parts[i], 10);
+        }
+
+        return result + toBitsString(parts[i], 1 + 3 * parts[i].length);
+    };
+
+    NumericQRDataMode.prototype.getStringBitsLength = function getStringBitsLength (inputLength, version) {
+        var mod3 = inputLength % 3;
+        return 4 + this.getBitsCharacterCount(version) + 10 * Math.floor(inputLength / 3) + 3 * mod3 + (mod3 === 0 ? 0 : 1);
+    };
+
+    return NumericQRDataMode;
+}(QRDataMode));