text: /**
   * @license Highcharts JS v8.0.0 (2019-12-10)
   *
   * Timeline series
   *
   * (c) 2010-2019 Highsoft AS
   * Author: Daniel Studencki
   *
   * 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/modules/timeline', ['highcharts'], 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, 'modules/timeline.src.js', [_modules['parts/Globals.js'], _modules['parts/Utilities.js']], function (H, U) {
          /* *
           *
           *  Timeline Series.
           *
           *  (c) 2010-2019 Highsoft AS
           *
           *  Author: Daniel Studencki
           *
           *  License: www.highcharts.com/license
           *
           *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
           *
           * */
          /**
           * Callback JavaScript function to format the data label as a string. Note that
           * if a `format` is defined, the format takes precedence and the formatter is
           * ignored.
           *
           * @callback Highcharts.TimelineDataLabelsFormatterCallbackFunction
           *
           * @param {Highcharts.DataLabelsFormatterContextObject|Highcharts.TimelineDataLabelsFormatterContextObject} this
           *        Data label context to format
           *
           * @return {number|string|null|undefined}
           *         Formatted data label text
           */
          /**
           * @interface Highcharts.TimelineDataLabelsFormatterContextObject
           * @extends Highcharts.DataLabelsFormatterContextObject
           */ /**
          * @name Highcharts.TimelineDataLabelsFormatterContextObject#key
          * @type {string|undefined}
          */ /**
          * @name Highcharts.TimelineDataLabelsFormatterContextObject#point
          * @type {Highcharts.Point}
          */ /**
          * @name Highcharts.TimelineDataLabelsFormatterContextObject#series
          * @type {Highcharts.Series}
          */
          var arrayMax = U.arrayMax, arrayMin = U.arrayMin, defined = U.defined, isNumber = U.isNumber, objectEach = U.objectEach, pick = U.pick;
          var addEvent = H.addEvent, LegendSymbolMixin = H.LegendSymbolMixin, TrackerMixin = H.TrackerMixin, merge = H.merge, Point = H.Point, Series = H.Series, seriesType = H.seriesType, seriesTypes = H.seriesTypes;
          /**
           * The timeline series type.
           *
           * @private
           * @class
           * @name Highcharts.seriesTypes.timeline
           *
           * @augments Highcharts.Series
           */
          seriesType('timeline', 'line', 
          /**
           * The timeline series presents given events along a drawn line.
           *
           * @sample highcharts/series-timeline/alternate-labels
           *         Timeline series
           * @sample highcharts/series-timeline/inverted
           *         Inverted timeline
           * @sample highcharts/series-timeline/datetime-axis
           *         With true datetime axis
           *
           * @extends      plotOptions.line
           * @since        7.0.0
           * @product      highcharts
           * @excluding    animationLimit, boostThreshold, connectEnds, connectNulls,
           *               cropThreshold, dashStyle, findNearestPointBy,
           *               getExtremesFromAll, lineWidth, negativeColor,
           *               pointInterval, pointIntervalUnit, pointPlacement,
           *               pointStart, softThreshold, stacking, step, threshold,
           *               turboThreshold, zoneAxis, zones
           * @requires     modules/timeline
           * @optionparent plotOptions.timeline
           */
          {
              colorByPoint: true,
              stickyTracking: false,
              ignoreHiddenPoint: true,
              legendType: 'point',
              lineWidth: 4,
              tooltip: {
                  headerFormat: '<span style="color:{point.color}">\u25CF</span> ' +
                      '<span style="font-size: 10px"> {point.key}</span><br/>',
                  pointFormat: '{point.description}'
              },
              states: {
                  hover: {
                      lineWidthPlus: 0
                  }
              },
              /**
               * @declare Highcharts.TimelineDataLabelsOptionsObject
               */
              dataLabels: {
                  enabled: true,
                  allowOverlap: true,
                  /**
                   * Whether to position data labels alternately. For example, if
                   * [distance](#plotOptions.timeline.dataLabels.distance)
                   * is set equal to `100`, then data labels will be positioned
                   * alternately (on both sides of the point) at a distance of 100px.
                   *
                   * @sample {highcharts} highcharts/series-timeline/alternate-disabled
                   *         Alternate disabled
                   */
                  alternate: true,
                  backgroundColor: '#ffffff',
                  borderWidth: 1,
                  borderColor: '#999999',
                  borderRadius: 3,
                  color: '#333333',
                  /**
                   * The color of the line connecting the data label to the point.
                   * The default color is the same as the point's color.
                   *
                   * In styled mode, the connector stroke is given in the
                   * `.highcharts-data-label-connector` class.
                   *
                   * @sample {highcharts} highcharts/series-timeline/connector-styles
                   *         Custom connector width and color
                   *
                   * @type      {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
                   * @apioption plotOptions.timeline.dataLabels.connectorColor
                   */
                  /**
                   * The width of the line connecting the data label to the point.
                   *
                   * In styled mode, the connector stroke width is given in the
                   * `.highcharts-data-label-connector` class.
                   *
                   * @sample {highcharts} highcharts/series-timeline/connector-styles
                   *         Custom connector width and color
                   */
                  connectorWidth: 1,
                  /**
                   * A pixel value defining the distance between the data label and
                   * the point. Negative numbers puts the label on top of the point.
                   */
                  distance: 100,
                  // eslint-disable-next-line valid-jsdoc
                  /**
                   * @type    {Highcharts.TimelineDataLabelsFormatterCallbackFunction}
                   * @default function () {
                   *   var format;
                   *
                   *   if (!this.series.chart.styledMode) {
                   *       format = '<span style="color:' + this.point.color +
                   *           '">● </span>';
                   *   } else {
                   *       format = '<span>● </span>';
                   *   }
                   *   format += '<span>' + (this.key || '') + '</span><br/>' +
                   *       (this.point.label || '');
                   *   return format;
                   * }
                   */
                  formatter: function () {
                      var format;
                      if (!this.series.chart.styledMode) {
                          format = '<span style="color:' + this.point.color +
                              '">● </span>';
                      }
                      else {
                          format = '<span>● </span>';
                      }
                      format += '<span class="highcharts-strong">' +
                          (this.key || '') + '</span><br/>' +
                          (this.point.label || '');
                      return format;
                  },
                  style: {
                      /** @internal */
                      textOutline: 'none',
                      /** @internal */
                      fontWeight: 'normal',
                      /** @internal */
                      fontSize: '12px'
                  },
                  /**
                   * Shadow options for the data label.
                   *
                   * @type {boolean|Highcharts.CSSObject}
                   */
                  shadow: false,
                  /**
                   * @type      {number}
                   * @apioption plotOptions.timeline.dataLabels.width
                   */
                  verticalAlign: 'middle'
              },
              marker: {
                  enabledThreshold: 0,
                  symbol: 'square',
                  radius: 6,
                  lineWidth: 2,
                  height: 15
              },
              showInLegend: false,
              colorKey: 'x'
          }, 
          /**
           * @lends Highcharts.Series#
           */
          {
              trackerGroups: ['markerGroup', 'dataLabelsGroup'],
              // Use a simple symbol from LegendSymbolMixin
              drawLegendSymbol: LegendSymbolMixin.drawRectangle,
              // Use a group of trackers from TrackerMixin
              drawTracker: TrackerMixin.drawTrackerPoint,
              init: function () {
                  var series = this;
                  Series.prototype.init.apply(series, arguments);
                  addEvent(series, 'afterTranslate', function () {
                      var lastPlotX, closestPointRangePx = Number.MAX_VALUE;
                      series.points.forEach(function (point) {
                          // Set the isInside parameter basing also on the real point
                          // visibility, in order to avoid showing hidden points
                          // in drawPoints method.
                          point.isInside = point.isInside && point.visible;
                          // New way of calculating closestPointRangePx value, which
                          // respects the real point visibility is needed.
                          if (point.visible && !point.isNull) {
                              if (defined(lastPlotX)) {
                                  closestPointRangePx = Math.min(closestPointRangePx, Math.abs(point.plotX - lastPlotX));
                              }
                              lastPlotX = point.plotX;
                          }
                      });
                      series.closestPointRangePx = closestPointRangePx;
                  });
                  // Distribute data labels before rendering them. Distribution is
                  // based on the 'dataLabels.distance' and 'dataLabels.alternate'
                  // property.
                  addEvent(series, 'drawDataLabels', function () {
                      // Distribute data labels basing on defined algorithm.
                      series.distributeDL(); // @todo use this scope for series
                  });
                  addEvent(series, 'afterDrawDataLabels', function () {
                      var dataLabel; // @todo use this scope for series
                      // Draw or align connector for each point.
                      series.points.forEach(function (point) {
                          dataLabel = point.dataLabel;
                          if (dataLabel) {
                              // Within this wrap method is necessary to save the
                              // current animation params, because the data label
                              // target position (after animation) is needed to align
                              // connectors.
                              dataLabel.animate = function (params) {
                                  if (this.targetPosition) {
                                      this.targetPosition = params;
                                  }
                                  return H.SVGElement.prototype.animate.apply(this, arguments);
                              };
                              // Initialize the targetPosition field within data label
                              // object. It's necessary because there is need to know
                              // expected position of specific data label, when
                              // aligning connectors. This field is overrided inside
                              // of SVGElement.animate() wrapped  method.
                              if (!dataLabel.targetPosition) {
                                  dataLabel.targetPosition = {};
                              }
                              return point.drawConnector();
                          }
                      });
                  });
                  addEvent(series.chart, 'afterHideOverlappingLabel', function () {
                      series.points.forEach(function (p) {
                          if (p.connector &&
                              p.dataLabel &&
                              p.dataLabel.oldOpacity !== p.dataLabel.newOpacity) {
                              p.alignConnector();
                          }
                      });
                  });
              },
              alignDataLabel: function (point, dataLabel, options, alignTo) {
                  var series = this, isInverted = series.chart.inverted, visiblePoints = series.visibilityMap.filter(function (point) {
                      return point;
                  }), visiblePointsCount = series.visiblePointsCount, pointIndex = visiblePoints.indexOf(point), isFirstOrLast = (!pointIndex || pointIndex === visiblePointsCount - 1), dataLabelsOptions = series.options.dataLabels, userDLOptions = point.userDLOptions || {}, 
                  // Define multiplier which is used to calculate data label
                  // width. If data labels are alternate, they have two times more
                  // space to adapt (excepting first and last ones, which has only
                  // one and half), than in case of placing all data labels side
                  // by side.
                  multiplier = dataLabelsOptions.alternate ?
                      (isFirstOrLast ? 1.5 : 2) :
                      1, distance, availableSpace = Math.floor(series.xAxis.len / visiblePointsCount), pad = dataLabel.padding, targetDLWidth, styles;
                  // Adjust data label width to the currently available space.
                  if (point.visible) {
                      distance = Math.abs(userDLOptions.x || point.options.dataLabels.x);
                      if (isInverted) {
                          targetDLWidth = ((distance - pad) * 2 - (point.itemHeight / 2));
                          styles = {
                              width: targetDLWidth,
                              // Apply ellipsis when data label height is exceeded.
                              textOverflow: dataLabel.width / targetDLWidth *
                                  dataLabel.height / 2 > availableSpace * multiplier ?
                                  'ellipsis' : 'none'
                          };
                      }
                      else {
                          styles = {
                              width: userDLOptions.width ||
                                  dataLabelsOptions.width ||
                                  availableSpace * multiplier - (pad * 2)
                          };
                      }
                      dataLabel.css(styles);
                      if (!series.chart.styledMode) {
                          dataLabel.shadow(dataLabelsOptions.shadow);
                      }
                  }
                  Series.prototype.alignDataLabel.apply(series, arguments);
              },
              processData: function () {
                  var series = this, visiblePoints = 0, i;
                  series.visibilityMap = series.getVisibilityMap();
                  // Calculate currently visible points.
                  series.visibilityMap.forEach(function (point) {
                      if (point) {
                          visiblePoints++;
                      }
                  });
                  series.visiblePointsCount = visiblePoints;
                  for (i = 0; i < series.xData.length; i++) {
                      series.yData[i] = 1;
                  }
                  Series.prototype.processData.call(this, arguments);
                  return;
              },
              getXExtremes: function (xData) {
                  var series = this, filteredData = xData.filter(function (x, i) {
                      return series.points[i].isValid() &&
                          series.points[i].visible;
                  });
                  return {
                      min: arrayMin(filteredData),
                      max: arrayMax(filteredData)
                  };
              },
              generatePoints: function () {
                  var series = this;
                  Series.prototype.generatePoints.apply(series);
                  series.points.forEach(function (point, i) {
                      point.applyOptions({
                          x: series.xData[i]
                      }, series.xData[i]);
                  });
              },
              getVisibilityMap: function () {
                  var series = this, map = (series.data.length ?
                      series.data : series.userOptions.data).map(function (point) {
                      return (point &&
                          point.visible !== false &&
                          !point.isNull) ? point : false;
                  });
                  return map;
              },
              distributeDL: function () {
                  var series = this, dataLabelsOptions = series.options.dataLabels, options, pointDLOptions, newOptions = {}, visibilityIndex = 1, distance = dataLabelsOptions.distance;
                  series.points.forEach(function (point) {
                      if (point.visible && !point.isNull) {
                          options = point.options;
                          pointDLOptions = point.options.dataLabels;
                          if (!series.hasRendered) {
                              point.userDLOptions =
                                  merge({}, pointDLOptions);
                          }
                          newOptions[series.chart.inverted ? 'x' : 'y'] =
                              dataLabelsOptions.alternate && visibilityIndex % 2 ?
                                  -distance : distance;
                          options.dataLabels = merge(newOptions, point.userDLOptions);
                          visibilityIndex++;
                      }
                  });
              },
              markerAttribs: function (point, state) {
                  var series = this, seriesMarkerOptions = series.options.marker, seriesStateOptions, pointMarkerOptions = point.marker || {}, symbol = (pointMarkerOptions.symbol || seriesMarkerOptions.symbol), pointStateOptions, width = pick(pointMarkerOptions.width, seriesMarkerOptions.width, series.closestPointRangePx), height = pick(pointMarkerOptions.height, seriesMarkerOptions.height), radius = 0, attribs;
                  // Call default markerAttribs method, when the xAxis type
                  // is set to datetime.
                  if (series.xAxis.isDatetimeAxis) {
                      return seriesTypes.line.prototype.markerAttribs
                          .call(this, point, state);
                  }
                  // Handle hover and select states
                  if (state) {
                      seriesStateOptions =
                          seriesMarkerOptions.states[state] || {};
                      pointStateOptions = pointMarkerOptions.states &&
                          pointMarkerOptions.states[state] || {};
                      radius = pick(pointStateOptions.radius, seriesStateOptions.radius, radius + (seriesStateOptions.radiusPlus || 0));
                  }
                  point.hasImage = (symbol && symbol.indexOf('url') === 0);
                  attribs = {
                      x: Math.floor(point.plotX) - (width / 2) - (radius / 2),
                      y: point.plotY - (height / 2) - (radius / 2),
                      width: width + radius,
                      height: height + radius
                  };
                  return attribs;
              },
              bindAxes: function () {
                  var series = this;
                  Series.prototype.bindAxes.call(series);
                  ['xAxis', 'yAxis'].forEach(function (axis) {
                      // Initially set the linked xAxis type to category.
                      if (axis === 'xAxis' && !series[axis].userOptions.type) {
                          series[axis].categories = series[axis].hasNames = true;
                      }
                  });
              }
          }, 
          /**
           * @lends Highcharts.Point#
           */
          {
              init: function () {
                  var point = Point.prototype.init.apply(this, arguments);
                  point.name = pick(point.name, 'Event');
                  point.y = 1;
                  return point;
              },
              isValid: function () {
                  return this.options.y !== null;
              },
              setVisible: function (vis, redraw) {
                  var point = this, series = point.series;
                  redraw = pick(redraw, series.options.ignoreHiddenPoint);
                  seriesTypes.pie.prototype.pointClass.prototype
                      .setVisible.call(point, vis, false);
                  // Process new data
                  series.processData();
                  if (redraw) {
                      series.chart.redraw();
                  }
              },
              setState: function () {
                  var proceed = Series.prototype.pointClass.prototype.setState;
                  // Prevent triggering the setState method on null points.
                  if (!this.isNull) {
                      proceed.apply(this, arguments);
                  }
              },
              getConnectorPath: function () {
                  var point = this, chart = point.series.chart, xAxisLen = point.series.xAxis.len, inverted = chart.inverted, direction = inverted ? 'x2' : 'y2', dl = point.dataLabel, targetDLPos = dl.targetPosition, coords = {
                      x1: point.plotX,
                      y1: point.plotY,
                      x2: point.plotX,
                      y2: isNumber(targetDLPos.y) ? targetDLPos.y : dl.y
                  }, negativeDistance = ((dl.alignAttr || dl)[direction[0]] <
                      point.series.yAxis.len / 2), path;
                  // Recalculate coords when the chart is inverted.
                  if (inverted) {
                      coords = {
                          x1: point.plotY,
                          y1: xAxisLen - point.plotX,
                          x2: targetDLPos.x || dl.x,
                          y2: xAxisLen - point.plotX
                      };
                  }
                  // Subtract data label width or height from expected coordinate so
                  // that the connector would start from the appropriate edge.
                  if (negativeDistance) {
                      coords[direction] += dl[inverted ? 'width' : 'height'];
                  }
                  // Change coordinates so that they will be relative to data label.
                  objectEach(coords, function (_coord, i) {
                      coords[i] -= (dl.alignAttr || dl)[i[0]];
                  });
                  path = chart.renderer.crispLine([
                      'M',
                      coords.x1,
                      coords.y1,
                      'L',
                      coords.x2,
                      coords.y2
                  ], dl.options.connectorWidth);
                  return path;
              },
              drawConnector: function () {
                  var point = this, series = point.series;
                  if (!point.connector) {
                      point.connector = series.chart.renderer
                          .path(point.getConnectorPath())
                          .attr({
                          zIndex: -1
                      })
                          .add(point.dataLabel);
                  }
                  if (point.series.chart.isInsidePlot(// #10507
                  point.dataLabel.x, point.dataLabel.y)) {
                      point.alignConnector();
                  }
              },
              alignConnector: function () {
                  var point = this, series = point.series, connector = point.connector, dl = point.dataLabel, dlOptions = point.dataLabel.options = merge(series.options.dataLabels, point.options.dataLabels), chart = point.series.chart, bBox = connector.getBBox(), plotPos = {
                      x: bBox.x + dl.translateX,
                      y: bBox.y + dl.translateY
                  }, isVisible;
                  // Include a half of connector width in order to run animation,
                  // when connectors are aligned to the plot area edge.
                  if (chart.inverted) {
                      plotPos.y -= dl.options.connectorWidth / 2;
                  }
                  else {
                      plotPos.x += dl.options.connectorWidth / 2;
                  }
                  isVisible = chart.isInsidePlot(plotPos.x, plotPos.y);
                  connector[isVisible ? 'animate' : 'attr']({
                      d: point.getConnectorPath()
                  });
                  if (!series.chart.styledMode) {
                      connector.attr({
                          stroke: dlOptions.connectorColor || point.color,
                          'stroke-width': dlOptions.connectorWidth,
                          opacity: dl[defined(dl.newOpacity) ? 'newOpacity' : 'opacity']
                      });
                  }
              }
          });
          /**
           * The `timeline` series. If the [type](#series.timeline.type) option is
           * not specified, it is inherited from [chart.type](#chart.type).
           *
           * @extends   series,plotOptions.timeline
           * @excluding animationLimit, boostThreshold, connectEnds, connectNulls,
           *            cropThreshold, dashStyle, dataParser, dataURL, findNearestPointBy,
           *            getExtremesFromAll, lineWidth, negativeColor,
           *            pointInterval, pointIntervalUnit, pointPlacement, pointStart,
           *            softThreshold, stacking, stack, step, threshold, turboThreshold,
           *            zoneAxis, zones
           * @product   highcharts
           * @requires  modules/timeline
           * @apioption series.timeline
           */
          /**
           * An array of data points for the series. For the `timeline` series type,
           * points can be given with three general parameters, `name`, `label`,
           * and `description`:
           *
           * Example:
           *
           * ```js
           * series: [{
           *    type: 'timeline',
           *    data: [{
           *        name: 'Jan 2018',
           *        label: 'Some event label',
           *        description: 'Description to show in tooltip'
           *    }]
           * }]
           * ```
           * If all points additionally have the `x` values, and xAxis type is set to
           * `datetime`, then events are laid out on a true time axis, where their
           * placement reflects the actual time between them.
           *
           * @sample {highcharts} highcharts/series-timeline/alternate-labels
           *         Alternate labels
           * @sample {highcharts} highcharts/series-timeline/datetime-axis
           *         Real time intervals
           *
           * @type      {Array<*>}
           * @extends   series.line.data
           * @excluding marker, y
           * @product   highcharts
           * @apioption series.timeline.data
           */
          /**
           * The name of event.
           *
           * @type      {string}
           * @product   highcharts
           * @apioption series.timeline.data.name
           */
          /**
           * The label of event.
           *
           * @type      {string}
           * @product   highcharts
           * @apioption series.timeline.data.label
           */
          /**
           * The description of event. This description will be shown in tooltip.
           *
           * @type      {string}
           * @product   highcharts
           * @apioption series.timeline.data.description
           */
          ''; // adds doclets above to transpiled file
  
      });
      _registerModule(_modules, 'masters/modules/timeline.src.js', [], function () {
  
  
      });
  }));