@ntlab/ntjs-assets 2.41.0 → 2.43.0

package/assets/js/highcharts/esm/indicators/stochastic.js

@@ -0,0 +1 @@
+import*as e from"../highcharts.js";import"../modules/stock.js";var t,a={};a.n=e=>{var t=e&&e.__esModule?()=>e.default:()=>e;return a.d(t,{a:t}),t},a.d=(e,t)=>{for(var o in t)a.o(t,o)&&!a.o(e,o)&&Object.defineProperty(e,o,{enumerable:!0,get:t[o]})},a.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t);let o=e.default;var i=a.n(o);a.d({},{});let s={getArrayExtremes:function(e,t,a){return e.reduce((e,o)=>[Math.min(e[0],o[t]),Math.max(e[1],o[a])],[Number.MAX_VALUE,-Number.MAX_VALUE])}},r=e.default.SeriesRegistry;var n=a.n(r);let{sma:{prototype:l}}=n().seriesTypes,{defined:p,error:h,merge:c}=i();!function(e){let t=["bottomLine"],a=["top","bottom"],o=["top"];function i(e){return"plot"+e.charAt(0).toUpperCase()+e.slice(1)}function s(e,t){let a=[];return(e.pointArrayMap||[]).forEach(e=>{e!==t&&a.push(i(e))}),a}function r(){let e=this,t=e.pointValKey,a=e.linesApiNames,o=e.areaLinesNames,r=e.points,n=e.options,u=e.graph,d={options:{gapSize:n.gapSize}},m=[],y=s(e,t),f=r.length,g;if(y.forEach((e,t)=>{for(m[t]=[];f--;)g=r[f],m[t].push({x:g.x,plotX:g.plotX,plotY:g[e],isNull:!p(g[e])});f=r.length}),e.userOptions.fillColor&&o.length){let t=m[y.indexOf(i(o[0]))],a=1===o.length?r:m[y.indexOf(i(o[1]))],s=e.color;e.points=a,e.nextPoints=t,e.color=e.userOptions.fillColor,e.options=c(r,d),e.graph=e.area,e.fillGraph=!0,l.drawGraph.call(e),e.area=e.graph,delete e.nextPoints,delete e.fillGraph,e.color=s}a.forEach((t,a)=>{m[a]?(e.points=m[a],n[t]?e.options=c(n[t].styles,d):h('Error: "There is no '+t+' in DOCS options declared. Check if linesApiNames are consistent with your DOCS line names."'),e.graph=e["graph"+t],l.drawGraph.call(e),e["graph"+t]=e.graph):h('Error: "'+t+" doesn't have equivalent in pointArrayMap. To many elements in linesApiNames relative to pointArrayMap.\"")}),e.points=r,e.options=n,e.graph=u,l.drawGraph.call(e)}function n(e){let t,a=[],o=[];if(e=e||this.points,this.fillGraph&&this.nextPoints){if((t=l.getGraphPath.call(this,this.nextPoints))&&t.length){t[0][0]="L",a=l.getGraphPath.call(this,e),o=t.slice(0,a.length);for(let e=o.length-1;e>=0;e--)a.push(o[e])}}else a=l.getGraphPath.apply(this,arguments);return a}function u(e){let t=[];return(this.pointArrayMap||[]).forEach(a=>{t.push(e[a])}),t}function d(){let e=this.pointArrayMap,t=[],a;t=s(this),l.translate.apply(this,arguments),this.points.forEach(o=>{e.forEach((e,i)=>{a=o[e],this.dataModify&&(a=this.dataModify.modifyValue(a)),null!==a&&(o[t[i]]=this.yAxis.toPixels(a,!0))})})}e.compose=function(e){let i=e.prototype;return i.linesApiNames=i.linesApiNames||t.slice(),i.pointArrayMap=i.pointArrayMap||a.slice(),i.pointValKey=i.pointValKey||"top",i.areaLinesNames=i.areaLinesNames||o.slice(),i.drawGraph=r,i.getGraphPath=n,i.toYData=u,i.translate=d,e}}(t||(t={}));let u=t,{sma:d}=n().seriesTypes,{extend:m,isArray:y,merge:f}=i();class g extends d{init(){super.init.apply(this,arguments),this.options=f({smoothedLine:{styles:{lineColor:this.color}}},this.options)}getValues(e,t){let a=t.periods[0],o=t.periods[1],i=e.xData,r=e.yData,n=r?r.length:0,l=[],p=[],h=[],c,u,d,m=null,f,g;if(n<a||!y(r[0])||4!==r[0].length)return;let A=!0,x=0;for(g=a-1;g<n;g++){if(c=r.slice(g-a+1,g+1),u=(f=s.getArrayExtremes(c,2,1))[0],isNaN(d=(r[g][3]-u)/(f[1]-u)*100)&&A){x++;continue}A&&!isNaN(d)&&(A=!1);let e=p.push(i[g]);isNaN(d)?h.push([h[e-2]&&"number"==typeof h[e-2][0]?h[e-2][0]:null,null]):h.push([d,null]),g>=x+(a-1)+(o-1)&&(m=super.getValues({xData:p.slice(-o),yData:h.slice(-o)},{period:o}).yData[0]),l.push([i[g],d,m]),h[e-1][1]=m}return{values:l,xData:p,yData:h}}}g.defaultOptions=f(d.defaultOptions,{params:{index:void 0,period:void 0,periods:[14,3]},marker:{enabled:!1},tooltip:{pointFormat:'<span style="color:{point.color}">●</span><b> {series.name}</b><br/>%K: {point.y}<br/>%D: {point.smoothed}<br/>'},smoothedLine:{styles:{lineWidth:1,lineColor:void 0}},dataGrouping:{approximation:"averages"}}),m(g.prototype,{areaLinesNames:[],nameComponents:["periods"],nameBase:"Stochastic",pointArrayMap:["y","smoothed"],parallelArrays:["x","y","smoothed"],pointValKey:"y",linesApiNames:["smoothedLine"]}),u.compose(g),n().registerSeriesType("stochastic",g);let A=i();export{A as default};

