@ch20026103/anysis 0.0.2-alpha

package/dist/umd/index.js

@@ -0,0 +1,1059 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.anysis = {}));
+})(this, (function (exports) { 'use strict';
+
+    function average(arr) {
+        var total = arr.reduce(function (prev, curr) { return prev + curr; });
+        var xBar = total / arr.length;
+        return xBar;
+    }
+    function calcB1(_a) {
+        var xBar = _a.xBar, yBar = _a.yBar, xArray = _a.xArray, yArray = _a.yArray;
+        var i = 0;
+        var denominator = 0;
+        var numerator = 0;
+        while (i < xArray.length) {
+            denominator += (xArray[i] - xBar) * (yArray[i] - yBar);
+            numerator += Math.pow(xArray[i] - xBar, 2);
+            i++;
+        }
+        return denominator / numerator;
+    }
+    function calcB0(_a) {
+        var xBar = _a.xBar, yBar = _a.yBar, b1 = _a.b1;
+        return yBar - b1 * xBar;
+    }
+    function calcSSR(_a) {
+        var yBar = _a.yBar, predictRegressionModel = _a.predictRegressionModel, xArray = _a.xArray;
+        var Sum = xArray.reduce(function (prev, curr) {
+            return prev + Math.pow(predictRegressionModel(curr) - yBar, 2);
+        }, 0);
+        return Sum;
+    }
+    function calcSSE(_a) {
+        var predictRegressionModel = _a.predictRegressionModel, yArray = _a.yArray, xArray = _a.xArray;
+        var Sum = 0;
+        for (var i = 0; i < xArray.length; i++) {
+            var X = xArray[i];
+            var Y = yArray[i];
+            Sum += Math.pow(Y - predictRegressionModel(X), 2);
+        }
+        return Sum;
+    }
+    /**
+     * xArray = independent
+     * yArray = dependent
+     * response: Y = b0 + b1X
+     */
+    function simpleRegressionModel(xArray, yArray) {
+        if (xArray.length !== yArray.length)
+            return {
+                description: "xArray length is different about yArray length",
+                predictModel: function () { return NaN; },
+                explained: "0%",
+            };
+        var xBar = average(xArray);
+        var yBar = average(yArray);
+        var b1 = calcB1({ xBar: xBar, yBar: yBar, xArray: xArray, yArray: yArray });
+        var b0 = calcB0({ xBar: xBar, yBar: yBar, b1: b1 });
+        var predictRegressionModel = function (xValue) {
+            return b0 + b1 * xValue;
+        };
+        var SSR = calcSSR({
+            yBar: yBar,
+            predictRegressionModel: predictRegressionModel,
+            xArray: xArray,
+        });
+        var SSE = calcSSE({
+            predictRegressionModel: predictRegressionModel,
+            yArray: yArray,
+            xArray: xArray,
+        });
+        var SST = SSR + SSE;
+        var rPower = (SSR / SST) * 100 + "%";
+        var response = {
+            description: "Y=".concat(b0, "+").concat(b1, "X"),
+            predictModel: predictRegressionModel,
+            explained: rPower,
+        };
+        return response;
+    }
+
+    function movingAverages(arr, periods) {
+        var response = new Array(periods).fill(0);
+        for (var i = periods; i < arr.length; i++) {
+            var Sum = 0;
+            for (var e = 1; e <= periods; e++) {
+                Sum += arr[i - e];
+            }
+            response.push(Sum / periods);
+        }
+        return response;
+    }
+    function weightMovingAverages(arr, periods) {
+        var response = new Array(periods.length).fill(0);
+        var weightSum = periods.reduce(function (pre, curr) { return pre + curr; });
+        for (var i = periods.length - 1; i < arr.length; i++) {
+            var Sum = 0;
+            for (var e = 0; e < periods.length; e++) {
+                Sum += arr[i - e] * periods[e];
+            }
+            response.push(Sum / weightSum);
+        }
+        return response;
+    }
+    function exponentialSmoothing(arr, alpha, options) {
+        var PreviousForecast = (options === null || options === void 0 ? void 0 : options.initialForecast) || arr[0];
+        var forecasts = [PreviousForecast];
+        for (var i = 1; i <= arr.length; i++) {
+            var Sum = PreviousForecast + alpha * (arr[i - 1] - PreviousForecast);
+            PreviousForecast = Sum;
+            forecasts.push(Sum);
+        }
+        return forecasts;
+    }
+
+    function setStartMonthInYear(startMonth) {
+        var base = [
+            "January",
+            "February",
+            "March",
+            "April",
+            "May",
+            "June",
+            "July",
+            "August",
+            "September",
+            "October",
+            "November",
+            "December",
+        ];
+        var end = base.slice(0, startMonth - 1);
+        var start = base.slice(startMonth - 1);
+        var response = start.concat(end);
+        return response;
+    }
+
+    function calcSeasonalIndicesNoTrend(monthData, annualEstimate, startMonth) {
+        if (startMonth === void 0) { startMonth = 1; }
+        // error
+        if (monthData.length % 12 !== 0)
+            return "data length fail";
+        // calc
+        var loop = monthData.length / 12;
+        var SumArr = [];
+        while (SumArr.length < 12) {
+            var Sum = 0;
+            for (var i = 0; i < loop; i++) {
+                Sum += monthData[i * 12 + SumArr.length];
+            }
+            SumArr.push(Sum / loop);
+        }
+        var SumAverage = SumArr.reduce(function (pre, curr) { return pre + curr; }) / 12;
+        var seasonalIndexal = SumArr.map(function (sum) { return sum / SumAverage; });
+        // create Map
+        var perMonth = annualEstimate / 12;
+        var months = setStartMonthInYear(startMonth);
+        var nextYearForecast = {};
+        months.forEach(function (month, index) {
+            nextYearForecast[month] = perMonth * seasonalIndexal[index];
+        });
+        return nextYearForecast;
+    }
+
+    function add(a, b) {
+        return a + b;
+    }
+
+    function minus(a, b) {
+        return a - b;
+    }
+
+    var __assign$4 = (undefined && undefined.__assign) || function () {
+        __assign$4 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$4.apply(this, arguments);
+    };
+    var Ma = /** @class */ (function () {
+        function Ma() {
+        }
+        Object.defineProperty(Ma.prototype, "getAllMa", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                var responseMa5 = this.getMa5(list);
+                var responseMa10 = this.getMa10(list);
+                var responseMa20 = this.getMa20(list);
+                var responseMa60 = this.getMa60(list);
+                var responseBoll = this.getBoll(list);
+                for (var i = 0; i < list.length; i++) {
+                    res[i] = Object.assign(list[i], responseMa5[i], responseMa10[i], responseMa20[i], responseMa60[i], responseBoll[i]);
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Ma.prototype, "getMa5", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 4)
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma5: undefined });
+                    else {
+                        var sum = list
+                            .slice(i - 4, i + 1)
+                            .reduce(function (pre, current) { return pre + current.c; }, 0);
+                        var ma5 = Math.round((sum / 5) * 100) / 100;
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma5: ma5 });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Ma.prototype, "getMa10", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 9)
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma10: undefined });
+                    else {
+                        var sum = list
+                            .slice(i - 9, i + 1)
+                            .reduce(function (pre, current) { return pre + current.c; }, 0);
+                        var ma10 = Math.round((sum / 10) * 100) / 100;
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma10: ma10 });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Ma.prototype, "getMa20", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 19)
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma20: undefined });
+                    else {
+                        var sum = list
+                            .slice(i - 19, i + 1)
+                            .reduce(function (pre, current) { return pre + current.c; }, 0);
+                        var ma20 = Math.round((sum / 20) * 100) / 100;
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma20: ma20 });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Ma.prototype, "getMa60", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 59)
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma60: undefined });
+                    else {
+                        var sum = list
+                            .slice(i - 59, i + 1)
+                            .reduce(function (pre, current) { return pre + current.c; }, 0);
+                        var ma60 = Math.round((sum / 60) * 100) / 100;
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma60: ma60 });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Ma.prototype, "getMaSelf", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list, self) {
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < (self - 1))
+                        res[i] = __assign$4(__assign$4({}, list[i]), { maSelf: undefined });
+                    else {
+                        var sum = list
+                            .slice(i - (self - 1), i + 1)
+                            .reduce(function (pre, current) { return pre + current.c; }, 0);
+                        var maSelf = Math.round((sum / self) * 100) / 100;
+                        res[i] = __assign$4(__assign$4({}, list[i]), { maSelf: maSelf });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Ma.prototype, "getBoll", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                var _loop_1 = function (i) {
+                    if (i < 24)
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma25: undefined, bollUb: undefined, bollLb: undefined });
+                    else {
+                        // ma25
+                        var sumMa25 = list
+                            .slice(i - 24, i + 1)
+                            .reduce(function (pre, current) { return pre + current.c; }, 0);
+                        var ma25_1 = Math.round((sumMa25 / 25) * 100) / 100;
+                        // 標準差
+                        var sumBase = res
+                            .slice(i - 24, i + 1)
+                            .reduce(function (pre, current) {
+                            return ma25_1 !== undefined
+                                ? pre + Math.pow(current.c - ma25_1, 2)
+                                : pre;
+                        }, 0);
+                        var base = Math.round(Math.sqrt(sumBase / 25) * 100) / 100;
+                        res[i] = __assign$4(__assign$4({}, list[i]), { ma25: ma25_1, bollUb: ma25_1 + 2 * base, bollLb: ma25_1 - 2 * base });
+                    }
+                };
+                for (var i = 0; i < list.length; i++) {
+                    _loop_1(i);
+                }
+                return res;
+            }
+        });
+        return Ma;
+    }());
+
+    var __assign$3 = (undefined && undefined.__assign) || function () {
+        __assign$3 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$3.apply(this, arguments);
+    };
+    var MACD = /** @class */ (function () {
+        function MACD() {
+        }
+        Object.defineProperty(MACD.prototype, "getMACD", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                // 首筆RSI
+                var res = [];
+                var EMA12 = this.getEMA12(list);
+                var EMA26 = this.getEMA26(list);
+                var DIF = this.getDIF(list, EMA12, EMA26);
+                var MACD9 = this.getMACD9(list, DIF);
+                for (var i = 0; i < list.length; i++) {
+                    res[i] = Object.assign(list[i], DIF[i], MACD9[i]);
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(MACD.prototype, "getDI", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (item) {
+                return (item["h"] + item["l"] + 2 * item["c"]) / 4;
+            }
+        });
+        Object.defineProperty(MACD.prototype, "getStartEMA", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (arr) {
+                var _this = this;
+                var sum = 0;
+                arr.forEach(function (item) {
+                    var DI = _this.getDI(item);
+                    sum += DI;
+                });
+                return sum / arr.length;
+            }
+        });
+        Object.defineProperty(MACD.prototype, "getEMA12", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var start = list.slice(0, 11);
+                var beforeEMA12 = this.getStartEMA(start);
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 12)
+                        res[i] = __assign$3(__assign$3({}, list[i]), { EMA12: undefined });
+                    else {
+                        beforeEMA12 = (beforeEMA12 * 11) / 13 + (this.getDI(list[i]) * 2) / 13;
+                        res[i] = __assign$3(__assign$3({}, list[i]), { EMA12: beforeEMA12 });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(MACD.prototype, "getEMA26", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var start = list.slice(0, 25);
+                var beforeEMA26 = this.getStartEMA(start);
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 26)
+                        res[i] = __assign$3(__assign$3({}, list[i]), { EMA26: undefined });
+                    else {
+                        beforeEMA26 = (beforeEMA26 * 25) / 27 + (this.getDI(list[i]) * 2) / 27;
+                        res[i] = __assign$3(__assign$3({}, list[i]), { EMA26: beforeEMA26 });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(MACD.prototype, "getDIF", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list, ResEMA12, ResEMA26) {
+                var _a, _b;
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 26)
+                        res[i] = __assign$3(__assign$3({}, list[i]), { DIF: undefined });
+                    else {
+                        var EMA12 = ((_a = ResEMA12 === null || ResEMA12 === void 0 ? void 0 : ResEMA12[i]) === null || _a === void 0 ? void 0 : _a["EMA12"]) && ResEMA12[i]["EMA12"];
+                        var EMA26 = ((_b = ResEMA26 === null || ResEMA26 === void 0 ? void 0 : ResEMA26[i]) === null || _b === void 0 ? void 0 : _b["EMA26"]) && ResEMA26[i]["EMA26"];
+                        var DIF = EMA12 - EMA26;
+                        res[i] = __assign$3(__assign$3({}, list[i]), { DIF: DIF });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(MACD.prototype, "getMACD9", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list, DIF) {
+                var res = [];
+                var beforeMACD9 = 0;
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 26)
+                        res[i] = __assign$3(__assign$3({}, list[i]), { MACD9: undefined, OSC: undefined });
+                    else if (i === 26) {
+                        var MACD9 = DIF.slice(26, 34)
+                            .map(function (item) { return ((item === null || item === void 0 ? void 0 : item.DIF) ? item["DIF"] : 0); })
+                            .reduce(function (accumulator, currentValue) { return accumulator + currentValue; });
+                        var OSC = DIF[i]["DIF"] - MACD9;
+                        res[26] = __assign$3(__assign$3({}, list[i]), { MACD9: MACD9, OSC: OSC });
+                        beforeMACD9 = MACD9;
+                    }
+                    else {
+                        var MACD9 = beforeMACD9 + ((DIF[i]["DIF"] - beforeMACD9) * 2) / 10;
+                        var OSC = DIF[i]["DIF"] - MACD9;
+                        res[i] = __assign$3(__assign$3({}, list[i]), { MACD9: MACD9, OSC: OSC });
+                        beforeMACD9 = MACD9;
+                    }
+                }
+                return res;
+            }
+        });
+        return MACD;
+    }());
+
+    var __assign$2 = (undefined && undefined.__assign) || function () {
+        __assign$2 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$2.apply(this, arguments);
+    };
+    var Rsi = /** @class */ (function () {
+        function Rsi() {
+        }
+        Object.defineProperty(Rsi.prototype, "getAllRsi", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                var rsi6 = this.getRsi6(list);
+                var rsi12 = this.getRsi12(list);
+                for (var i = 0; i < list.length; i++) {
+                    res[i] = Object.assign(list[i], rsi6[i], rsi12[i]);
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Rsi.prototype, "getRsi6", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                // 前5筆
+                for (var i = 0; i < 5; i++) {
+                    res[i] = __assign$2(__assign$2({}, list[i]), { rsi6: undefined });
+                }
+                // 第6筆Rsi
+                var beforeUpAvg = this.getStartUpAvg(list, 6);
+                var beforeDownAvg = this.getStartDownAvg(list, 6);
+                var firstRsi6 = this.getRsi(beforeUpAvg, beforeDownAvg);
+                res[5] = __assign$2(__assign$2({}, list[5]), { rsi6: firstRsi6 });
+                // else
+                for (var i = 6; i < list.length; i++) {
+                    var minusU = 0;
+                    var minusD = 0;
+                    var minusC = list[i]["c"] - list[i - 1]["c"];
+                    if (minusC > 0) {
+                        minusU = minusC;
+                    }
+                    else {
+                        minusD = minusC;
+                    }
+                    beforeUpAvg = (beforeUpAvg * 5) / 6 + minusU / 6;
+                    beforeDownAvg = (beforeDownAvg * 5) / 6 + Math.abs(minusD) / 6;
+                    var rsi6 = this.getRsi(beforeUpAvg, beforeDownAvg);
+                    res[i] = __assign$2(__assign$2({}, list[i]), { rsi6: Math.round(rsi6 * 100) / 100 });
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Rsi.prototype, "getRsi12", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                // 前11筆
+                for (var i = 0; i < 11; i++) {
+                    res[i] = __assign$2(__assign$2({}, list[i]), { rsi12: undefined });
+                }
+                // 第12筆Rsi
+                var beforeUpAvg = this.getStartUpAvg(list, 12);
+                var beforeDownAvg = this.getStartDownAvg(list, 12);
+                var firstRsi12 = this.getRsi(beforeUpAvg, beforeDownAvg);
+                res[11] = __assign$2(__assign$2({}, list[11]), { rsi12: firstRsi12 });
+                // else
+                for (var i = 12; i < list.length; i++) {
+                    var minusU = 0;
+                    var minusD = 0;
+                    var minusC = list[i]["c"] - list[i - 1]["c"];
+                    if (minusC > 0) {
+                        minusU = minusC;
+                    }
+                    else {
+                        minusD = minusC;
+                    }
+                    beforeUpAvg = (beforeUpAvg * 11) / 12 + minusU / 12;
+                    beforeDownAvg = (beforeDownAvg * 11) / 12 + Math.abs(minusD) / 12;
+                    var rsi12 = this.getRsi(beforeUpAvg, beforeDownAvg);
+                    res[i] = __assign$2(__assign$2({}, list[i]), { rsi12: Math.round(rsi12 * 100) / 100 });
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Rsi.prototype, "getStartUpAvg", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list, count) {
+                var start = list.slice(0, 5);
+                var sum = 0;
+                for (var i = 1; i < start.length; i++) {
+                    var minus = start[i]["c"] - start[i - 1]["c"];
+                    if (minus > 0) {
+                        sum += minus;
+                    }
+                }
+                return sum / count;
+            }
+        });
+        Object.defineProperty(Rsi.prototype, "getStartDownAvg", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list, count) {
+                var start = list.slice(0, 5);
+                var sum = 0;
+                for (var i = 1; i < start.length; i++) {
+                    var minus = start[i]["c"] - start[i - 1]["c"];
+                    if (minus < 0) {
+                        sum += minus;
+                    }
+                }
+                return Math.abs(sum / count);
+            }
+        });
+        Object.defineProperty(Rsi.prototype, "getRsi", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (UpAvg, DownAvg) {
+                var res = 0;
+                if (UpAvg + DownAvg !== 0) {
+                    res = (UpAvg / (UpAvg + DownAvg)) * 100;
+                }
+                return res;
+            }
+        });
+        return Rsi;
+    }());
+
+    var __assign$1 = (undefined && undefined.__assign) || function () {
+        __assign$1 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$1.apply(this, arguments);
+    };
+    var Williams = /** @class */ (function () {
+        function Williams() {
+        }
+        Object.defineProperty(Williams.prototype, "getAllWillams", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                var williams9 = this.getWilliams9(list);
+                var williams18 = this.getWilliams18(list);
+                for (var i = 0; i < list.length; i++) {
+                    res[i] = Object.assign(list[i], williams9[i], williams18[i]);
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Williams.prototype, "getWilliams9", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 9)
+                        res[i] = __assign$1(__assign$1({}, list[i]), { williams9: undefined });
+                    else {
+                        var maxList = list.slice(i - 8, i).map(function (item) { return item["h"]; });
+                        var minList = list.slice(i - 8, i).map(function (item) { return item["l"]; });
+                        var max = Math.max.apply(Math, maxList);
+                        var min = Math.min.apply(Math, minList);
+                        var close_1 = list[i]["c"];
+                        var williams9 = ((max - close_1) / (max - min)) * -100;
+                        res[i] = __assign$1(__assign$1({}, list[i]), { williams9: Math.round(williams9 * 100) / 100 });
+                    }
+                }
+                return res;
+            }
+        });
+        Object.defineProperty(Williams.prototype, "getWilliams18", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var res = [];
+                for (var i = 0; i < list.length; i++) {
+                    if (i < 18)
+                        res[i] = __assign$1(__assign$1({}, list[i]), { williams9: undefined });
+                    else {
+                        var maxList = list.slice(i - 17, i).map(function (item) { return item["h"]; });
+                        var minList = list.slice(i - 17, i).map(function (item) { return item["l"]; });
+                        var max = Math.max.apply(Math, maxList);
+                        var min = Math.min.apply(Math, minList);
+                        var close_2 = list[i]["c"];
+                        var williams18 = ((max - close_2) / (max - min)) * -100;
+                        res[i] = __assign$1(__assign$1({}, list[i]), { williams18: Math.round(williams18 * 100) / 100 });
+                    }
+                }
+                return res;
+            }
+        });
+        return Williams;
+    }());
+
+    var __assign = (undefined && undefined.__assign) || function () {
+        __assign = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function addDetail(obj, list, detail) {
+        if (detail)
+            return __assign(__assign({}, obj), { detail: list });
+        else
+            return __assign({}, obj);
+    }
+    function getWeekLine(list, detail) {
+        var res = [];
+        var collectWeekData = [];
+        list.forEach(function (item, index) {
+            var year = item["t"]
+                .toString()
+                .replace(/^(\d{4})(\d{2})(\d{2})$/, "$1-$2-$3");
+            var day = new Date(year).getDay();
+            switch (day) {
+                case 6:
+                    break;
+                case 5: {
+                    collectWeekData.push(item);
+                    var obj = {
+                        o: collectWeekData[0]["o"],
+                        c: collectWeekData[collectWeekData.length - 1]["c"],
+                        t: collectWeekData[collectWeekData.length - 1]["t"],
+                        h: Math.max.apply(Math, collectWeekData.map(function (item) { return item.h; })),
+                        l: Math.min.apply(Math, collectWeekData.map(function (item) { return item.l; })),
+                    };
+                    res.push(addDetail(obj, collectWeekData, detail));
+                    collectWeekData = [];
+                    break;
+                }
+                case 1:
+                    if (collectWeekData.length !== 0) {
+                        var obj = {
+                            o: collectWeekData[0]["o"],
+                            c: collectWeekData[collectWeekData.length - 1]["c"],
+                            t: collectWeekData[collectWeekData.length - 1]["t"],
+                            h: Math.max.apply(Math, collectWeekData.map(function (item) { return item.h; })),
+                            l: Math.min.apply(Math, collectWeekData.map(function (item) { return item.l; })),
+                        };
+                        res.push(addDetail(obj, collectWeekData, detail));
+                    }
+                    collectWeekData = [];
+                    collectWeekData.push(item);
+                    break;
+                default:
+                    collectWeekData.push(item);
+                    if (list.length - 1 === index) {
+                        var obj = {
+                            o: collectWeekData[0]["o"],
+                            c: collectWeekData[collectWeekData.length - 1]["c"],
+                            t: collectWeekData[collectWeekData.length - 1]["t"],
+                            h: Math.max.apply(Math, collectWeekData.map(function (item) { return item.h; })),
+                            l: Math.min.apply(Math, collectWeekData.map(function (item) { return item.l; })),
+                        };
+                        res.push(addDetail(obj, collectWeekData, detail));
+                    }
+                    break;
+            }
+        });
+        return res;
+    }
+
+    var Gold = /** @class */ (function () {
+        function Gold() {
+        }
+        Object.defineProperty(Gold.prototype, "findHighPoint", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var weekLine = getWeekLine(list, true);
+                var hightPoints = {};
+                var _loop_1 = function (i) {
+                    var hightPoint = undefined;
+                    switch (i) {
+                        case 0:
+                            {
+                                var h1 = weekLine[i].h;
+                                var h2 = weekLine[i + 1].h;
+                                var h3 = weekLine[i + 2].h;
+                                if (h1 > h2 && h1 > h3)
+                                    hightPoint = weekLine[i];
+                            }
+                            break;
+                        case 1:
+                            {
+                                var h1 = weekLine[i - 1].h;
+                                var h2 = weekLine[i].h;
+                                var h3 = weekLine[i + 1].h;
+                                var h4 = weekLine[i + 2].h;
+                                if (h2 > h1 && h2 > h3 && h2 > h4)
+                                    hightPoint = weekLine[i];
+                            }
+                            break;
+                        case weekLine.length - 3:
+                            {
+                                var h1 = weekLine[i - 2].h;
+                                var h2 = weekLine[i - 1].h;
+                                var h3 = weekLine[i].h;
+                                var h4 = weekLine[i + 1].h;
+                                var h5 = weekLine[i + 2].h;
+                                if (h3 > h1 && h3 > h2 && h3 > h4 && h3 > h5)
+                                    hightPoint = weekLine[i];
+                            }
+                            break;
+                        case weekLine.length - 2:
+                            {
+                                var h1 = weekLine[i - 2].h;
+                                var h2 = weekLine[i - 1].h;
+                                var h3 = weekLine[i].h;
+                                var h4 = weekLine[i + 1].h;
+                                if (h3 > h1 && h3 > h2 && h3 > h4)
+                                    hightPoint = weekLine[i];
+                            }
+                            break;
+                        case weekLine.length - 1:
+                            {
+                                var h1 = weekLine[i - 2].h;
+                                var h2 = weekLine[i - 1].h;
+                                var h3 = weekLine[i].h;
+                                if (h3 > h2 && h3 > h1)
+                                    hightPoint = weekLine[i];
+                            }
+                            break;
+                        default:
+                            {
+                                var h1 = weekLine[i - 2].h;
+                                var h2 = weekLine[i - 1].h;
+                                var h3 = weekLine[i].h;
+                                var h4 = weekLine[i + 1].h;
+                                var h5 = weekLine[i + 2].h;
+                                var h6 = weekLine[i + 3].h;
+                                if (h3 > h2 && h3 > h4 && h3 > h5 && h3 > h6)
+                                    hightPoint = weekLine[i];
+                                if (h3 > h1 && h3 > h2 && h3 > h4 && h3 > h5)
+                                    hightPoint = weekLine[i];
+                            }
+                            break;
+                    }
+                    if (hightPoint && hightPoint["detail"]) {
+                        var h_1 = hightPoint.h;
+                        var theHight = hightPoint.detail.find(function (item) { return item.h === h_1; });
+                        delete hightPoint.detail;
+                        if (theHight)
+                            hightPoints[theHight === null || theHight === void 0 ? void 0 : theHight.t] = theHight;
+                    }
+                };
+                for (var i = 0; i < weekLine.length; i++) {
+                    _loop_1(i);
+                }
+                return hightPoints;
+            }
+        });
+        Object.defineProperty(Gold.prototype, "findLowPoint", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var weekLine = getWeekLine(list, true);
+                var lowPoints = {};
+                var _loop_2 = function (i) {
+                    var lowPoint = undefined;
+                    switch (i) {
+                        case 0:
+                            {
+                                var l1 = weekLine[i].l;
+                                var l2 = weekLine[i + 1].l;
+                                var l3 = weekLine[i + 2].l;
+                                if (l1 < l2 && l1 < l3)
+                                    lowPoint = weekLine[i];
+                            }
+                            break;
+                        case 1:
+                            {
+                                var l1 = weekLine[i - 1].l;
+                                var l2 = weekLine[i].l;
+                                var l3 = weekLine[i + 1].l;
+                                var l4 = weekLine[i + 2].l;
+                                if (l2 < l1 && l2 < l3 && l2 < l4)
+                                    lowPoint = weekLine[i];
+                            }
+                            break;
+                        case weekLine.length - 3:
+                            {
+                                var l1 = weekLine[i - 2].l;
+                                var l2 = weekLine[i - 1].l;
+                                var l3 = weekLine[i].l;
+                                var l4 = weekLine[i + 1].l;
+                                var l5 = weekLine[i + 2].l;
+                                if (l3 < l1 && l3 < l2 && l3 < l4 && l3 < l5)
+                                    lowPoint = weekLine[i];
+                            }
+                            break;
+                        case weekLine.length - 2:
+                            {
+                                var l1 = weekLine[i - 2].l;
+                                var l2 = weekLine[i - 1].l;
+                                var l3 = weekLine[i].l;
+                                var l4 = weekLine[i + 1].l;
+                                if (l3 < l1 && l3 < l2 && l3 < l4)
+                                    lowPoint = weekLine[i];
+                            }
+                            break;
+                        case weekLine.length - 1:
+                            {
+                                var l1 = weekLine[i - 2].l;
+                                var l2 = weekLine[i - 1].l;
+                                var l3 = weekLine[i].l;
+                                if (l3 < l2 && l3 < l1)
+                                    lowPoint = weekLine[i];
+                            }
+                            break;
+                        default:
+                            {
+                                var l1 = weekLine[i - 2].l;
+                                var l2 = weekLine[i - 1].l;
+                                var l3 = weekLine[i].l;
+                                var l4 = weekLine[i + 1].l;
+                                var l5 = weekLine[i + 2].l;
+                                var l6 = weekLine[i + 3].l;
+                                if (l3 < l2 && l3 < l4 && l3 < l5 && l3 < l6)
+                                    lowPoint = weekLine[i];
+                                if (l3 < l1 && l3 < l2 && l3 < l4 && l3 < l5)
+                                    lowPoint = weekLine[i];
+                            }
+                            break;
+                    }
+                    if (lowPoint && lowPoint["detail"]) {
+                        var l_1 = lowPoint.l;
+                        var theLow = lowPoint.detail.find(function (item) { return item.l === l_1; });
+                        delete lowPoint.detail;
+                        if (theLow)
+                            lowPoints[theLow === null || theLow === void 0 ? void 0 : theLow.t] = theLow;
+                    }
+                };
+                for (var i = 0; i < weekLine.length; i++) {
+                    _loop_2(i);
+                }
+                return lowPoints;
+            }
+        });
+        Object.defineProperty(Gold.prototype, "getGold", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function (list) {
+                var hightPoints = this.findHighPoint(list);
+                var lowPoints = this.findLowPoint(list);
+                var lastHightPointDate = Object.keys(hightPoints).slice(-1)[0] !==
+                    list[list.length - 1].t.toString()
+                    ? Object.keys(hightPoints).slice(-1)[0]
+                    : Object.keys(hightPoints).slice(-2)[0];
+                var lastLowPointDate = Object.keys(lowPoints).slice(-1)[0] !== list[list.length - 1].t.toString()
+                    ? Object.keys(lowPoints).slice(-1)[0]
+                    : Object.keys(lowPoints).slice(-2)[0];
+                var highestPoint = hightPoints[lastHightPointDate].h;
+                var lowestPoint = lowPoints[lastLowPointDate].l;
+                var res = {
+                    highestPointDate: parseInt(lastHightPointDate),
+                    lowestPointDate: parseInt(lastLowPointDate),
+                    lowestPoint: lowestPoint,
+                    highestPoint: highestPoint,
+                    superStrong: Math.round((highestPoint - (highestPoint - lowestPoint) * 0.191) * 100) / 100,
+                    strong: Math.round((highestPoint - (highestPoint - lowestPoint) * 0.382) * 100) / 100,
+                    middle: Math.round((highestPoint - (highestPoint - lowestPoint) * 0.5) * 100) /
+                        100,
+                    weak: Math.round((highestPoint - (highestPoint - lowestPoint) * 0.618) * 100) / 100,
+                    superWeak: Math.round((highestPoint - (highestPoint - lowestPoint) * 0.809) * 100) / 100,
+                };
+                return res;
+            }
+        });
+        return Gold;
+    }());
+
+    var Mode;
+    (function (Mode) {
+        Mode[Mode["NumberToString"] = 1] = "NumberToString";
+        Mode[Mode["NumberToTimeStamp"] = 2] = "NumberToTimeStamp";
+        Mode[Mode["StringToTimeStamp"] = 3] = "StringToTimeStamp";
+        Mode[Mode["TimeStampToString"] = 4] = "TimeStampToString";
+        Mode[Mode["TimeStampToNumber"] = 5] = "TimeStampToNumber";
+        Mode[Mode["StringToNumber"] = 6] = "StringToNumber";
+    })(Mode || (Mode = {}));
+    function dateFormat(date, mode) {
+        switch (mode) {
+            case Mode.NumberToString: {
+                var input = date.toString();
+                var res = input.slice(0, 4) + "-" + input.slice(4, 6) + "-" + input.slice(6, 8);
+                return res;
+            }
+            case Mode.NumberToTimeStamp: {
+                var input = date.toString();
+                var stringDate = input.slice(0, 4) + "-" + input.slice(4, 6) + "-" + input.slice(6, 8);
+                var res = Date.parse(stringDate);
+                return res;
+            }
+            case Mode.StringToTimeStamp: {
+                var res = Date.parse(date);
+                return res;
+            }
+            case Mode.TimeStampToString: {
+                var newDate = new Date(date);
+                var yy = newDate.getFullYear();
+                var mm = newDate.getMonth() + 1 < 10
+                    ? "0" + (newDate.getMonth() + 1)
+                    : newDate.getMonth() + 1;
+                var dd = newDate.getDate() < 10 ? "0" + newDate.getDate() : newDate.getDate();
+                var res = yy + "-" + mm + "-" + dd;
+                return res;
+            }
+            case Mode.TimeStampToNumber: {
+                var newDate = new Date(date);
+                var yy = newDate.getFullYear();
+                var mm = newDate.getMonth() + 1 < 10
+                    ? "0" + (newDate.getMonth() + 1)
+                    : newDate.getMonth() + 1;
+                var dd = newDate.getDate() < 10 ? "0" + newDate.getDate() : newDate.getDate();
+                var res = "".concat(yy).concat(mm).concat(dd);
+                return parseInt(res);
+            }
+            case Mode.StringToNumber: {
+                var res = date.toString().replace("-", "").replace("-", "");
+                return parseInt(res);
+            }
+            default:
+                return "please setting mode";
+        }
+    }
+
+    exports.Gold = Gold;
+    exports.Ma = Ma;
+    exports.Macd = MACD;
+    exports.Rsi = Rsi;
+    exports.Williams = Williams;
+    exports.add = add;
+    exports.calcSeasonalIndicesNoTrend = calcSeasonalIndicesNoTrend;
+    exports.dateFormat = dateFormat;
+    exports.exponentialSmoothing = exponentialSmoothing;
+    exports.getWeekLine = getWeekLine;
+    exports.minus = minus;
+    exports.movingAverages = movingAverages;
+    exports.simpleRegressionModel = simpleRegressionModel;
+    exports.weightMovingAverages = weightMovingAverages;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));