@ch20026103/anysis 0.0.2-alpha

package/dist/cjs/stockSkills/williams.js

@@ -0,0 +1,77 @@
+"use strict";
+var __assign = (this && this.__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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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(__assign({}, 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(__assign({}, 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(__assign({}, 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(__assign({}, list[i]), { williams18: Math.round(williams18 * 100) / 100 });
+                }
+            }
+            return res;
+        }
+    });
+    return Williams;
+}());
+exports.default = Williams;

package/dist/cjs/stockSkills/williams.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/stockSkills/williams.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var williams_1 = require("./williams");
+var test_data_test_1 = require("./test_data.test");
+describe("test williams methods", function () {
+    it("test getWilliams9()", function () {
+        var williams = new williams_1.default();
+        expect(williams.getWilliams9(test_data_test_1.default)[test_data_test_1.default.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            williams9: -79.59,
+        });
+    });
+    it("test getWilliams18()", function () {
+        var williams = new williams_1.default();
+        expect(williams.getWilliams18(test_data_test_1.default)[test_data_test_1.default.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            williams18: -73.77,
+        });
+    });
+    it("test getAllWillams()", function () {
+        var williams = new williams_1.default();
+        expect(williams.getAllWillams(test_data_test_1.default)[test_data_test_1.default.length - 1]).toEqual({
+            c: 142,
+            o: 138,
+            t: 20211214,
+            v: 16841,
+            h: 143,
+            l: 138,
+            williams9: -79.59,
+            williams18: -73.77,
+        });
+    });
+});

package/dist/cjs/test/add.d.ts

@@ -0,0 +1 @@
+export declare function add(a: number, b: number): number;

package/dist/cjs/test/add.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+function add(a, b) {
+    return a + b;
+}
+exports.add = add;

package/dist/cjs/test/minus.d.ts

@@ -0,0 +1 @@
+export declare function minus(a: number, b: number): number;

package/dist/cjs/test/minus.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minus = void 0;
+function minus(a, b) {
+    return a - b;
+}
+exports.minus = minus;

package/dist/esm/analyze/Month/index.d.ts

@@ -0,0 +1,15 @@
+export declare type setStartMonthInYearType = {
+    January: unknown;
+    February: unknown;
+    March: unknown;
+    April: unknown;
+    May: unknown;
+    June: unknown;
+    July: unknown;
+    August: unknown;
+    September: unknown;
+    October: unknown;
+    November: unknown;
+    December: unknown;
+};
+export declare function setStartMonthInYear(startMonth: number): string[];

package/dist/esm/analyze/Month/index.js

@@ -0,0 +1,20 @@
+export 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;
+}

package/dist/esm/analyze/Regression/simpleRegressoinModel.d.ts

@@ -0,0 +1,12 @@
+declare type RegressionResponseType = {
+    description: string;
+    predictModel: (xValue: number) => number;
+    explained: string;
+};
+/**
+ * xArray = independent
+ * yArray = dependent
+ * response: Y = b0 + b1X
+ */
+export default function simpleRegressionModel(xArray: number[], yArray: number[]): RegressionResponseType;
+export {};

package/dist/esm/analyze/Regression/simpleRegressoinModel.js

@@ -0,0 +1,76 @@
+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
+ */
+export default 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;
+}

package/dist/esm/analyze/Regression/simpleRegressoinModel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/analyze/Regression/simpleRegressoinModel.test.js

@@ -0,0 +1,14 @@
+import simpleRegressoinModel from "./simpleRegressoinModel";
+describe("test simple regressoin model methods", function () {
+    it("test example", function () {
+        var a = [3, 4, 6, 4, 2, 5];
+        var b = [6, 8, 9, 5, 4.5, 9.5];
+        var res = simpleRegressoinModel(a, b);
+        expect(res).toEqual({
+            description: "Y=2+1.25X",
+            explained: "69.44444444444444%",
+            predictModel: expect.any(Function),
+        });
+        expect((res === null || res === void 0 ? void 0 : res.predictModel) && res.predictModel(6)).toBe(9.5);
+    });
+});

package/dist/esm/analyze/TimeSeries/R/index.d.ts

@@ -0,0 +1,7 @@
+export declare function movingAverages(arr: number[], periods: number): number[];
+export declare function weightMovingAverages(arr: number[], periods: number[]): number[];
+declare type ExponentialSmoothingOptions = {
+    initialForecast: number;
+};
+export declare function exponentialSmoothing(arr: number[], alpha: number, options?: Partial<ExponentialSmoothingOptions>): number[];
+export {};

