text: /**
   * @license Highcharts JS v7.1.0 (2019-04-01)
   *
   * X-range series
   *
   * (c) 2010-2019 Torstein Honsi, Lars A. V. Cabrera
   *
   * 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/xrange', ['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/xrange.src.js', [_modules['parts/Globals.js']], function (H) {
          /* *
           * X-range series module
           *
           * (c) 2010-2019 Torstein Honsi, Lars A. V. Cabrera
           *
           * License: www.highcharts.com/license
           */
  
  
  
          var addEvent = H.addEvent,
              defined = H.defined,
              color = H.Color,
              columnType = H.seriesTypes.column,
              correctFloat = H.correctFloat,
              isNumber = H.isNumber,
              isObject = H.isObject,
              merge = H.merge,
              pick = H.pick,
              seriesType = H.seriesType,
              seriesTypes = H.seriesTypes,
              Axis = H.Axis,
              Point = H.Point,
              Series = H.Series;
  
          /**
           * Return color of a point based on its category.
           *
           * @private
           * @function getColorByCategory
           *
           * @param {object} series
           *        The series which the point belongs to.
           *
           * @param {object} point
           *        The point to calculate its color for.
           *
           * @return {object}
           *         Returns an object containing the properties color and colorIndex.
           */
          function getColorByCategory(series, point) {
              var colors = series.options.colors || series.chart.options.colors,
                  colorCount = colors ?
                      colors.length :
                      series.chart.options.chart.colorCount,
                  colorIndex = point.y % colorCount,
                  color = colors && colors[colorIndex];
  
              return {
                  colorIndex: colorIndex,
                  color: color
              };
          }
  
          /**
           * @private
           * @class
           * @name Highcharts.seriesTypes.xrange
           *
           * @augments Highcharts.Series
           */
          seriesType('xrange', 'column'
  
              /**
               * The X-range series displays ranges on the X axis, typically time
               * intervals with a start and end date.
               *
               * @sample {highcharts} highcharts/demo/x-range/
               *         X-range
               * @sample {highcharts} highcharts/css/x-range/
               *         Styled mode X-range
               * @sample {highcharts} highcharts/chart/inverted-xrange/
               *         Inverted X-range
               *
               * @extends      plotOptions.column
               * @since        6.0.0
               * @product      highcharts highstock gantt
               * @excluding    boostThreshold, crisp, cropThreshold, depth, edgeColor,
               *               edgeWidth, findNearestPointBy, getExtremesFromAll,
               *               negativeColor, pointInterval, pointIntervalUnit,
               *               pointPlacement, pointRange, pointStart, softThreshold,
               *               stacking, threshold, data
               * @optionparent plotOptions.xrange
               */
              , {
  
                  /**
                   * A partial fill for each point, typically used to visualize how much
                   * of a task is performed. The partial fill object can be set either on
                   * series or point level.
                   *
                   * @sample {highcharts} highcharts/demo/x-range
                   *         X-range with partial fill
                   *
                   * @product   highcharts highstock gantt
                   * @apioption plotOptions.xrange.partialFill
                   */
  
                  /**
                   * The fill color to be used for partial fills. Defaults to a darker
                   * shade of the point color.
                   *
                   * @type      {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
                   * @product   highcharts highstock gantt
                   * @apioption plotOptions.xrange.partialFill.fill
                   */
  
                  /**
                   * A partial fill for each point, typically used to visualize how much
                   * of a task is performed. See [completed](series.gantt.data.completed).
                   *
                   * @sample gantt/demo/progress-indicator
                   *         Gantt with progress indicator
                   *
                   * @product   gantt
                   * @apioption plotOptions.gantt.partialFill
                   */
  
                  /**
                   * In an X-range series, this option makes all points of the same Y-axis
                   * category the same color.
                   */
                  colorByPoint: true,
  
                  dataLabels: {
                      /** @ignore-option */
                      formatter: function () {
                          var point = this.point,
                              amount = point.partialFill;
  
                          if (isObject(amount)) {
                              amount = amount.amount;
                          }
                          if (!defined(amount)) {
                              amount = 0;
                          }
                          return correctFloat(amount * 100) + '%';
                      },
                      /** @ignore-option */
                      inside: true,
                      /** @ignore-option */
                      verticalAlign: 'middle'
                  },
  
                  tooltip: {
  
                      headerFormat: '<span style="font-size: 10px">{point.x} - {point.x2}</span><br/>',
  
                      pointFormat: '<span style="color:{point.color}">\u25CF</span> {series.name}: <b>{point.yCategory}</b><br/>'
                  },
  
                  borderRadius: 3,
  
                  pointRange: 0
  
              }, {
  
                  type: 'xrange',
                  parallelArrays: ['x', 'x2', 'y'],
                  requireSorting: false,
                  animate: seriesTypes.line.prototype.animate,
                  cropShoulder: 1,
                  getExtremesFromAll: true,
                  autoIncrement: H.noop,
                  /**
               * Borrow the column series metrics, but with swapped axes. This gives free
               * access to features like groupPadding, grouping, pointWidth etc.
               *
               * @private
               * @function Higcharts.Series#getColumnMetrics
               *
               * @return {Highcharts.ColumnMetricsObject}
               */
                  getColumnMetrics: function () {
                      var metrics,
                          chart = this.chart;
  
                      function swapAxes() {
                          chart.series.forEach(function (s) {
                              var xAxis = s.xAxis;
  
                              s.xAxis = s.yAxis;
                              s.yAxis = xAxis;
                          });
                      }
  
                      swapAxes();
  
                      metrics = columnType.prototype.getColumnMetrics.call(this);
  
                      swapAxes();
  
                      return metrics;
                  },
  
                  /**
               * Override cropData to show a point where x or x2 is outside visible range,
               * but one of them is inside.
               *
               * @private
               * @function Highcharts.Series#cropData
               *
               * @param {Array<number>} xData
               *
               * @param {Array<number>} yData
               *
               * @param {number} min
               *
               * @param {number} max
               *
               * @param {number} [cropShoulder]
               *
               * @return {*}
               */
                  cropData: function (xData, yData, min, max) {
  
                      // Replace xData with x2Data to find the appropriate cropStart
                      var cropData = Series.prototype.cropData,
                          crop = cropData.call(this, this.x2Data, yData, min, max);
  
                      // Re-insert the cropped xData
                      crop.xData = xData.slice(crop.start, crop.end);
  
                      return crop;
                  },
                  /**
                   * Finds the index of an existing point that matches the given point
                   * options.
                   *
                   * @private
                   * @function Highcharts.Series#findPointIndex
                   * @param {object} options The options of the point.
                   * @returns {number|undefined} Returns index of a matching point,
                   * returns undefined if no match is found.
                   */
                  findPointIndex: function (options) {
                      var series = this,
                          // Search in data, since broken-axis can remove points inside a
                          // break.
                          points = series.data,
                          oldData = series.points,
                          id = options.id,
                          point,
                          pointIndex;
  
                      if (id) {
                          point = H.find(points, function (point) {
                              return point.id === id;
                          });
                          pointIndex = point ? point.index : undefined;
                      }
  
                      if (pointIndex === undefined) {
                          point = H.find(points, function (point) {
                              return (
                                  point.x === options.x &&
                                  point.x2 === options.x2 &&
                                  !(oldData[pointIndex] && oldData[pointIndex].touched)
                              );
                          });
                          pointIndex = point ? point.index : undefined;
                      }
  
                      // Reduce pointIndex if data is cropped
                      if (series.cropped && pointIndex >= series.cropStart) {
                          pointIndex -= series.cropStart;
                      }
  
                      return pointIndex;
                  },
                  /**
               * @private
               * @function Highcharts.Series#translatePoint
               *
               * @param {Highcharts.Point} point
               */
                  translatePoint: function (point) {
                      var series = this,
                          xAxis = series.xAxis,
                          yAxis = series.yAxis,
                          metrics = series.columnMetrics,
                          options = series.options,
                          minPointLength = options.minPointLength || 0,
                          plotX = point.plotX,
                          posX = pick(point.x2, point.x + (point.len || 0)),
                          plotX2 = xAxis.translate(posX, 0, 0, 0, 1),
                          length = Math.abs(plotX2 - plotX),
                          widthDifference,
                          shapeArgs,
                          partialFill,
                          inverted = this.chart.inverted,
                          borderWidth = pick(options.borderWidth, 1),
                          crisper = borderWidth % 2 / 2,
                          yOffset = metrics.offset,
                          pointHeight = Math.round(metrics.width),
                          dlLeft,
                          dlRight,
                          dlWidth;
  
                      if (minPointLength) {
                          widthDifference = minPointLength - length;
                          if (widthDifference < 0) {
                              widthDifference = 0;
                          }
                          plotX -= widthDifference / 2;
                          plotX2 += widthDifference / 2;
                      }
  
                      plotX = Math.max(plotX, -10);
                      plotX2 = Math.min(Math.max(plotX2, -10), xAxis.len + 10);
  
                      // Handle individual pointWidth
                      if (defined(point.options.pointWidth)) {
                          yOffset -= (
                              (Math.ceil(point.options.pointWidth) - pointHeight) / 2
                          );
                          pointHeight = Math.ceil(point.options.pointWidth);
                      }
  
                      // Apply pointPlacement to the Y axis
                      if (
                          options.pointPlacement &&
                      isNumber(point.plotY) &&
                      yAxis.categories
                      ) {
                          point.plotY = yAxis
                              .translate(point.y, 0, 1, 0, 1, options.pointPlacement);
                      }
  
                      point.shapeArgs = {
                          x: Math.floor(Math.min(plotX, plotX2)) + crisper,
                          y: Math.floor(point.plotY + yOffset) + crisper,
                          width: Math.round(Math.abs(plotX2 - plotX)),
                          height: pointHeight,
                          r: series.options.borderRadius
                      };
  
                      // Align data labels inside the shape and inside the plot area
                      dlLeft = point.shapeArgs.x;
                      dlRight = dlLeft + point.shapeArgs.width;
                      if (dlLeft < 0 || dlRight > xAxis.len) {
                          dlLeft = Math.min(xAxis.len, Math.max(0, dlLeft));
                          dlRight = Math.max(0, Math.min(dlRight, xAxis.len));
                          dlWidth = dlRight - dlLeft;
                          point.dlBox = merge(point.shapeArgs, {
                              x: dlLeft,
                              width: dlRight - dlLeft,
                              centerX: dlWidth ? dlWidth / 2 : null
                          });
  
                      } else {
                          point.dlBox = null;
                      }
  
                      // Tooltip position
                      if (!inverted) {
                          point.tooltipPos[0] += length / 2 * (xAxis.reversed ? -1 : 1);
                          point.tooltipPos[1] -= metrics.width / 2;
  
                          // Limit position by the correct axis size (#9727)
                          point.tooltipPos[0] = Math.max(
                              Math.min(point.tooltipPos[0], xAxis.len - 1), 0
                          );
                          point.tooltipPos[1] = Math.max(
                              Math.min(point.tooltipPos[1], yAxis.len - 1), 0
                          );
                      } else {
                          point.tooltipPos[1] += length / 2 * (xAxis.reversed ? 1 : -1);
                          point.tooltipPos[0] += metrics.width / 2;
  
                          // Limit position by the correct axis size (#9727)
                          point.tooltipPos[1] = Math.max(
                              Math.min(point.tooltipPos[1], xAxis.len - 1), 0
                          );
                          point.tooltipPos[0] = Math.max(
                              Math.min(point.tooltipPos[0], yAxis.len - 1), 0
                          );
                      }
  
                      // Add a partShapeArgs to the point, based on the shapeArgs property
                      partialFill = point.partialFill;
                      if (partialFill) {
                      // Get the partial fill amount
                          if (isObject(partialFill)) {
                              partialFill = partialFill.amount;
                          }
                          // If it was not a number, assume 0
                          if (!isNumber(partialFill)) {
                              partialFill = 0;
                          }
                          shapeArgs = point.shapeArgs;
                          point.partShapeArgs = {
                              x: shapeArgs.x,
                              y: shapeArgs.y,
                              width: shapeArgs.width,
                              height: shapeArgs.height,
                              r: series.options.borderRadius
                          };
                          point.clipRectArgs = {
                              x: shapeArgs.x,
                              y: shapeArgs.y,
                              width: Math.max(
                                  Math.round(
                                      length * partialFill +
                                  (point.plotX - plotX)
                                  ),
                                  0
                              ),
                              height: shapeArgs.height
                          };
                      }
                  },
  
                  /**
               * @private
               * @function Highcharts.Series#translate
               */
                  translate: function () {
                      columnType.prototype.translate.apply(this, arguments);
                      this.points.forEach(function (point) {
                          this.translatePoint(point);
                      }, this);
                  },
  
                  /**
               * Draws a single point in the series. Needed for partial fill.
               *
               * This override turns point.graphic into a group containing the original
               * graphic and an overlay displaying the partial fill.
               *
               * @private
               * @function Highcharts.Series#drawPoint
               *
               * @param {Highcharts.Point} point
               *        An instance of Point in the series.
               *
               * @param {"animate"|"attr"} verb
               *        'animate' (animates changes) or 'attr' (sets options)
               */
                  drawPoint: function (point, verb) {
                      var series = this,
                          seriesOpts = series.options,
                          renderer = series.chart.renderer,
                          graphic = point.graphic,
                          type = point.shapeType,
                          shapeArgs = point.shapeArgs,
                          partShapeArgs = point.partShapeArgs,
                          clipRectArgs = point.clipRectArgs,
                          pfOptions = point.partialFill,
                          cutOff = seriesOpts.stacking && !seriesOpts.borderRadius,
                          pointState = point.state,
                          stateOpts = seriesOpts.states[pointState || 'normal'] || {},
                          attrOrAnim = pointState === undefined ? 'attr' : 'animate',
                          pointAttr = series.pointAttribs(point, pointState),
                          animation = pick(
                              series.chart.options.chart.animation,
                              stateOpts.animation
                          ),
                          fill;
  
                      if (!point.isNull) {
  
                          // Original graphic
                          if (graphic) { // update
                              point.graphicOriginal[verb](shapeArgs);
                          } else {
                              point.graphic = graphic = renderer.g('point')
                                  .addClass(point.getClassName())
                                  .add(point.group || series.group);
  
                              point.graphicOriginal = renderer[type](merge(shapeArgs))
                                  .addClass(point.getClassName())
                                  .addClass('highcharts-partfill-original')
                                  .add(graphic);
                          }
  
                          // Partial fill graphic
                          if (partShapeArgs) {
                              if (point.graphicOverlay) {
                                  point.clipRect.animate(
                                      merge(clipRectArgs)
                                  );
  
                              } else {
  
                                  point.clipRect = renderer.clipRect(
                                      clipRectArgs.x,
                                      clipRectArgs.y,
                                      clipRectArgs.width,
                                      clipRectArgs.height
                                  );
  
                                  point.graphicOverlay = renderer[type](partShapeArgs)
                                      .addClass('highcharts-partfill-overlay')
                                      .add(graphic)
                                      .clip(point.clipRect);
                              }
                          }
  
  
                          // Presentational
                          if (!series.chart.styledMode) {
                              point.graphicOriginal
                                  .animate(pointAttr, animation)
                                  .shadow(seriesOpts.shadow, null, cutOff);
  
                              if (partShapeArgs) {
                                  // Ensure pfOptions is an object
                                  if (!isObject(pfOptions)) {
                                      pfOptions = {};
                                  }
                                  if (isObject(seriesOpts.partialFill)) {
                                      pfOptions = merge(
                                          pfOptions, seriesOpts.partialFill
                                      );
                                  }
  
                                  fill = (
                                      pfOptions.fill ||
                                      color(pointAttr.fill).brighten(-0.3).get() ||
                                      color(point.color || series.color)
                                          .brighten(-0.3).get()
                                  );
  
                                  pointAttr.fill = fill;
                                  point.graphicOverlay[attrOrAnim](pointAttr, animation)
                                      .shadow(seriesOpts.shadow, null, cutOff);
                              }
                          }
  
                      } else if (graphic) {
                          point.graphic = graphic.destroy(); // #1269
                      }
                  },
  
                  /**
               * @private
               * @function Highcharts.Series#drawPoints
               */
                  drawPoints: function () {
                      var series = this,
                          verb = series.getAnimationVerb();
  
                      // Draw the columns
                      series.points.forEach(function (point) {
                          series.drawPoint(point, verb);
                      });
                  },
  
  
                  /**
               * Returns "animate", or "attr" if the number of points is above the
               * animation limit.
               *
               * @private
               * @function Highcharts.Series#getAnimationVerb
               *
               * @return {string}
               */
                  getAnimationVerb: function () {
                      return (
                          this.chart.pointCount < (this.options.animationLimit || 250) ?
                              'animate' :
                              'attr'
                      );
                  }
  
                  /*
              // Override to remove stroke from points. For partial fill.
              pointAttribs: function () {
                  var series = this,
                      retVal = columnType.prototype.pointAttribs.apply(series, arguments);
  
                  //retVal['stroke-width'] = 0;
                  return retVal;
              }
              //*/
  
              }, { // Point class properties
              /**
               * Extend applyOptions so that `colorByPoint` for x-range means that one
               * color is applied per Y axis category.
               *
               * @private
               * @function Highcharts.Point#applyOptions
               *
               * @return {Highcharts.Series}
               */
                  resolveColor: function () {
                      var series = this.series,
                          colorByPoint;
  
                      if (series.options.colorByPoint && !this.options.color) {
                          colorByPoint = getColorByCategory(series, this);
  
                          if (!series.chart.styledMode) {
                              this.color = colorByPoint.color;
                          }
  
                          if (!this.options.colorIndex) {
                              this.colorIndex = colorByPoint.colorIndex;
                          }
                      } else if (!this.color) {
                          this.color = series.color;
                      }
  
                  },
                  /**
               * Extend init to have y default to 0.
               *
               * @private
               * @function Highcharts.Point#init
               *
               * @return {Highcharts.Series}
               */
                  init: function () {
                      Point.prototype.init.apply(this, arguments);
  
                      if (!this.y) {
                          this.y = 0;
                      }
  
                      return this;
                  },
  
                  /**
               * @private
               * @function Highcharts.Point#setState
               */
                  setState: function () {
                      Point.prototype.setState.apply(this, arguments);
  
                      this.series.drawPoint(this, this.series.getAnimationVerb());
                  },
  
                  /**
               * @private
               * @function Highcharts.Point#getLabelConfig
               *
               * @return {Highcharts.PointLabelObject}
               */
                  // Add x2 and yCategory to the available properties for tooltip formats
                  getLabelConfig: function () {
                      var point = this,
                          cfg = Point.prototype.getLabelConfig.call(point),
                          yCats = point.series.yAxis.categories;
  
                      cfg.x2 = point.x2;
                      cfg.yCategory = point.yCategory = yCats && yCats[point.y];
                      return cfg;
                  },
                  tooltipDateKeys: ['x', 'x2'],
  
                  /**
               * @private
               * @function Highcharts.Point#isValid
               *
               * @return {boolean}
               */
                  isValid: function () {
                      return typeof this.x === 'number' &&
                      typeof this.x2 === 'number';
                  }
              });
  
          // Max x2 should be considered in xAxis extremes
          addEvent(Axis, 'afterGetSeriesExtremes', function () {
              var axis = this,
                  axisSeries = axis.series,
                  dataMax,
                  modMax;
  
              if (axis.isXAxis) {
                  dataMax = pick(axis.dataMax, -Number.MAX_VALUE);
                  axisSeries.forEach(function (series) {
                      if (series.x2Data) {
                          series.x2Data.forEach(function (val) {
                              if (val > dataMax) {
                                  dataMax = val;
                                  modMax = true;
                              }
                          });
                      }
                  });
                  if (modMax) {
                      axis.dataMax = dataMax;
                  }
              }
          });
  
  
          /**
           * An `xrange` series. If the [type](#series.xrange.type) option is not
           * specified, it is inherited from [chart.type](#chart.type).
           *
           * @extends   series,plotOptions.xrange
           * @excluding boostThreshold, crisp, cropThreshold, depth, edgeColor, edgeWidth,
           *            findNearestPointBy, getExtremesFromAll, negativeColor,
           *            pointInterval, pointIntervalUnit, pointPlacement, pointRange,
           *            pointStart, softThreshold, stacking, threshold
           * @product   highcharts highstock gantt
           * @apioption series.xrange
           */
  
          /**
           * An array of data points for the series. For the `xrange` series type,
           * points can be given in the following ways:
           *
           * 1. An array of objects with named values. The objects are point configuration
           *    objects as seen below.
           *    ```js
           *    data: [{
           *        x: Date.UTC(2017, 0, 1),
           *        x2: Date.UTC(2017, 0, 3),
           *        name: "Test",
           *        y: 0,
           *        color: "#00FF00"
           *    }, {
           *        x: Date.UTC(2017, 0, 4),
           *        x2: Date.UTC(2017, 0, 5),
           *        name: "Deploy",
           *        y: 1,
           *        color: "#FF0000"
           *    }]
           *    ```
           *
           * @sample {highcharts} highcharts/series/data-array-of-objects/
           *         Config objects
           *
           * @type      {Array<*>}
           * @extends   series.line.data
           * @product   highcharts highstock gantt
           * @apioption series.xrange.data
           */
  
          /**
           * The starting X value of the range point.
           *
           * @sample {highcharts} highcharts/demo/x-range
           *         X-range
           *
           * @type      {number}
           * @product   highcharts highstock gantt
           * @apioption series.xrange.data.x
           */
  
          /**
           * The ending X value of the range point.
           *
           * @sample {highcharts} highcharts/demo/x-range
           *         X-range
           *
           * @type      {number}
           * @product   highcharts highstock gantt
           * @apioption series.xrange.data.x2
           */
  
          /**
           * The Y value of the range point.
           *
           * @sample {highcharts} highcharts/demo/x-range
           *         X-range
           *
           * @type      {number}
           * @product   highcharts highstock gantt
           * @apioption series.xrange.data.y
           */
  
          /**
           * A partial fill for each point, typically used to visualize how much of
           * a task is performed. The partial fill object can be set either on series
           * or point level.
           *
           * @sample {highcharts} highcharts/demo/x-range
           *         X-range with partial fill
           *
           * @product   highcharts highstock gantt
           * @apioption series.xrange.data.partialFill
           */
  
          /**
           * The amount of the X-range point to be filled. Values can be 0-1 and are
           * converted to percentages in the default data label formatter.
           *
           * @type      {number}
           * @product   highcharts highstock gantt
           * @apioption series.xrange.data.partialFill.amount
           */
  
          /**
           * The fill color to be used for partial fills. Defaults to a darker shade
           * of the point color.
           *
           * @type      {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
           * @product   highcharts highstock gantt
           * @apioption series.xrange.data.partialFill.fill
           */
  
      });
      _registerModule(_modules, 'masters/modules/xrange.src.js', [], function () {
  
  
      });
  }));
  