text: /**
   * @license  Highcharts JS v6.2.0 (2018-10-17)
   *
   * Parabolic SAR Indicator for Highstock
   *
   * (c) 2010-2017 Grzegorz Blachliński
   *
   * License: www.highcharts.com/license
   */
  'use strict';
  (function (factory) {
  	if (typeof module === 'object' && module.exports) {
  		module.exports = factory;
  	} else if (typeof define === 'function' && define.amd) {
  		define(function () {
  			return factory;
  		});
  	} else {
  		factory(Highcharts);
  	}
  }(function (Highcharts) {
  	(function (H) {
  
  
  
  
  		// Utils:
  
  		function toFixed(a, n) {
  		    return parseFloat(a.toFixed(n));
  		}
  
  		function calculateDirection(previousDirection, low, high, PSAR) {
  		    if (
  		        (previousDirection === 1 && low > PSAR) ||
  		        (previousDirection === -1 && high > PSAR)
  		    ) {
  		        return 1;
  		    }
  		    return -1;
  		}
  
  		/*
  		 * Method for calculating acceleration factor
  		 * dir - direction
  		 * pDir - previous Direction
  		 * eP - extreme point
  		 * pEP - previous extreme point
  		 * inc - increment for acceleration factor
  		 * maxAcc - maximum acceleration factor
  		 * initAcc - initial acceleration factor
  		 */
  		function getAccelerationFactor(dir, pDir, eP, pEP, pAcc, inc, maxAcc, initAcc) {
  		    if (dir === pDir) {
  		        if (dir === 1 && (eP > pEP)) {
  		            return (pAcc === maxAcc) ? maxAcc : toFixed(pAcc + inc, 2);
  		        } else if (dir === -1 && (eP < pEP)) {
  		            return (pAcc === maxAcc) ? maxAcc : toFixed(pAcc + inc, 2);
  		        }
  		        return pAcc;
  		    }
  		    return initAcc;
  		}
  
  		function getExtremePoint(high, low, previousDirection, previousExtremePoint) {
  		    if (previousDirection === 1) {
  		        return (high > previousExtremePoint) ? high : previousExtremePoint;
  		    }
  		    return (low < previousExtremePoint) ? low : previousExtremePoint;
  		}
  
  		function getEPMinusPSAR(EP, PSAR) {
  		    return EP - PSAR;
  		}
  
  		function getAccelerationFactorMultiply(accelerationFactor, EPMinusSAR) {
  		    return accelerationFactor * EPMinusSAR;
  		}
  
  		/*
  		 * Method for calculating PSAR
  		 * pdir - previous direction
  		 * sDir - second previous Direction
  		 * PSAR - previous PSAR
  		 * pACCMultiply - previous acceleration factor multiply
  		 * sLow - second previous low
  		 * pLow - previous low
  		 * sHigh - second previous high
  		 * pHigh - previous high
  		 * pEP - previous extreme point
  		 */
  		function getPSAR(pdir, sDir, PSAR, pACCMulti, sLow, pLow, pHigh, sHigh, pEP) {
  		    if (pdir === sDir) {
  		        if (pdir === 1) {
  		            return (PSAR + pACCMulti < Math.min(sLow, pLow)) ?
  		                PSAR + pACCMulti :
  		                Math.min(sLow, pLow);
  		        }
  		        return (PSAR + pACCMulti > Math.max(sHigh, pHigh)) ?
  		            PSAR + pACCMulti :
  		            Math.max(sHigh, pHigh);
  		    }
  		    return pEP;
  		}
  
  
  
  		/**
  		 * The Parabolic SAR series type.
  		 *
  		 * @constructor seriesTypes.psar
  		 * @augments seriesTypes.sma
  		 */
  		H.seriesType('psar', 'sma',
  
  		    /**
  		     * Parabolic SAR. This series requires `linkedTo`
  		     * option to be set and should be loaded
  		     * after `stock/indicators/indicators.js` file.
  		     *
  		     * @extends plotOptions.sma
  		     * @product highstock
  		     * @sample {highstock} stock/indicators/psar
  		     *                     Parabolic SAR Indicator
  		     * @since 6.0.0
  		     * @optionparent plotOptions.psar
  		     */
  
  		    {
  		        lineWidth: 0,
  		        marker: {
  		            enabled: true
  		        },
  		        states: {
  		            hover: {
  		                lineWidthPlus: 0
  		            }
  		        },
  		        /**
  		         * @excluding period
  		         */
  		        params: {
  		            /**
  		             * The initial value for acceleration factor.
  		             * Acceleration factor is starting with this value
  		             * and increases by specified increment each time
  		             * the extreme point makes a new high.
  		             * AF can reach a maximum of maxAccelerationFactor,
  		             * no matter how long the uptrend extends.
  		             *
  		             * @type {Number}
  		             * @since 6.0.0
  		             * @excluding period
  		             * @product highstock
  		             */
  		            initialAccelerationFactor: 0.02,
  		            /**
  		             * The Maximum value for acceleration factor.
  		             * AF can reach a maximum of maxAccelerationFactor,
  		             * no matter how long the uptrend extends.
  		             *
  		             * @type {Number}
  		             * @since 6.0.0
  		             * @product highstock
  		             */
  		            maxAccelerationFactor: 0.2,
  		            /**
  		             * Acceleration factor increases by increment each time
  		             * the extreme point makes a new high.
  		             *
  		             * @type {Number}
  		             * @since 6.0.0
  		             * @product highstock
  		             */
  		            increment: 0.02,
  		            /**
  		             * Index from which PSAR is starting calculation
  		             *
  		             * @type {Number}
  		             * @since 6.0.0
  		             * @product highstock
  		             */
  		            index: 2,
  		            /**
  		             * Number of maximum decimals that are used in PSAR calculations.
  		             *
  		             * @type {Number}
  		             * @since 6.0.0
  		             * @product highstock
  		             */
  		            decimals: 4
  		        }
  		    }, {
  		        nameComponents: false,
  		        getValues: function (series, params) {
  		            var xVal = series.xData,
  		                yVal = series.yData,
  		                // Extreme point is the lowest low for falling and highest high
  		                // for rising psar - and we are starting with falling
  		                extremePoint = yVal[0][1],
  		                accelerationFactor = params.initialAccelerationFactor,
  		                maxAccelerationFactor = params.maxAccelerationFactor,
  		                increment = params.increment,
  		                // Set initial acc factor (for every new trend!)
  		                initialAccelerationFactor = params.initialAccelerationFactor,
  		                PSAR = yVal[0][2],
  		                decimals = params.decimals,
  		                index = params.index,
  		                PSARArr = [],
  		                xData = [],
  		                yData = [],
  		                previousDirection = 1,
  		                direction, EPMinusPSAR, accelerationFactorMultiply,
  		                newDirection,
  		                prevLow,
  		                prevPrevLow,
  		                prevHigh,
  		                prevPrevHigh,
  		                newExtremePoint,
  		                high, low, ind;
  
  		            if (index >= yVal.length) {
  		                return false;
  		            }
  
  		            for (ind = 0; ind < index; ind++) {
  		                extremePoint = Math.max(yVal[ind][1], extremePoint);
  		                PSAR = Math.min(yVal[ind][2], toFixed(PSAR, decimals));
  		            }
  
  		            direction = (yVal[ind][1] > PSAR) ? 1 : -1;
  		            EPMinusPSAR = getEPMinusPSAR(extremePoint, PSAR);
  		            accelerationFactor = params.initialAccelerationFactor;
  		            accelerationFactorMultiply = getAccelerationFactorMultiply(
  		                accelerationFactor,
  		                EPMinusPSAR
  		            );
  
  		            PSARArr.push([xVal[index], PSAR]);
  		            xData.push(xVal[index]);
  		            yData.push(toFixed(PSAR, decimals));
  
  		            for (ind = index + 1; ind < yVal.length; ind++) {
  
  		                prevLow = yVal[ind - 1][2];
  		                prevPrevLow = yVal[ind - 2][2];
  		                prevHigh = yVal[ind - 1][1];
  		                prevPrevHigh = yVal[ind - 2][1];
  		                high = yVal[ind][1];
  		                low = yVal[ind][2];
  
  		                // Null points break PSAR
  		                if (
  		                    prevPrevLow !== null &&
  		                    prevPrevHigh !== null &&
  		                    prevLow !== null &&
  		                    prevHigh !== null &&
  		                    high !== null &&
  		                    low !== null
  		                ) {
  		                    PSAR = getPSAR(
  		                        direction,
  		                        previousDirection,
  		                        PSAR,
  		                        accelerationFactorMultiply,
  		                        prevPrevLow,
  		                        prevLow,
  		                        prevHigh,
  		                        prevPrevHigh,
  		                        extremePoint
  		                    );
  
  
  		                    newExtremePoint = getExtremePoint(
  		                        high,
  		                        low,
  		                        direction,
  		                        extremePoint
  		                    );
  		                    newDirection = calculateDirection(
  		                        previousDirection,
  		                        low,
  		                        high,
  		                        PSAR
  		                    );
  		                    accelerationFactor = getAccelerationFactor(
  		                        newDirection,
  		                        direction,
  		                        newExtremePoint,
  		                        extremePoint,
  		                        accelerationFactor,
  		                        increment,
  		                        maxAccelerationFactor,
  		                        initialAccelerationFactor
  		                    );
  
  		                    EPMinusPSAR = getEPMinusPSAR(newExtremePoint, PSAR);
  		                    accelerationFactorMultiply = getAccelerationFactorMultiply(
  		                        accelerationFactor,
  		                        EPMinusPSAR
  		                    );
  		                    PSARArr.push([xVal[ind], toFixed(PSAR, decimals)]);
  		                    xData.push(xVal[ind]);
  		                    yData.push(toFixed(PSAR, decimals));
  
  		                    previousDirection = direction;
  		                    direction = newDirection;
  		                    extremePoint = newExtremePoint;
  		                }
  		            }
  		            return {
  		                values: PSARArr,
  		                xData: xData,
  		                yData: yData
  		            };
  		        }
  		    }
  		);
  
  		/**
  		 * A `PSAR` series. If the [type](#series.psar.type) option is not
  		 * specified, it is inherited from [chart.type](#chart.type).
  		 *
  		 * @type {Object}
  		 * @since 6.0.0
  		 * @extends series,plotOptions.psar
  		 * @excluding data,dataParser,dataURL
  		 * @product highstock
  		 * @apioption series.psar
  		 */
  
  		/**
  		 * An array of data points for the series. For the `psar` series type,
  		 * points are calculated dynamically.
  		 *
  		 * @type {Array<Object|Array>}
  		 * @since 6.0.0
  		 * @extends series.line.data
  		 * @product highstock
  		 * @apioption series.psar.data
  		 */
  
  	}(Highcharts));
  	return (function () {
  
  
  	}());
  }));
  