smartxtrader 3.8.1-xm.0

package/packages/webtrader-charts/src/indicators/smma.js

@@ -0,0 +1,81 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 1/30/16.
+ */
+
+var SMMA = function (data, options, indicators) {
+    IndicatorBase.call(this, data, options, indicators);
+    this.priceData = [];
+    this.CalculateSMMAValue = function (data, index) {
+        /* SMMA :
+         //PREVSUM = SMMA(i - 1) * N
+         //SMMA(i) = (PREVSUM - SMMA(i - 1) + CLOSE(i)) / N
+         //SUM1 — is the total sum of closing prices for N periods;
+         //PREVSUM — is the smoothed sum of the previous bar;
+         //SMMA1 — is the smoothed moving average of the first bar;
+         //SMMA(i) — is the smoothed moving average of the current bar (except for the first one);
+         //CLOSE(i) — is the current closing price;
+         //N — is the smoothing period.*/
+        var preSma = this.indicatorData[index - 1].value || 0;
+        var preSum = preSma * this.options.period;
+        var smmaValue = (preSum - preSma + this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo)) / this.options.period;
+        return toFixed(smmaValue, 4);
+    };
+    for (var index = 0; index < data.length; index++) {
+        if (index > (this.options.period - 1)) {
+            var smma = this.CalculateSMMAValue( data, index);
+            this.indicatorData.push({ time: data[index].time, value: smma });
+        }
+        else if (index === this.options.period - 1) {
+            var sum = 0.0;
+            for (var i = 0; i < this.options.period; i++) {
+                sum += this.indicators.getIndicatorOrPriceValue(data[i], this.options.appliedTo);
+            }
+            var smma = toFixed(sum / this.options.period , 4);
+            this.indicatorData.push({ time: data[index].time, value: smma });
+        }
+        else {
+            this.indicatorData.push({ time: data[index].time, value: 0.0 });
+        }
+        this.priceData.push(data[index]);
+    }
+    /* hide entries that are 0 */
+    this.indicatorData.forEach(function(entry) {
+      if(entry.value === 0) {
+        entry.value = null;
+      }
+    });
+};
+
+SMMA.prototype = Object.create(IndicatorBase.prototype);
+SMMA.prototype.constructor = SMMA;
+
+SMMA.prototype.addPoint = function (data) {
+    this.priceData.push(data);
+    var smma = this.CalculateSMMAValue(this.priceData, this.priceData.length - 1);
+    this.indicatorData.push({ time: data.time, value: smma });
+    return [{
+        id: this.uniqueID,
+        value: smma
+    }];
+};
+
+SMMA.prototype.update = function (data) {
+    var index = this.priceData.length - 1;
+    this.priceData[index].open = data.open;
+    this.priceData[index].high = data.high;
+    this.priceData[index].low = data.low;
+    this.priceData[index].close = data.close;
+    var smma = this.CalculateSMMAValue(this.priceData, index);
+    this.indicatorData[index].value = smma;
+    return [{
+        id: this.uniqueID,
+        value: smma
+    }];
+};
+
+SMMA.prototype.toString = function () {
+    return 'SMMA (' + this.options.period + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.SMMA = SMMA;

package/packages/webtrader-charts/src/indicators/stoch.js

@@ -0,0 +1,169 @@
+import {uuid, toFixed} from '../common/utils.js';
+import _ from 'lodash';
+/**
+ * Created by Mahboob.M on 2/8/16.
+ */
+var STOCH = function(data, options, indicators) {
+
+    options.fastDMaType = (options.fastDMaType || 'SMA').toUpperCase();
+    IndicatorBase.call(this, data, options, indicators);
+    this.priceData = [];
+    //2 unique IDs for 2 series to be rendered
+    this.uniqueID = [uuid(), uuid()];
+
+    this.calculateStochValue = function (data, index) {
+      /*
+      %K = (Current Close - Lowest Low)/(Highest High - Lowest Low) * 100
+      %D = 3-day SMA of %K
+      Lowest Low = lowest low for the look-back period
+      Highest High = highest high for the look-back period
+      %K is multiplied by 100 to move the decimal point two places
+      */
+        var lowestLow = data[index].low, hiestHigh = data[index].high;
+        for (var i = 0; i < this.options.fastKPeriod; i++) {
+            lowestLow = Math.min(data[index - i].low, lowestLow);
+            hiestHigh = Math.max(data[index - i].high, hiestHigh);
+        };
+        var kValue = 0;
+        if (hiestHigh - lowestLow !== 0) {
+            kValue = ((this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo) - lowestLow) / (hiestHigh - lowestLow)) * 100;
+        };
+
+        return toFixed(kValue, 4);
+    };
+   
+    for (var index = 0; index < data.length; index++) {
+        if (index >= this.options.fastKPeriod) {
+            var kValue = this.calculateStochValue(data, index);
+            this.indicatorData.push({ time: data[index].time, value: kValue, close: kValue });
+        }
+        else {
+            this.indicatorData.push({ time: data[index].time, value: 0, close: 0 });
+        }
+
+        this.priceData.push(data[index]);
+    };
+
+    this.dData = new window[options.fastDMaType](this.indicatorData, { period: this.options.fastDPeriod, maType: this.options.fastDMaType }, indicators);
+
+};
+
+STOCH.prototype = Object.create(IndicatorBase.prototype);
+STOCH.prototype.constructor = STOCH;
+
+STOCH.prototype.addPoint = function (data) {
+    this.priceData.push(data);
+    var index = this.priceData.length - 1;
+    var kValue = this.calculateStochValue(this.priceData, index);
+    var dValue = this.dData.addPoint({ time: data.time, close: kValue })[0].value;
+    this.indicatorData.push({ time: data.time, value: kValue });
+    return [{
+        id: this.uniqueID[0],
+        value: kValue
+    }, {
+        id: this.uniqueID[1],
+        value: dValue
+    }];
+};
+
+STOCH.prototype.update = function (data) {
+    var index = this.priceData.length - 1;
+    this.priceData[index].open = data.open;
+    this.priceData[index].high = data.high;
+    this.priceData[index].low = data.low;
+    this.priceData[index].close = data.close;
+    var kValue = this.calculateStochValue(this.priceData, index);
+    var dValue = this.dData.update({ time: data.time, close: kValue })[0].value;
+    this.indicatorData[index].value = kValue;
+    return [{
+        id: this.uniqueID[0],
+        value: kValue
+    }, {
+        id: this.uniqueID[1],
+        value: dValue
+    }];
+};
+
+STOCH.prototype.toString = function() {
+    return 'STOCH (' + this.options.fastKPeriod  + ', ' + this.options.fastDPeriod  + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+/**
+ * @param indicatorMetadata
+ * @returns {*[]}
+ */
+STOCH.prototype.buildSeriesAndAxisConfFromData = function(indicatorMetadata) {
+    //Prepare the data before sending a configuration
+    var stochData = [];
+    this.indicatorData.forEach(function (e) {
+        stochData.push([e.time, e.value]);
+    });
+    var dData = [];
+    this.dData.indicatorData.forEach(function (e) {
+        dData.push([e.time, e.value]);
+    });
+
+    return [{
+        axisConf: { // Secondary yAxis
+            id: indicatorMetadata.id + '-' + this.uniqueID[0],
+            title: {
+                text: this.toString(),
+                align: 'high',
+                offset: 0,
+                rotation: 0,
+                y: 10,
+                x: 30 + this.toString().length * 7.5
+            },
+            lineWidth: 2,
+            plotLines: this.options.levels
+          }
+        },
+        {
+             seriesConf: {
+                 id: this.uniqueID[0],
+                 name: this.toString(),
+                 data: stochData,
+                 type: 'line',
+                 yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                 color: this.options.stroke,
+                 lineWidth: this.options.strokeWidth,
+                 dashStyle: this.options.dashStyle,
+                 onChartIndicator: false
+             }
+         },
+        {
+            seriesConf: {
+                id: this.uniqueID[1],
+                name: '%D',
+                data: dData,
+                type: 'line',
+                yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                color: this.options.dStroke,
+                lineWidth: this.options.strokeWidth,
+                dashStyle: this.options.dashStyle,
+                onChartIndicator: false
+            }
+        }
+    ];
+};
+
+/**
+ * This method will return all IDs that are used to identify data series configuration
+ * in the buildSeriesAndAxisConfFromData method.
+ * @returns {*[]}
+ */
+STOCH.prototype.getIDs = function() {
+    return this.uniqueID;
+};
+
+/**
+ * If all the unique IDs generated by this instance is same as what is passed in the parameter,
+ * then we consider this instance to be same as what caller is looking for
+ * @param uniqueIDArr
+ * @returns {boolean}
+ */
+STOCH.prototype.isSameInstance = function(uniqueIDArr) {
+    return _.isEqual(uniqueIDArr.sort(), this.uniqueID);
+};
+
+window.STOCH = STOCH;

package/packages/webtrader-charts/src/indicators/stochf.js

@@ -0,0 +1,140 @@
+import {uuid, toFixed} from '../common/utils.js';
+import _ from 'lodash';
+/*
+ * Created by Mahboob.M on 2/8/16.
+ */
+
+var STOCHF = function (data, options, indicators) {
+    options.fastKMaType = (options.fastKMaType || 'SMA').toUpperCase();
+    options.fastDMaType = (options.fastDMaType || 'SMA').toUpperCase();
+    IndicatorBase.call(this, data, options, indicators);
+    this.uniqueID = [uuid(), uuid()];
+    /*Fast %K = 100 SMA ( ( ( Close - Low ) / (High - Low ) ),Time Period )
+    Fast %D: Simple moving average of Fast K (usually 3-period moving average)
+    */
+    this.stoch = new STOCH(data, { fastKPeriod: this.options.fastKPeriod,fastDPeriod: this.options.fastDPeriod, appliedTo: this.options.appliedTo }, indicators);
+    this.kMa = new window[this.options.fastKMaType](this.stoch.indicatorData, { period: this.options.fastKPeriod, maType: this.options.fastKMaType }, indicators);
+    this.indicatorData = this.kMa.indicatorData;
+    this.kData = [];
+    var _this = this;
+    this.indicatorData.forEach(function (e) {
+        _this.kData.push({ time: e.time, close: e.value });
+    });
+    this.dData = new window[options.fastDMaType](this.kData, { period: this.options.fastDPeriod, maType: this.options.fastDMaType }, indicators);
+};
+
+STOCHF.prototype = Object.create(IndicatorBase.prototype);
+STOCHF.prototype.constructor = STOCHF;
+
+STOCHF.prototype.addPoint = function (data) {
+    var stoch = this.stoch.addPoint(data)[0].value;
+    var kMa = this.kMa.addPoint({time:data.time , close:stoch})[0].value;
+    this.indicatorData = this.kMa.indicatorData;
+    var dValue = this.dData.addPoint({time:data.time , close:kMa})[0].value;
+    return [{
+        id: this.uniqueID[0],
+        value: kMa
+    }, {
+        id: this.uniqueID[1],
+        value: dValue
+    }];
+};
+
+STOCHF.prototype.update = function (data) {
+    var stoch = this.stoch.update(data)[0].value;
+    var kMa = this.kMa.update({time:data.time , close:stoch})[0].value;
+    this.indicatorData = this.kMa.indicatorData;
+    var dValue =this.dData.update({time:data.time , close:kMa})[0].value;
+    return [{
+        id: this.uniqueID[0],
+        value: kMa
+    }, {
+        id: this.uniqueID[1],
+        value: dValue
+    }];
+};
+
+STOCHF.prototype.toString = function () {
+    return  'STOCHF (' + this.options.fastKPeriod + ', '+ this.options.fastDPeriod + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+/**
+ * @param indicatorMetadata
+ * @returns {*[]}
+ */
+STOCHF.prototype.buildSeriesAndAxisConfFromData = function(indicatorMetadata) {
+    //Prepare the data before sending a configuration
+    var sochfData = [];
+    this.indicatorData.forEach(function (e) {
+        sochfData.push([e.time, e.value]);
+    });
+    var dData = [];
+    this.dData.indicatorData.forEach(function (e) {
+        dData.push([e.time, e.value]);
+    });
+
+    return [{
+        axisConf: { // Secondary yAxis
+            id: indicatorMetadata.id + '-' + this.uniqueID[0],
+            title: {
+                text: this.toString(),
+                align: 'high',
+                offset: 0,
+                rotation: 0,
+                y: 10,
+                x: 30+ this.toString().length * 7.5
+            },
+            lineWidth: 2,
+            plotLines: this.options.levels
+          }
+        },
+        {
+             seriesConf: {
+                 id: this.uniqueID[0],
+                 name: this.toString(),
+                 data: sochfData,
+                 type: 'line',
+                 yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                 color: this.options.stroke,
+                 lineWidth: this.options.strokeWidth,
+                 dashStyle: this.options.dashStyle,
+                 onChartIndicator: false
+             }
+         },
+        {
+            seriesConf: {
+                id: this.uniqueID[1],
+                name: '%D',
+                data: dData,
+                type: 'line',
+                yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                color: this.options.dStroke,
+                lineWidth: this.options.strokeWidth,
+                dashStyle: this.options.dashStyle,
+                onChartIndicator: false
+            }
+        }
+    ];
+};
+
+/**
+ * This method will return all IDs that are used to identify data series configuration
+ * in the buildSeriesAndAxisConfFromData method.
+ * @returns {*[]}
+ */
+STOCHF.prototype.getIDs = function() {
+    return this.uniqueID;
+};
+
+/**
+ * If all the unique IDs generated by this instance is same as what is passed in the parameter,
+ * then we consider this instance to be same as what caller is looking for
+ * @param uniqueIDArr
+ * @returns {boolean}
+ */
+STOCHF.prototype.isSameInstance = function(uniqueIDArr) {
+    return _.isEqual(uniqueIDArr.sort(), this.uniqueID);
+};
+
+
+window.STOCHF = STOCHF;

package/packages/webtrader-charts/src/indicators/stochrsi.js

@@ -0,0 +1,70 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 1/29/16.
+ */
+
+var STOCHRSI = function (data, options, indicators) {
+    IndicatorBase.call(this, data, options, indicators);
+    this.rsi = new window['RSI'](data, options, indicators);
+    this.CalculateSTOCHRSIValue = function (index) {
+        /*
+         * Formula -
+         * rs(t) = avg-gain(n) / avg-loss(n)
+         * rsi(t) = if avg-loss(n) == 0 ? 100 : 100 - (100/ (1+rs(t))
+         * StochRSI = (RSI - Lowest Low RSI) / (Highest High RSI - Lowest Low RSI)
+         * t - current
+         * n - period
+         */
+        var highestHigh = this.rsi.indicatorData[index].value;
+        var lowestLow = this.rsi.indicatorData[index].value;
+        for (var i = 0; i < this.options.period; i++) {
+            highestHigh = Math.max(highestHigh, this.rsi.indicatorData[index - i].value);
+            lowestLow = Math.min(lowestLow, this.rsi.indicatorData[index - i].value);
+        }
+        var stochrsi = 0;
+        if ((highestHigh - lowestLow) !== 0) { stochrsi = (this.rsi.indicatorData[index].value - lowestLow) / (highestHigh - lowestLow) };
+
+        return toFixed(stochrsi, 4);
+    };
+
+    for (var index = 0; index < data.length; index++) {
+        if (index >= this.options.period) {
+            var stochrsi = this.CalculateSTOCHRSIValue(index);
+            this.indicatorData.push({ time: data[index].time, value: stochrsi });
+        } else {
+            this.indicatorData.push({ time: data[index].time, value: 0.0 });
+        }
+    }
+};
+
+
+STOCHRSI.prototype = Object.create(IndicatorBase.prototype);
+STOCHRSI.prototype.constructor = STOCHRSI;
+
+STOCHRSI.prototype.addPoint = function (data) {
+    this.rsi.addPoint(data);
+    var stochrsi = this.CalculateSTOCHRSIValue(this.indicatorData.length - 1);
+    this.indicatorData.push({ time: data.time, value: stochrsi });
+    return [{
+        id: this.uniqueID,
+        value: stochrsi
+    }];
+};
+
+STOCHRSI.prototype.update = function (data) {
+    var index = this.indicatorData.length - 1;
+    this.rsi.update(data);
+    var stochrsi = this.CalculateSTOCHRSIValue(index);
+    this.indicatorData[index].value = stochrsi;
+    return [{
+        id: this.uniqueID,
+        value: stochrsi
+    }];
+};
+
+STOCHRSI.prototype.toString = function () {
+    return ' STOCHRSI (' + this.options.period + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.STOCHRSI = STOCHRSI;
+

package/packages/webtrader-charts/src/indicators/stochs.js

@@ -0,0 +1,141 @@
+import {uuid, toFixed} from '../common/utils.js';
+import _ from 'lodash';
+/*
+ * Created by Mahboob.M on 2/8/16.
+ */
+
+var STOCHS = function (data, options, indicators) {
+    options.fastKMaType = (options.fastKMaType || 'SMA').toUpperCase();
+    options.slowKMaType = (options.slowKMaType || 'SMA').toUpperCase();
+    options.slowDMaType = (options.slowDMaType || 'SMA').toUpperCase();
+    IndicatorBase.call(this, data, options, indicators);
+    this.uniqueID = [uuid(), uuid()];
+
+    /*Fast %K = 100 SMA ( ( ( Close - Low ) / (High - Low ) ),Time Period )
+    Fast %D: Simple moving average of Fast K (usually 3-period moving average)
+    */
+    this.stochf = new STOCHF(data, { fastKPeriod: this.options.fastKPeriod, fastKMaType: this.options.fastKMaType, appliedTo: this.options.appliedTo }, indicators);
+    this.kMa = new window[this.options.slowKMaType](this.stochf.kData, { period: this.options.slowKPeriod, maType: this.options.slowKMaType }, indicators);
+    this.indicatorData = this.kMa.indicatorData;
+    var kData = [];
+    this.indicatorData.forEach(function (e) {
+        kData.push({ time: e.time, close: e.value });
+    });
+    this.dData = new window[options.slowDMaType](kData, { period: this.options.slowDPeriod, maType: this.options.slowDMaType }, indicators);
+};
+
+STOCHS.prototype = Object.create(IndicatorBase.prototype);
+STOCHS.prototype.constructor = STOCHS;
+
+STOCHS.prototype.addPoint = function (data) {
+    var stoch = this.stochf.addPoint(data)[0].value;
+    var kMa = this.kMa.addPoint({time:data.time , close:stoch})[0].value;
+    this.indicatorData = this.kMa.indicatorData;
+    var dValue = this.dData.addPoint({time:data.time , close:kMa})[0].value;
+    return [{
+        id: this.uniqueID[0],
+        value: kMa
+    }, {
+        id: this.uniqueID[1],
+        value: dValue
+    }];
+};
+
+STOCHS.prototype.update = function (data) {
+    var stoch = this.stochf.update(data)[0].value;
+    var kMa = this.kMa.update({time:data.time , close:stoch})[0].value;
+    this.indicatorData = this.kMa.indicatorData;
+    var dValue =this.dData.update({time:data.time , close:kMa})[0].value;
+    return [{
+        id: this.uniqueID[0],
+        value: kMa
+    }, {
+        id: this.uniqueID[1],
+        value: dValue
+    }];
+};
+
+STOCHS.prototype.toString = function () {
+    return  'STOCHS (' + this.options.slowKPeriod + ', '+ this.options.slowDPeriod + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+/**
+ * @param indicatorMetadata
+ * @returns {*[]}
+ */
+STOCHS.prototype.buildSeriesAndAxisConfFromData = function(indicatorMetadata) {
+    //Prepare the data before sending a configuration
+    var stochsData = [];
+    this.indicatorData.forEach(function (e) {
+        stochsData.push([e.time, e.value]);
+    });
+    var dData = [];
+    this.dData.indicatorData.forEach(function (e) {
+        dData.push([e.time, e.value]);
+    });
+
+    return [{
+        axisConf: { // Secondary yAxis
+            id: indicatorMetadata.id + '-' + this.uniqueID[0],
+            title: {
+                text: this.toString(),
+                align: 'high',
+                offset: 0,
+                rotation: 0,
+                y: 10,
+                x: 30+ this.toString().length * 7.5
+            },
+            lineWidth: 2,
+            plotLines: this.options.levels
+          }
+        },
+        {
+             seriesConf: {
+                 id: this.uniqueID[0],
+                 name: this.toString(),
+                 data: stochsData,
+                 type: 'line',
+                 yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                 color: this.options.stroke,
+                 lineWidth: this.options.strokeWidth,
+                 dashStyle: this.options.dashStyle,
+                 onChartIndicator: false
+             }
+         },
+        {
+            seriesConf: {
+                id: this.uniqueID[1],
+                name: '%D',
+                data: dData,
+                type: 'line',
+                yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                color: this.options.dStroke,
+                lineWidth: this.options.strokeWidth,
+                dashStyle: this.options.dashStyle,
+                onChartIndicator: false
+            }
+        }
+    ];
+};
+
+/**
+ * This method will return all IDs that are used to identify data series configuration
+ * in the buildSeriesAndAxisConfFromData method.
+ * @returns {*[]}
+ */
+STOCHS.prototype.getIDs = function() {
+    return this.uniqueID;
+};
+
+/**
+ * If all the unique IDs generated by this instance is same as what is passed in the parameter,
+ * then we consider this instance to be same as what caller is looking for
+ * @param uniqueIDArr
+ * @returns {boolean}
+ */
+STOCHS.prototype.isSameInstance = function(uniqueIDArr) {
+    return _.isEqual(uniqueIDArr.sort(), this.uniqueID);
+};
+
+
+window.STOCHS = STOCHS;

package/packages/webtrader-charts/src/indicators/sum.js

@@ -0,0 +1,60 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 1/29/16.
+ */
+
+var SUM = function (data, options, indicators) {
+    IndicatorBase.call(this, data, options, indicators);
+    this.priceData = [];
+    this.CalculateSUMValue = function (data, index) {
+        /* SUM :
+         sum = sum price over n, n - period*/
+        var sum = 0.0;
+        for (var i = 0; i < this.options.period; i++) {
+            sum += this.indicators.getIndicatorOrPriceValue(data[index - i], this.options.appliedTo);
+        }
+        return toFixed(sum, 4);
+    };
+    for (var index = 0; index < data.length; index++) {
+        if (index >= (this.options.period - 1)) {
+            var sum = this.CalculateSUMValue(data, index);
+            this.indicatorData.push({ time: data[index].time, value: sum });
+        } else {
+            this.indicatorData.push({ time: data[index].time, value: 0.0 });
+        }
+        this.priceData.push(data[index]);
+    }
+};
+
+SUM.prototype = Object.create(IndicatorBase.prototype);
+SUM.prototype.constructor = SUM;
+
+SUM.prototype.addPoint = function (data) {
+    this.priceData.push(data);
+    var sum = this.CalculateSUMValue(this.priceData, this.priceData.length - 1);
+    this.indicatorData.push({ time: data.time, value: sum });
+    return [{
+        id: this.uniqueID,
+        value: sum
+    }];
+};
+
+SUM.prototype.update = function (data) {
+    var index = this.priceData.length - 1;
+    this.priceData[index].open = data.open;
+    this.priceData[index].high = data.high;
+    this.priceData[index].low = data.low;
+    this.priceData[index].close = data.close;
+    var sum = this.CalculateSUMValue(this.priceData, index);
+    this.indicatorData[index].value = sum;
+    return [{
+        id: this.uniqueID,
+        value: sum
+    }];
+};
+
+SUM.prototype.toString = function () {
+    return 'SUM (' + this.options.period + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.SUM = SUM;