package/dist/esm/analyze/TimeSeries/R/index.js

@@ -0,0 +1,33 @@
+export 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;
+}
+export 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;
+}
+export 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;
+}

package/dist/esm/analyze/TimeSeries/RS/index.d.ts

@@ -0,0 +1,2 @@
+import { setStartMonthInYearType } from "../../Month/index.js";
+export declare function calcSeasonalIndicesNoTrend(monthData: number[], annualEstimate: number, startMonth?: number): setStartMonthInYearType | "data length fail";

package/dist/esm/analyze/TimeSeries/RS/index.js

@@ -0,0 +1,27 @@
+import { setStartMonthInYear, } from "../../Month/index.js";
+export 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;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,12 @@
+export { default as simpleRegressionModel } from "./analyze/Regression/simpleRegressoinModel.js";
+export { movingAverages, weightMovingAverages, exponentialSmoothing, } from "./analyze/TimeSeries/R/index.js";
+export { calcSeasonalIndicesNoTrend } from "./analyze/TimeSeries/RS/index.js";
+export { add } from "./test/add.js";
+export { minus } from "./test/minus.js";
+export { default as Ma } from "./stockSkills/ma.js";
+export { default as Macd } from "./stockSkills/macd.js";
+export { default as Rsi } from "./stockSkills/rsi.js";
+export { default as Williams } from "./stockSkills/williams.js";
+export { default as Gold } from "./stockSkills/gold.js";
+export { default as dateFormat } from "./stockSkills/utils/dateFormat.js";
+export { default as getWeekLine } from "./stockSkills/utils/getWeekLine.js";

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+/*
+  請注意，在 src/index.ts 中，我的導入包含文件擴展名(.js)。
+  如果需要支持 Node.js 和構建工具（ex: webpack），則不需要這樣做。 **因為commonJs默認js副檔名**
+  但如果要支持 ES 模塊的瀏覽器 ，則需要文件擴展名(.js)。
+*/
+export { default as simpleRegressionModel } from "./analyze/Regression/simpleRegressoinModel.js";
+export { movingAverages, weightMovingAverages, exponentialSmoothing, } from "./analyze/TimeSeries/R/index.js";
+export { calcSeasonalIndicesNoTrend } from "./analyze/TimeSeries/RS/index.js";
+export { add } from "./test/add.js";
+export { minus } from "./test/minus.js";
+export { default as Ma } from "./stockSkills/ma.js";
+export { default as Macd } from "./stockSkills/macd.js";
+export { default as Rsi } from "./stockSkills/rsi.js";
+export { default as Williams } from "./stockSkills/williams.js";
+export { default as Gold } from "./stockSkills/gold.js";
+export { default as dateFormat } from "./stockSkills/utils/dateFormat.js";
+export { default as getWeekLine } from "./stockSkills/utils/getWeekLine.js";

package/dist/esm/stockSkills/gold.d.ts

@@ -0,0 +1,47 @@
+declare type ResGoldType = {
+    highestPointDate: number;
+    lowestPointDate: number;
+    lowestPoint: number;
+    highestPoint: number;
+    superStrong: number;
+    strong: number;
+    middle: number;
+    weak: number;
+    superWeak: number;
+};
+declare type ListType = {
+    h: number;
+    t: number;
+    o: number;
+    c: number;
+    l: number;
+}[];
+declare type ResHightestType = {
+    [key: string]: {
+        h: number;
+        t: number;
+        o: number;
+        c: number;
+        l: number;
+    };
+};
+declare type ResLowestType = {
+    [key: string]: {
+        h: number;
+        t: number;
+        o: number;
+        c: number;
+        l: number;
+    };
+};
+interface GoldType {
+    findHighPoint: (list: ListType) => ResHightestType;
+    findLowPoint: (list: ListType) => ResLowestType;
+    getGold: (list: ListType) => ResGoldType;
+}
+export default class Gold implements GoldType {
+    findHighPoint(list: ListType): ResHightestType;
+    findLowPoint(list: ListType): ResLowestType;
+    getGold(list: ListType): ResGoldType;
+}
+export {};

package/dist/esm/stockSkills/gold.js

@@ -0,0 +1,214 @@
+import getWeekLine from "./utils/getWeekLine.js";
+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;
+}());
+export default Gold;

package/dist/esm/stockSkills/gold.test.d.ts

@@ -0,0 +1 @@
+export {};