package/assets/js/highcharts/esm/indicators/stochastic.src.js

@@ -0,0 +1,622 @@
+/**
+ * @license Highstock JS v12.2.0 (2025-04-07)
+ * @module highcharts/indicators/stochastic
+ * @requires highcharts
+ * @requires highcharts/modules/stock
+ *
+ * Indicator series type for Highcharts Stock
+ *
+ * (c) 2010-2025 Paweł Fus
+ *
+ * License: www.highcharts.com/license
+ */
+import * as __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_8202131d__ from "../highcharts.src.js";
+import * as __WEBPACK_EXTERNAL_MODULE__modules_stock_src_js_b3d80146__ from "../modules/stock.src.js";
+/******/ // The require scope
+/******/ var __webpack_require__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/compat get default export */
+/******/ (() => {
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = (module) => {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			() => (module['default']) :
+/******/ 			() => (module);
+/******/ 		__webpack_require__.d(getter, { a: getter });
+/******/ 		return getter;
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+
+;// external ["../highcharts.src.js","default"]
+const external_highcharts_src_js_default_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_8202131d__["default"];
+var external_highcharts_src_js_default_default = /*#__PURE__*/__webpack_require__.n(external_highcharts_src_js_default_namespaceObject);
+;// external "../modules/stock.src.js"
+var x = (y) => {
+	var x = {}; __webpack_require__.d(x,
+    	y); return x
+    } 
+    var y = (x) => (() => (x))
+    const stock_src_js_namespaceObject = x({  });
+;// ./code/es-modules/Stock/Indicators/ArrayUtilities.js
+/**
+ *
+ *  (c) 2010-2025 Pawel Fus & Daniel Studencki
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Get extremes of array filled by OHLC data.
+ *
+ * @private
+ *
+ * @param {Array<Array<number>>} arr
+ * Array of OHLC points (arrays).
+ *
+ * @param {number} minIndex
+ * Index of "low" value in point array.
+ *
+ * @param {number} maxIndex
+ * Index of "high" value in point array.
+ *
+ * @return {Array<number,number>}
+ * Returns array with min and max value.
+ */
+function getArrayExtremes(arr, minIndex, maxIndex) {
+    return arr.reduce((prev, target) => [
+        Math.min(prev[0], target[minIndex]),
+        Math.max(prev[1], target[maxIndex])
+    ], [Number.MAX_VALUE, -Number.MAX_VALUE]);
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+const ArrayUtilities = {
+    getArrayExtremes
+};
+/* harmony default export */ const Indicators_ArrayUtilities = (ArrayUtilities);
+
+;// external ["../highcharts.src.js","default","SeriesRegistry"]
+const external_highcharts_src_js_default_SeriesRegistry_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_8202131d__["default"].SeriesRegistry;
+var external_highcharts_src_js_default_SeriesRegistry_default = /*#__PURE__*/__webpack_require__.n(external_highcharts_src_js_default_SeriesRegistry_namespaceObject);
+;// ./code/es-modules/Stock/Indicators/MultipleLinesComposition.js
+/**
+ *
+ *  (c) 2010-2025 Wojciech Chmiel
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+
+
+const { sma: { prototype: smaProto } } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
+
+const { defined, error, merge } = (external_highcharts_src_js_default_default());
+/* *
+ *
+ *  Composition
+ *
+ * */
+var MultipleLinesComposition;
+(function (MultipleLinesComposition) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    /**
+     * Additional lines DOCS names. Elements of linesApiNames array should
+     * be consistent with DOCS line names defined in your implementation.
+     * Notice that linesApiNames should have decreased amount of elements
+     * relative to pointArrayMap (without pointValKey).
+     *
+     * @private
+     * @type {Array<string>}
+     */
+    const linesApiNames = ['bottomLine'];
+    /**
+     * Lines ids. Required to plot appropriate amount of lines.
+     * Notice that pointArrayMap should have more elements than
+     * linesApiNames, because it contains main line and additional lines ids.
+     * Also it should be consistent with amount of lines calculated in
+     * getValues method from your implementation.
+     *
+     * @private
+     * @type {Array<string>}
+     */
+    const pointArrayMap = ['top', 'bottom'];
+    /**
+     * Names of the lines, between which the area should be plotted.
+     * If the drawing of the area should
+     * be disabled for some indicators, leave this option as an empty array.
+     * Names should be the same as the names in the pointArrayMap.
+     *
+     * @private
+     * @type {Array<string>}
+     */
+    const areaLinesNames = ['top'];
+    /**
+     * Main line id.
+     *
+     * @private
+     * @type {string}
+     */
+    const pointValKey = 'top';
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Composition useful for all indicators that have more than one line.
+     * Compose it with your implementation where you will provide the
+     * `getValues` method appropriate to your indicator and `pointArrayMap`,
+     * `pointValKey`, `linesApiNames` properties. Notice that `pointArrayMap`
+     * should be consistent with the amount of lines calculated in the
+     * `getValues` method.
+     *
+     * @private
+     */
+    function compose(IndicatorClass) {
+        const proto = IndicatorClass.prototype;
+        proto.linesApiNames = (proto.linesApiNames ||
+            linesApiNames.slice());
+        proto.pointArrayMap = (proto.pointArrayMap ||
+            pointArrayMap.slice());
+        proto.pointValKey = (proto.pointValKey ||
+            pointValKey);
+        proto.areaLinesNames = (proto.areaLinesNames ||
+            areaLinesNames.slice());
+        proto.drawGraph = indicatorDrawGraph;
+        proto.getGraphPath = indicatorGetGraphPath;
+        proto.toYData = indicatorToYData;
+        proto.translate = indicatorTranslate;
+        return IndicatorClass;
+    }
+    MultipleLinesComposition.compose = compose;
+    /**
+     * Generate the API name of the line
+     *
+     * @private
+     * @param propertyName name of the line
+     */
+    function getLineName(propertyName) {
+        return ('plot' +
+            propertyName.charAt(0).toUpperCase() +
+            propertyName.slice(1));
+    }
+    /**
+     * Create translatedLines Collection based on pointArrayMap.
+     *
+     * @private
+     * @param {string} [excludedValue]
+     *        Main line id
+     * @return {Array<string>}
+     *         Returns translated lines names without excluded value.
+     */
+    function getTranslatedLinesNames(indicator, excludedValue) {
+        const translatedLines = [];
+        (indicator.pointArrayMap || []).forEach((propertyName) => {
+            if (propertyName !== excludedValue) {
+                translatedLines.push(getLineName(propertyName));
+            }
+        });
+        return translatedLines;
+    }
+    /**
+     * Draw main and additional lines.
+     *
+     * @private
+     */
+    function indicatorDrawGraph() {
+        const indicator = this, pointValKey = indicator.pointValKey, linesApiNames = indicator.linesApiNames, areaLinesNames = indicator.areaLinesNames, mainLinePoints = indicator.points, mainLineOptions = indicator.options, mainLinePath = indicator.graph, gappedExtend = {
+            options: {
+                gapSize: mainLineOptions.gapSize
+            }
+        }, 
+        // Additional lines point place holders:
+        secondaryLines = [], secondaryLinesNames = getTranslatedLinesNames(indicator, pointValKey);
+        let pointsLength = mainLinePoints.length, point;
+        // Generate points for additional lines:
+        secondaryLinesNames.forEach((plotLine, index) => {
+            // Create additional lines point place holders
+            secondaryLines[index] = [];
+            while (pointsLength--) {
+                point = mainLinePoints[pointsLength];
+                secondaryLines[index].push({
+                    x: point.x,
+                    plotX: point.plotX,
+                    plotY: point[plotLine],
+                    isNull: !defined(point[plotLine])
+                });
+            }
+            pointsLength = mainLinePoints.length;
+        });
+        // Modify options and generate area fill:
+        if (indicator.userOptions.fillColor && areaLinesNames.length) {
+            const index = secondaryLinesNames.indexOf(getLineName(areaLinesNames[0])), secondLinePoints = secondaryLines[index], firstLinePoints = areaLinesNames.length === 1 ?
+                mainLinePoints :
+                secondaryLines[secondaryLinesNames.indexOf(getLineName(areaLinesNames[1]))], originalColor = indicator.color;
+            indicator.points = firstLinePoints;
+            indicator.nextPoints = secondLinePoints;
+            indicator.color = indicator.userOptions.fillColor;
+            indicator.options = merge(mainLinePoints, gappedExtend);
+            indicator.graph = indicator.area;
+            indicator.fillGraph = true;
+            smaProto.drawGraph.call(indicator);
+            indicator.area = indicator.graph;
+            // Clean temporary properties:
+            delete indicator.nextPoints;
+            delete indicator.fillGraph;
+            indicator.color = originalColor;
+        }
+        // Modify options and generate additional lines:
+        linesApiNames.forEach((lineName, i) => {
+            if (secondaryLines[i]) {
+                indicator.points = secondaryLines[i];
+                if (mainLineOptions[lineName]) {
+                    indicator.options = merge(mainLineOptions[lineName].styles, gappedExtend);
+                }
+                else {
+                    error('Error: "There is no ' + lineName +
+                        ' in DOCS options declared. Check if linesApiNames' +
+                        ' are consistent with your DOCS line names."');
+                }
+                indicator.graph = indicator['graph' + lineName];
+                smaProto.drawGraph.call(indicator);
+                // Now save lines:
+                indicator['graph' + lineName] = indicator.graph;
+            }
+            else {
+                error('Error: "' + lineName + ' doesn\'t have equivalent ' +
+                    'in pointArrayMap. To many elements in linesApiNames ' +
+                    'relative to pointArrayMap."');
+            }
+        });
+        // Restore options and draw a main line:
+        indicator.points = mainLinePoints;
+        indicator.options = mainLineOptions;
+        indicator.graph = mainLinePath;
+        smaProto.drawGraph.call(indicator);
+    }
+    /**
+     * Create the path based on points provided as argument.
+     * If indicator.nextPoints option is defined, create the areaFill.
+     *
+     * @private
+     * @param points Points on which the path should be created
+     */
+    function indicatorGetGraphPath(points) {
+        let areaPath, path = [], higherAreaPath = [];
+        points = points || this.points;
+        // Render Span
+        if (this.fillGraph && this.nextPoints) {
+            areaPath = smaProto.getGraphPath.call(this, this.nextPoints);
+            if (areaPath && areaPath.length) {
+                areaPath[0][0] = 'L';
+                path = smaProto.getGraphPath.call(this, points);
+                higherAreaPath = areaPath.slice(0, path.length);
+                // Reverse points, so that the areaFill will start from the end:
+                for (let i = higherAreaPath.length - 1; i >= 0; i--) {
+                    path.push(higherAreaPath[i]);
+                }
+            }
+        }
+        else {
+            path = smaProto.getGraphPath.apply(this, arguments);
+        }
+        return path;
+    }
+    /**
+     * @private
+     * @param {Highcharts.Point} point
+     *        Indicator point
+     * @return {Array<number>}
+     *         Returns point Y value for all lines
+     */
+    function indicatorToYData(point) {
+        const pointColl = [];
+        (this.pointArrayMap || []).forEach((propertyName) => {
+            pointColl.push(point[propertyName]);
+        });
+        return pointColl;
+    }
+    /**
+     * Add lines plot pixel values.
+     *
+     * @private
+     */
+    function indicatorTranslate() {
+        const pointArrayMap = this.pointArrayMap;
+        let LinesNames = [], value;
+        LinesNames = getTranslatedLinesNames(this);
+        smaProto.translate.apply(this, arguments);
+        this.points.forEach((point) => {
+            pointArrayMap.forEach((propertyName, i) => {
+                value = point[propertyName];
+                // If the modifier, like for example compare exists,
+                // modified the original value by that method, #15867.
+                if (this.dataModify) {
+                    value = this.dataModify.modifyValue(value);
+                }
+                if (value !== null) {
+                    point[LinesNames[i]] = this.yAxis.toPixels(value, true);
+                }
+            });
+        });
+    }
+})(MultipleLinesComposition || (MultipleLinesComposition = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const Indicators_MultipleLinesComposition = (MultipleLinesComposition);
+
+;// ./code/es-modules/Stock/Indicators/Stochastic/StochasticIndicator.js
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+
+
+
+
+const { sma: SMAIndicator } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
+
+const { extend, isArray, merge: StochasticIndicator_merge } = (external_highcharts_src_js_default_default());
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * The Stochastic series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.stochastic
+ *
+ * @augments Highcharts.Series
+ */
+class StochasticIndicator extends SMAIndicator {
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    init() {
+        super.init.apply(this, arguments);
+        // Set default color for lines:
+        this.options = StochasticIndicator_merge({
+            smoothedLine: {
+                styles: {
+                    lineColor: this.color
+                }
+            }
+        }, this.options);
+    }
+    getValues(series, params) {
+        const periodK = params.periods[0], periodD = params.periods[1], xVal = series.xData, yVal = series.yData, yValLen = yVal ? yVal.length : 0, 
+        // 0- date, 1-%K, 2-%D
+        SO = [], xData = [], yData = [], close = 3, low = 2, high = 1;
+        let slicedY, CL, HL, LL, K, D = null, points, extremes, i;
+        // Stochastic requires close value
+        if (yValLen < periodK ||
+            !isArray(yVal[0]) ||
+            yVal[0].length !== 4) {
+            return;
+        }
+        // If the value of initial points is constant, wait until it changes
+        // to calculate correct Stochastic values
+        let constantValues = true, j = 0;
+        // For a N-period, we start from N-1 point, to calculate Nth point
+        // That is why we later need to comprehend slice() elements list
+        // with (+1)
+        for (i = periodK - 1; i < yValLen; i++) {
+            slicedY = yVal.slice(i - periodK + 1, i + 1);
+            // Calculate %K
+            extremes = Indicators_ArrayUtilities.getArrayExtremes(slicedY, low, high);
+            LL = extremes[0]; // Lowest low in %K periods
+            CL = yVal[i][close] - LL;
+            HL = extremes[1] - LL;
+            K = CL / HL * 100;
+            if (isNaN(K) && constantValues) {
+                j++;
+                continue;
+            }
+            else if (constantValues && !isNaN(K)) {
+                constantValues = false;
+            }
+            const length = xData.push(xVal[i]);
+            // If N-period previous values are constant which results in NaN %K,
+            // we need to use previous %K value if it is a number,
+            // otherwise we should use null
+            if (isNaN(K)) {
+                yData.push([
+                    yData[length - 2] &&
+                        typeof yData[length - 2][0] === 'number' ?
+                        yData[length - 2][0] : null,
+                    null
+                ]);
+            }
+            else {
+                yData.push([K, null]);
+            }
+            // Calculate smoothed %D, which is SMA of %K
+            if (i >= j + (periodK - 1) + (periodD - 1)) {
+                points = super.getValues({
+                    xData: xData.slice(-periodD),
+                    yData: yData.slice(-periodD)
+                }, {
+                    period: periodD
+                });
+                D = points.yData[0];
+            }
+            SO.push([xVal[i], K, D]);
+            yData[length - 1][1] = D;
+        }
+        return {
+            values: SO,
+            xData: xData,
+            yData: yData
+        };
+    }
+}
+/* *
+ *
+ *  Static Properties
+ *
+ * */
+/**
+ * Stochastic oscillator. This series requires the `linkedTo` option to be
+ * set and should be loaded after the `stock/indicators/indicators.js` file.
+ *
+ * @sample stock/indicators/stochastic
+ *         Stochastic oscillator
+ *
+ * @extends      plotOptions.sma
+ * @since        6.0.0
+ * @product      highstock
+ * @excluding    allAreas, colorAxis, joinBy, keys, navigatorOptions,
+ *               pointInterval, pointIntervalUnit, pointPlacement,
+ *               pointRange, pointStart, showInNavigator, stacking
+ * @requires     stock/indicators/indicators
+ * @requires     stock/indicators/stochastic
+ * @optionparent plotOptions.stochastic
+ */
+StochasticIndicator.defaultOptions = StochasticIndicator_merge(SMAIndicator.defaultOptions, {
+    /**
+     * @excluding index, period
+     */
+    params: {
+        // Index and period are unchangeable, do not inherit (#15362)
+        index: void 0,
+        period: void 0,
+        /**
+         * Periods for Stochastic oscillator: [%K, %D].
+         *
+         * @type    {Array<number,number>}
+         * @default [14, 3]
+         */
+        periods: [14, 3]
+    },
+    marker: {
+        enabled: false
+    },
+    tooltip: {
+        pointFormat: '<span style="color:{point.color}">\u25CF</span><b> {series.name}</b><br/>%K: {point.y}<br/>%D: {point.smoothed}<br/>'
+    },
+    /**
+     * Smoothed line options.
+     */
+    smoothedLine: {
+        /**
+         * Styles for a smoothed line.
+         */
+        styles: {
+            /**
+             * Pixel width of the line.
+             */
+            lineWidth: 1,
+            /**
+             * Color of the line. If not set, it's inherited from
+             * [plotOptions.stochastic.color
+             * ](#plotOptions.stochastic.color).
+             *
+             * @type {Highcharts.ColorString}
+             */
+            lineColor: void 0
+        }
+    },
+    dataGrouping: {
+        approximation: 'averages'
+    }
+});
+extend(StochasticIndicator.prototype, {
+    areaLinesNames: [],
+    nameComponents: ['periods'],
+    nameBase: 'Stochastic',
+    pointArrayMap: ['y', 'smoothed'],
+    parallelArrays: ['x', 'y', 'smoothed'],
+    pointValKey: 'y',
+    linesApiNames: ['smoothedLine']
+});
+Indicators_MultipleLinesComposition.compose(StochasticIndicator);
+external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('stochastic', StochasticIndicator);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const Stochastic_StochasticIndicator = ((/* unused pure expression or super */ null && (StochasticIndicator)));
+/* *
+ *
+ *  API Options
+ *
+ * */
+/**
+ * A Stochastic indicator. If the [type](#series.stochastic.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.stochastic
+ * @since     6.0.0
+ * @product   highstock
+ * @excluding allAreas, colorAxis,  dataParser, dataURL, joinBy, keys,
+ *            navigatorOptions, pointInterval, pointIntervalUnit,
+ *            pointPlacement, pointRange, pointStart, showInNavigator, stacking
+ * @requires  stock/indicators/indicators
+ * @requires  stock/indicators/stochastic
+ * @apioption series.stochastic
+ */
+''; // To include the above in the js output
+
+;// ./code/es-modules/masters/indicators/stochastic.src.js
+
+
+
+
+
+/* harmony default export */ const stochastic_src = ((external_highcharts_src_js_default_default()));
+
+export { stochastic_src as default };

package/assets/js/highcharts/esm/indicators/supertrend.js

@@ -0,0 +1 @@
+import*as o from"../highcharts.js";import"../modules/stock.js";var e={};e.n=o=>{var l=o&&o.__esModule?()=>o.default:()=>o;return e.d(l,{a:l}),l},e.d=(o,l)=>{for(var t in l)e.o(l,t)&&!e.o(o,t)&&Object.defineProperty(o,t,{enumerable:!0,get:l[t]})},e.o=(o,e)=>Object.prototype.hasOwnProperty.call(o,e);let l=o.default;var t=e.n(l);e.d({},{});let r=o.default.SeriesRegistry;var s=e.n(r);let{atr:n,sma:i}=s().seriesTypes,{addEvent:p,correctFloat:a,isArray:d,isNumber:c,extend:h,merge:u,objectEach:g}=t();function x(o,e){return{index:e,close:o.getColumn("close")[e],x:o.getColumn("x")[e]}}class y extends i{init(){let o=this;super.init.apply(o,arguments);let e=p(this.chart.constructor,"afterLinkSeries",()=>{if(o.options){let e=o.options;e.cropThreshold=o.linkedParent.options.cropThreshold-(e.params.period-1)}e()},{order:1})}drawGraph(){let o=this,e=o.options,l=o.linkedParent,t=l.getColumn("x"),r=l?l.points:[],s=o.points,n=o.graph,p=r.length-s.length,a=p>0?p:0,d={options:{gapSize:e.gapSize}},h={top:[],bottom:[],intersect:[]},y={top:{styles:{lineWidth:e.lineWidth,lineColor:e.fallingTrendColor||e.color,dashStyle:e.dashStyle}},bottom:{styles:{lineWidth:e.lineWidth,lineColor:e.risingTrendColor||e.color,dashStyle:e.dashStyle}},intersect:e.changeTrendLine},m,f,C,T,S,b,v,D,L,N=s.length;for(;N--;)m=s[N],f=s[N-1],C=r[N-1+a],T=r[N-2+a],S=r[N+a],b=r[N+a+1],v=m.options.color,D={x:m.x,plotX:m.plotX,plotY:m.plotY,isNull:!1},!T&&C&&c(t[C.index-1])&&(T=x(l,C.index-1)),!b&&S&&c(t[S.index+1])&&(b=x(l,S.index+1)),!C&&T&&c(t[T.index+1])?C=x(l,T.index+1):!C&&S&&c(t[S.index-1])&&(C=x(l,S.index-1)),m&&C&&S&&T&&m.x!==C.x&&(m.x===S.x?(T=C,C=S):m.x===T.x?(C=T,T={close:l.getColumn("close")[C.index-1],x:t[C.index-1]}):b&&m.x===b.x&&(C=b,T=S)),f&&T&&C?(L={x:f.x,plotX:f.plotX,plotY:f.plotY,isNull:!1},m.y>=C.close&&f.y>=T.close?(m.color=v||e.fallingTrendColor||e.color,h.top.push(D)):m.y<C.close&&f.y<T.close?(m.color=v||e.risingTrendColor||e.color,h.bottom.push(D)):(h.intersect.push(D),h.intersect.push(L),h.intersect.push(u(L,{isNull:!0})),m.y>=C.close&&f.y<T.close?(m.color=v||e.fallingTrendColor||e.color,f.color=v||e.risingTrendColor||e.color,h.top.push(D),h.top.push(u(L,{isNull:!0}))):m.y<C.close&&f.y>=T.close&&(m.color=v||e.risingTrendColor||e.color,f.color=v||e.fallingTrendColor||e.color,h.bottom.push(D),h.bottom.push(u(L,{isNull:!0}))))):C&&(m.y>=C.close?(m.color=v||e.fallingTrendColor||e.color,h.top.push(D)):(m.color=v||e.risingTrendColor||e.color,h.bottom.push(D)));g(h,function(e,l){o.points=e,o.options=u(y[l].styles,d),o.graph=o["graph"+l+"Line"],i.prototype.drawGraph.call(o),o["graph"+l+"Line"]=o.graph}),o.points=s,o.options=e,o.graph=n}getValues(o,e){let l=e.period,t=e.multiplier,r=o.xData,s=o.yData,i=[],p=[],c=[],h=0===l?0:l-1,u=[],g=[],x=[],y,m,f,C,T,S,b,v,D;if(!(r.length<=l)&&d(s[0])&&4===s[0].length&&!(l<0)){for(D=0,x=n.prototype.getValues.call(this,o,{period:l}).yData;D<x.length;D++)v=s[h+D],b=s[h+D-1]||[],C=u[D-1],T=g[D-1],S=c[D-1],0===D&&(C=T=S=0),y=a((v[1]+v[2])/2+t*x[D]),m=a((v[1]+v[2])/2-t*x[D]),y<C||b[3]>C?u[D]=y:u[D]=C,m>T||b[3]<T?g[D]=m:g[D]=T,S===C&&v[3]<u[D]||S===T&&v[3]<g[D]?f=u[D]:(S===C&&v[3]>u[D]||S===T&&v[3]>g[D])&&(f=g[D]),i.push([r[h+D],f]),p.push(r[h+D]),c.push(f);return{values:i,xData:p,yData:c}}}}y.defaultOptions=u(i.defaultOptions,{params:{index:void 0,multiplier:3,period:10},risingTrendColor:"#06b535",fallingTrendColor:"#f21313",changeTrendLine:{styles:{lineWidth:1,lineColor:"#333333",dashStyle:"LongDash"}}}),h(y.prototype,{nameBase:"Supertrend",nameComponents:["multiplier","period"]}),s().registerSeriesType("supertrend",y);let m=t();export{m as default};