text: /**
   * @license Highstock JS v9.2.2 (2021-08-24)
   *
   * Indicator series type for Highcharts Stock
   *
   * (c) 2010-2021 Wojciech Chmiel
   *
   * License: www.highcharts.com/license
   */
  'use strict';
  (function (factory) {
      if (typeof module === 'object' && module.exports) {
          factory['default'] = factory;
          module.exports = factory;
      } else if (typeof define === 'function' && define.amd) {
          define('highcharts/indicators/aroon-oscillator', ['highcharts', 'highcharts/modules/stock'], function (Highcharts) {
              factory(Highcharts);
              factory.Highcharts = Highcharts;
              return factory;
          });
      } else {
          factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
      }
  }(function (Highcharts) {
      var _modules = Highcharts ? Highcharts._modules : {};
      function _registerModule(obj, path, args, fn) {
          if (!obj.hasOwnProperty(path)) {
              obj[path] = fn.apply(null, args);
          }
      }
      _registerModule(_modules, 'Mixins/MultipleLines.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
          /**
           *
           *  (c) 2010-2021 Wojciech Chmiel
           *
           *  License: www.highcharts.com/license
           *
           *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
           *
           * */
          var defined = U.defined,
              error = U.error,
              merge = U.merge;
          var SMA = H.seriesTypes.sma;
          /**
           * Mixin useful for all indicators that have more than one line.
           * Merge it with your implementation where you will provide
           * getValues method appropriate to your indicator and pointArrayMap,
           * pointValKey, linesApiNames properites. Notice that pointArrayMap
           * should be consistent with amount of lines calculated in getValues method.
           *
           * @private
           * @mixin multipleLinesMixin
           */
          var multipleLinesMixin = {
                  /* eslint-disable valid-jsdoc */
                  /**
                   * 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
                   * @name multipleLinesMixin.pointArrayMap
                   * @type {Array<string>}
                   */
                  pointArrayMap: ['top', 'bottom'],
                  /**
                   * Main line id.
                   *
                   * @private
                   * @name multipleLinesMixin.pointValKey
                   * @type {string}
                   */
                  pointValKey: 'top',
                  /**
                   * 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
                   * @name multipleLinesMixin.linesApiNames
                   * @type {Array<string>}
                   */
                  linesApiNames: ['bottomLine'],
                  /**
                   * Create translatedLines Collection based on pointArrayMap.
                   *
                   * @private
                   * @function multipleLinesMixin.getTranslatedLinesNames
                   * @param {string} [excludedValue]
                   *        Main line id
                   * @return {Array<string>}
                   *         Returns translated lines names without excluded value.
                   */
                  getTranslatedLinesNames: function (excludedValue) {
                      var translatedLines = [];
                  (this.pointArrayMap || []).forEach(function (propertyName) {
                      if (propertyName !== excludedValue) {
                          translatedLines.push('plot' +
                              propertyName.charAt(0).toUpperCase() +
                              propertyName.slice(1));
                      }
                  });
                  return translatedLines;
              },
              /**
               * @private
               * @function multipleLinesMixin.toYData
               * @param {Highcharts.Point} point
               *        Indicator point
               * @return {Array<number>}
               *         Returns point Y value for all lines
               */
              toYData: function (point) {
                  var pointColl = [];
                  (this.pointArrayMap || []).forEach(function (propertyName) {
                      pointColl.push(point[propertyName]);
                  });
                  return pointColl;
              },
              /**
               * Add lines plot pixel values.
               *
               * @private
               * @function multipleLinesMixin.translate
               * @return {void}
               */
              translate: function () {
                  var indicator = this,
                      pointArrayMap = indicator.pointArrayMap,
                      LinesNames = [],
                      value;
                  var modfidyValue = indicator.modifyValue;
                  LinesNames = indicator.getTranslatedLinesNames();
                  SMA.prototype.translate.apply(indicator, arguments);
                  indicator.points.forEach(function (point) {
                      pointArrayMap.forEach(function (propertyName, i) {
                          value = point[propertyName];
                          // If the modifier, like for example compare exists,
                          // modified the original value by that method, #15867.
                          if (modfidyValue) {
                              value = modfidyValue.call(indicator, value);
                          }
                          if (value !== null) {
                              point[LinesNames[i]] = indicator.yAxis.toPixels(value, true);
                          }
                      });
                  });
              },
              /**
               * Draw main and additional lines.
               *
               * @private
               * @function multipleLinesMixin.drawGraph
               * @return {void}
               */
              drawGraph: function () {
                  var indicator = this,
                      pointValKey = indicator.pointValKey,
                      linesApiNames = indicator.linesApiNames,
                      mainLinePoints = indicator.points,
                      pointsLength = mainLinePoints.length,
                      mainLineOptions = indicator.options,
                      mainLinePath = indicator.graph,
                      gappedExtend = {
                          options: {
                              gapSize: mainLineOptions.gapSize
                          }
                      }, 
                      // additional lines point place holders:
                      secondaryLines = [],
                      secondaryLinesNames = indicator.getTranslatedLinesNames(pointValKey),
                      point;
                  // Generate points for additional lines:
                  secondaryLinesNames.forEach(function (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 additional lines:
                  linesApiNames.forEach(function (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."' +
                                  ' at mixin/multiple-line.js:34');
                          }
                          indicator.graph = indicator['graph' + lineName];
                          SMA.prototype.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;
                  SMA.prototype.drawGraph.call(indicator);
              }
          };
  
          return multipleLinesMixin;
      });
      _registerModule(_modules, 'Mixins/IndicatorRequired.js', [_modules['Core/Utilities.js']], function (U) {
          /**
           *
           *  (c) 2010-2021 Daniel Studencki
           *
           *  License: www.highcharts.com/license
           *
           *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
           *
           * */
          var error = U.error;
          /* eslint-disable no-invalid-this, valid-jsdoc */
          var requiredIndicatorMixin = {
                  /**
                   * Check whether given indicator is loaded,
              else throw error.
                   * @private
                   * @param {Highcharts.Indicator} indicator
                   *        Indicator constructor function.
                   * @param {string} requiredIndicator
                   *        Required indicator type.
                   * @param {string} type
                   *        Type of indicator where function was called (parent).
                   * @param {Highcharts.IndicatorCallbackFunction} callback
                   *        Callback which is triggered if the given indicator is loaded.
                   *        Takes indicator as an argument.
                   * @param {string} errMessage
                   *        Error message that will be logged in console.
                   * @return {boolean}
                   *         Returns false when there is no required indicator loaded.
                   */
                  isParentLoaded: function (indicator,
              requiredIndicator,
              type,
              callback,
              errMessage) {
                      if (indicator) {
                          return callback ? callback(indicator) : true;
                  }
                  error(errMessage || this.generateMessage(type, requiredIndicator));
                  return false;
              },
              /**
               * @private
               * @param {string} indicatorType
               *        Indicator type
               * @param {string} required
               *        Required indicator
               * @return {string}
               *         Error message
               */
              generateMessage: function (indicatorType, required) {
                  return 'Error: "' + indicatorType +
                      '" indicator type requires "' + required +
                      '" indicator loaded before. Please read docs: ' +
                      'https://api.highcharts.com/highstock/plotOptions.' +
                      indicatorType;
              }
          };
  
          return requiredIndicatorMixin;
      });
      _registerModule(_modules, 'Stock/Indicators/AroonOscillator/AroonOscillatorIndicator.js', [_modules['Mixins/MultipleLines.js'], _modules['Mixins/IndicatorRequired.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (multipleLinesMixin, requiredIndicator, SeriesRegistry, U) {
          /* *
           *
           *  License: www.highcharts.com/license
           *
           *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
           *
           * */
          var __extends = (this && this.__extends) || (function () {
                  var extendStatics = function (d,
              b) {
                      extendStatics = Object.setPrototypeOf ||
                          ({ __proto__: [] } instanceof Array && function (d,
              b) { d.__proto__ = b; }) ||
                          function (d,
              b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
                  return extendStatics(d, b);
              };
              return function (d, b) {
                  extendStatics(d, b);
                  function __() { this.constructor = d; }
                  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
              };
          })();
          var AroonIndicator = SeriesRegistry.seriesTypes.aroon;
          var extend = U.extend,
              merge = U.merge;
          var AROON = SeriesRegistry.seriesTypes.aroon;
          /* *
           *
           *  Class
           *
           * */
          /**
           * The Aroon Oscillator series type.
           *
           * @private
           * @class
           * @name Highcharts.seriesTypes.aroonoscillator
           *
           * @augments Highcharts.Series
           */
          var AroonOscillatorIndicator = /** @class */ (function (_super) {
                  __extends(AroonOscillatorIndicator, _super);
              function AroonOscillatorIndicator() {
                  var _this = _super !== null && _super.apply(this,
                      arguments) || this;
                  /* *
                   *
                   *  Properties
                   *
                   * */
                  _this.data = void 0;
                  _this.options = void 0;
                  _this.points = void 0;
                  return _this;
              }
              /* *
               *
               *  Functions
               *
               * */
              AroonOscillatorIndicator.prototype.getValues = function (series, params) {
                  // 0- date, 1- Aroon Oscillator
                  var ARO = [],
                      xData = [],
                      yData = [],
                      aroon,
                      aroonUp,
                      aroonDown,
                      oscillator,
                      i;
                  aroon = AROON.prototype.getValues.call(this, series, params);
                  for (i = 0; i < aroon.yData.length; i++) {
                      aroonUp = aroon.yData[i][0];
                      aroonDown = aroon.yData[i][1];
                      oscillator = aroonUp - aroonDown;
                      ARO.push([aroon.xData[i], oscillator]);
                      xData.push(aroon.xData[i]);
                      yData.push(oscillator);
                  }
                  return {
                      values: ARO,
                      xData: xData,
                      yData: yData
                  };
              };
              AroonOscillatorIndicator.prototype.init = function () {
                  var args = arguments,
                      ctx = this;
                  requiredIndicator.isParentLoaded(AROON, 'aroon', ctx.type, function (indicator) {
                      indicator.prototype.init.apply(ctx, args);
                      return;
                  });
              };
              /**
               * Aroon Oscillator. This series requires the `linkedTo` option to be set
               * and should be loaded after the `stock/indicators/indicators.js` and
               * `stock/indicators/aroon.js`.
               *
               * @sample {highstock} stock/indicators/aroon-oscillator
               *         Aroon Oscillator
               *
               * @extends      plotOptions.aroon
               * @since        7.0.0
               * @product      highstock
               * @excluding    allAreas, aroonDown, colorAxis, compare, compareBase,
               *               joinBy, keys, navigatorOptions, pointInterval,
               *               pointIntervalUnit, pointPlacement, pointRange, pointStart,
               *               showInNavigator, stacking
               * @requires     stock/indicators/indicators
               * @requires     stock/indicators/aroon
               * @requires     stock/indicators/aroon-oscillator
               * @optionparent plotOptions.aroonoscillator
               */
              AroonOscillatorIndicator.defaultOptions = merge(AroonIndicator.defaultOptions, {
                  tooltip: {
                      pointFormat: '<span style="color:{point.color}">\u25CF</span><b> {series.name}</b>: {point.y}'
                  }
              });
              return AroonOscillatorIndicator;
          }(AroonIndicator));
          extend(AroonOscillatorIndicator.prototype, merge(multipleLinesMixin, {
              nameBase: 'Aroon Oscillator',
              pointArrayMap: ['y'],
              pointValKey: 'y',
              linesApiNames: []
          }));
          SeriesRegistry.registerSeriesType('aroonoscillator', AroonOscillatorIndicator);
          /* *
           *
           *  Default Export
           *
           * */
          /**
           * An `Aroon Oscillator` series. If the [type](#series.aroonoscillator.type)
           * option is not specified, it is inherited from [chart.type](#chart.type).
           *
           * @extends   series,plotOptions.aroonoscillator
           * @since     7.0.0
           * @product   highstock
           * @excluding allAreas, aroonDown, colorAxis, compare, compareBase, dataParser,
           *            dataURL, joinBy, keys, navigatorOptions, pointInterval,
           *            pointIntervalUnit, pointPlacement, pointRange, pointStart,
           *            showInNavigator, stacking
           * @requires  stock/indicators/indicators
           * @requires  stock/indicators/aroon
           * @requires  stock/indicators/aroon-oscillator
           * @apioption series.aroonoscillator
           */
          ''; // adds doclet above to the transpiled file
  
          return AroonOscillatorIndicator;
      });
      _registerModule(_modules, 'masters/indicators/aroon-oscillator.src.js', [], function () {
  
  
      });
  }));