Chartist.noop = function (n) {
  return n;
};
  

    Chartist.alphaNumerate = function (n) {
  // Limit to a-z
  return String.fromCharCode(97 + n % 26);
};
  

    Chartist.extend = function (target) {
  target = target || {};

  var sources = Array.prototype.slice.call(arguments, 1);
  sources.forEach(function(source) {
    for (var prop in source) {
      if (typeof source[prop] === 'object' && !(source[prop] instanceof Array)) {
        target[prop] = Chartist.extend({}, target[prop], source[prop]);
      } else {
        target[prop] = source[prop];
      }
    }
  });

  return target;
};
  

    Chartist.replaceAll = function(str, subStr, newSubStr) {
  return str.replace(new RegExp(subStr, 'g'), newSubStr);
};
  

    Chartist.stripUnit = function(value) {
  if(typeof value === 'string') {
    value = value.replace(/[^0-9\+-\.]/g, '');
  }

  return +value;
};
  

    Chartist.ensureUnit = function(value, unit) {
  if(typeof value === 'number') {
    value = value + unit;
  }

  return value;
};
  

    Chartist.querySelector = function(query) {
  return query instanceof Node ? query : document.querySelector(query);
};
  

    Chartist.times = function(length) {
  return Array.apply(null, new Array(length));
};
  

    Chartist.sum = function(previous, current) {
  return previous + current;
};
  

    Chartist.serialMap = function(arr, cb) {
  var result = [],
      length = Math.max.apply(null, arr.map(function(e) {
        return e.length;
      }));

  Chartist.times(length).forEach(function(e, index) {
    var args = arr.map(function(e) {
      return e[index];
    });

    result[index] = cb.apply(null, args);
  });

  return result;
};
  

    Chartist.roundWithPrecision = function(value, digits) {
  var precision = Math.pow(10, digits || Chartist.precision);
  return Math.round(value * precision) / precision;
};
  

    Chartist.serialize = function(data) {
  if(data === null || data === undefined) {
    return data;
  } else if(typeof data === 'number') {
    data = ''+data;
  } else if(typeof data === 'object') {
    data = JSON.stringify({data: data});
  }

  return Object.keys(Chartist.escapingMap).reduce(function(result, key) {
    return Chartist.replaceAll(result, key, Chartist.escapingMap[key]);
  }, data);
};
  

    Chartist.deserialize = function(data) {
  if(typeof data !== 'string') {
    return data;
  }

  data = Object.keys(Chartist.escapingMap).reduce(function(result, key) {
    return Chartist.replaceAll(result, Chartist.escapingMap[key], key);
  }, data);

  try {
    data = JSON.parse(data);
    data = data.data !== undefined ? data.data : data;
  } catch(e) {}

  return data;
};
  

    Chartist.createSvg = function (container, width, height, className) {
  var svg;

  width = width || '100%';
  height = height || '100%';

  // Check if there is a previous SVG element in the container that contains the Chartist XML namespace and remove it
  // Since the DOM API does not support namespaces we need to manually search the returned list http://www.w3.org/TR/selectors-api/
  Array.prototype.slice.call(container.querySelectorAll('svg')).filter(function filterChartistSvgObjects(svg) {
    return svg.getAttribute(Chartist.xmlNs.qualifiedName);
  }).forEach(function removePreviousElement(svg) {
    container.removeChild(svg);
  });

  // Create svg object with width and height or use 100% as default
  svg = new Chartist.Svg('svg').attr({
    width: width,
    height: height
  }).addClass(className).attr({
    style: 'width: ' + width + '; height: ' + height + ';'
  });

  // Add the DOM node to our container
  container.appendChild(svg._node);

  return svg;
};
  

    Chartist.reverseData = function(data) {
  data.labels.reverse();
  data.series.reverse();
  for (var i = 0; i < data.series.length; i++) {
    if(typeof(data.series[i]) === 'object' && data.series[i].data !== undefined) {
      data.series[i].data.reverse();
    } else {
      data.series[i].reverse();
    }
  }
};
  

    Chartist.getDataArray = function (data, reverse) {
  var array = [],
    value,
    localData;

  // If the data should be reversed but isn't we need to reverse it
  // If it's reversed but it shouldn't we need to reverse it back
  // That's required to handle data updates correctly and to reflect the responsive configurations
  if(reverse && !data.reversed || !reverse && data.reversed) {
    Chartist.reverseData(data);
    data.reversed = !data.reversed;
  }

  for (var i = 0; i < data.series.length; i++) {
    // If the series array contains an object with a data property we will use the property
    // otherwise the value directly (array or number).
    // We create a copy of the original data array with Array.prototype.push.apply
    localData = typeof(data.series[i]) === 'object' && data.series[i].data !== undefined ? data.series[i].data : data.series[i];
    if(localData instanceof Array) {
      array[i] = [];
      Array.prototype.push.apply(array[i], localData);
    } else {
      array[i] = localData;
    }

    // Convert object values to numbers
    for (var j = 0; j < array[i].length; j++) {
      value = array[i][j];
      value = value.value === 0 ? 0 : (value.value || value);
      array[i][j] = +value;
    }
  }

  return array;
};
  

    Chartist.normalizePadding = function(padding, fallback) {
  fallback = fallback || 0;

  return typeof padding === 'number' ? {
    top: padding,
    right: padding,
    bottom: padding,
    left: padding
  } : {
    top: typeof padding.top === 'number' ? padding.top : fallback,
    right: typeof padding.right === 'number' ? padding.right : fallback,
    bottom: typeof padding.bottom === 'number' ? padding.bottom : fallback,
    left: typeof padding.left === 'number' ? padding.left : fallback
  };
};
  

    Chartist.normalizeDataArray = function (dataArray, length) {
  for (var i = 0; i < dataArray.length; i++) {
    if (dataArray[i].length === length) {
      continue;
    }

    for (var j = dataArray[i].length; j < length; j++) {
      dataArray[i][j] = 0;
    }
  }

  return dataArray;
};

Chartist.getMetaData = function(series, index) {
  var value = series.data ? series.data[index] : series[index];
  return value ? Chartist.serialize(value.meta) : undefined;
};
  

    Chartist.orderOfMagnitude = function (value) {
  return Math.floor(Math.log(Math.abs(value)) / Math.LN10);
};
  

    Chartist.projectLength = function (axisLength, length, bounds) {
  return length / bounds.range * axisLength;
};
  

    Chartist.getAvailableHeight = function (svg, options) {
  return Math.max((Chartist.stripUnit(options.height) || svg.height()) - (options.chartPadding.top +  options.chartPadding.bottom) - options.axisX.offset, 0);
};
  

    Chartist.getHighLow = function (dataArray) {
  var i,
    j,
    highLow = {
      high: -Number.MAX_VALUE,
      low: Number.MAX_VALUE
    };

  for (i = 0; i < dataArray.length; i++) {
    for (j = 0; j < dataArray[i].length; j++) {
      if (dataArray[i][j] > highLow.high) {
        highLow.high = dataArray[i][j];
      }

      if (dataArray[i][j] < highLow.low) {
        highLow.low = dataArray[i][j];
      }
    }
  }

  return highLow;
};
  

    Chartist.getBounds = function (axisLength, highLow, scaleMinSpace, referenceValue) {
  var i,
    newMin,
    newMax,
    bounds = {
      high: highLow.high,
      low: highLow.low
    };

  // If high and low are the same because of misconfiguration or flat data (only the same value) we need
  // to set the high or low to 0 depending on the polarity
  if(bounds.high === bounds.low) {
    // If both values are 0 we set high to 1
    if(bounds.low === 0) {
      bounds.high = 1;
    } else if(bounds.low < 0) {
      // If we have the same negative value for the bounds we set bounds.high to 0
      bounds.high = 0;
    } else {
      // If we have the same positive value for the bounds we set bounds.low to 0
      bounds.low = 0;
    }
  }

  // Overrides of high / low based on reference value, it will make sure that the invisible reference value is
  // used to generate the chart. This is useful when the chart always needs to contain the position of the
  // invisible reference value in the view i.e. for bipolar scales.
  if (referenceValue || referenceValue === 0) {
    bounds.high = Math.max(referenceValue, bounds.high);
    bounds.low = Math.min(referenceValue, bounds.low);
  }

  bounds.valueRange = bounds.high - bounds.low;
  bounds.oom = Chartist.orderOfMagnitude(bounds.valueRange);
  bounds.min = Math.floor(bounds.low / Math.pow(10, bounds.oom)) * Math.pow(10, bounds.oom);
  bounds.max = Math.ceil(bounds.high / Math.pow(10, bounds.oom)) * Math.pow(10, bounds.oom);
  bounds.range = bounds.max - bounds.min;
  bounds.step = Math.pow(10, bounds.oom);
  bounds.numberOfSteps = Math.round(bounds.range / bounds.step);

  // Optimize scale step by checking if subdivision is possible based on horizontalGridMinSpace
  // If we are already below the scaleMinSpace value we will scale up
  var length = Chartist.projectLength(axisLength, bounds.step, bounds),
    scaleUp = length < scaleMinSpace;

  while (true) {
    if (scaleUp && Chartist.projectLength(axisLength, bounds.step, bounds) <= scaleMinSpace) {
      bounds.step *= 2;
    } else if (!scaleUp && Chartist.projectLength(axisLength, bounds.step / 2, bounds) >= scaleMinSpace) {
      bounds.step /= 2;
    } else {
      break;
    }
  }

  // Narrow min and max based on new step
  newMin = bounds.min;
  newMax = bounds.max;
  for (i = bounds.min; i <= bounds.max; i += bounds.step) {
    if (i + bounds.step < bounds.low) {
      newMin += bounds.step;
    }

    if (i - bounds.step >= bounds.high) {
      newMax -= bounds.step;
    }
  }
  bounds.min = newMin;
  bounds.max = newMax;
  bounds.range = bounds.max - bounds.min;

  bounds.values = [];
  for (i = bounds.min; i <= bounds.max; i += bounds.step) {
    bounds.values.push(Chartist.roundWithPrecision(i));
  }

  return bounds;
};
  

    Chartist.polarToCartesian = function (centerX, centerY, radius, angleInDegrees) {
  var angleInRadians = (angleInDegrees - 90) * Math.PI / 180.0;

  return {
    x: centerX + (radius * Math.cos(angleInRadians)),
    y: centerY + (radius * Math.sin(angleInRadians))
  };
};
  

    Chartist.createChartRect = function (svg, options, fallbackPadding) {
  var yOffset = options.axisY ? options.axisY.offset || 0 : 0,
    xOffset = options.axisX ? options.axisX.offset || 0 : 0,
    w = Chartist.stripUnit(options.width) || svg.width(),
    h = Chartist.stripUnit(options.height) || svg.height(),
    normalizedPadding = Chartist.normalizePadding(options.chartPadding, fallbackPadding);

  return {
    x1: normalizedPadding.left + yOffset,
    y1: Math.max(h - normalizedPadding.bottom - xOffset, normalizedPadding.bottom),
    x2: Math.max(w - normalizedPadding.right, normalizedPadding.right + yOffset),
    y2: normalizedPadding.top,
    width: function () {
      return this.x2 - this.x1;
    },
    height: function () {
      return this.y1 - this.y2;
    }
  };
};
  

    Chartist.createGrid = function(projectedValue, index, axis, offset, length, group, classes, eventEmitter) {
  var positionalData = {};
  positionalData[axis.units.pos + '1'] = projectedValue.pos;
  positionalData[axis.units.pos + '2'] = projectedValue.pos;
  positionalData[axis.counterUnits.pos + '1'] = offset;
  positionalData[axis.counterUnits.pos + '2'] = offset + length;

  var gridElement = group.elem('line', positionalData, classes.join(' '));

  // Event for grid draw
  eventEmitter.emit('draw',
    Chartist.extend({
      type: 'grid',
      axis: axis.units.pos,
      index: index,
      group: group,
      element: gridElement
    }, positionalData)
  );
};
  

    Chartist.createLabel = function(projectedValue, index, labels, axis, axisOffset, labelOffset, group, classes, useForeignObject, eventEmitter) {
  var labelElement,
    positionalData = {};
  positionalData[axis.units.pos] = projectedValue.pos + labelOffset[axis.units.pos];
  positionalData[axis.counterUnits.pos] = labelOffset[axis.counterUnits.pos];
  positionalData[axis.units.len] = projectedValue.len;
  positionalData[axis.counterUnits.len] = axisOffset;

  if(useForeignObject) {
    var content = '<span class="' + classes.join(' ') + '">' + labels[index] + '</span>';
    labelElement = group.foreignObject(content, Chartist.extend({
      style: 'overflow: visible;'
    }, positionalData));
  } else {
    labelElement = group.elem('text', positionalData, classes.join(' ')).text(labels[index]);
  }

  eventEmitter.emit('draw', Chartist.extend({
    type: 'label',
    axis: axis,
    index: index,
    group: group,
    element: labelElement,
    text: labels[index]
  }, positionalData));
};
  

    Chartist.createAxis = function(axis, data, chartRect, gridGroup, labelGroup, useForeignObject, options, eventEmitter) {
  var axisOptions = options['axis' + axis.units.pos.toUpperCase()],
    projectedValues = data.map(axis.projectValue.bind(axis)).map(axis.transform),
    labelValues = data.map(axisOptions.labelInterpolationFnc);

  projectedValues.forEach(function(projectedValue, index) {
    // Skip grid lines and labels where interpolated label values are falsey (execpt for 0)
    if(!labelValues[index] && labelValues[index] !== 0) {
      return;
    }

    if(axisOptions.showGrid) {
      Chartist.createGrid(projectedValue, index, axis, axis.gridOffset, chartRect[axis.counterUnits.len](), gridGroup, [
        options.classNames.grid,
        options.classNames[axis.units.dir]
      ], eventEmitter);
    }

    if(axisOptions.showLabel) {
      Chartist.createLabel(projectedValue, index, labelValues, axis, axisOptions.offset, axis.labelOffset, labelGroup, [
        options.classNames.label,
        options.classNames[axis.units.dir]
      ], useForeignObject, eventEmitter);
    }
  });
};
  

    Chartist.optionsProvider = function (options, responsiveOptions, eventEmitter) {
  var baseOptions = Chartist.extend({}, options),
    currentOptions,
    mediaQueryListeners = [],
    i;

  function updateCurrentOptions(preventChangedEvent) {
    var previousOptions = currentOptions;
    currentOptions = Chartist.extend({}, baseOptions);

    if (responsiveOptions) {
      for (i = 0; i < responsiveOptions.length; i++) {
        var mql = window.matchMedia(responsiveOptions[i][0]);
        if (mql.matches) {
          currentOptions = Chartist.extend(currentOptions, responsiveOptions[i][1]);
        }
      }
    }

    if(eventEmitter && !preventChangedEvent) {
      eventEmitter.emit('optionsChanged', {
        previousOptions: previousOptions,
        currentOptions: currentOptions
      });
    }
  }

  function removeMediaQueryListeners() {
    mediaQueryListeners.forEach(function(mql) {
      mql.removeListener(updateCurrentOptions);
    });
  }

  if (!window.matchMedia) {
    throw 'window.matchMedia not found! Make sure you\'re using a polyfill.';
  } else if (responsiveOptions) {

    for (i = 0; i < responsiveOptions.length; i++) {
      var mql = window.matchMedia(responsiveOptions[i][0]);
      mql.addListener(updateCurrentOptions);
      mediaQueryListeners.push(mql);
    }
  }
  // Execute initially so we get the correct options
  updateCurrentOptions(true);

  return {
    get currentOptions() {
      return Chartist.extend({}, currentOptions);
    },
    removeMediaQueryListeners: removeMediaQueryListeners
  };
};

}(window, document, Chartist));
  

    Chartist.Interpolation.none = function() {
  return function cardinal(pathCoordinates) {
    var path = new Chartist.Svg.Path().move(pathCoordinates[0], pathCoordinates[1]);

    for(var i = 3; i < pathCoordinates.length; i += 2) {
      path.line(pathCoordinates[i - 1], pathCoordinates[i]);
    }

    return path;
  };
};
  

    Chartist.Interpolation.simple = function(options) {
  var defaultOptions = {
    divisor: 2
  };
  options = Chartist.extend({}, defaultOptions, options);

  var d = 1 / Math.max(1, options.divisor);

  return function simple(pathCoordinates) {
    var path = new Chartist.Svg.Path().move(pathCoordinates[0], pathCoordinates[1]);

    for(var i = 2; i < pathCoordinates.length; i += 2) {
      var prevX = pathCoordinates[i - 2],
          prevY = pathCoordinates[i - 1],
          currX = pathCoordinates[i],
          currY = pathCoordinates[i + 1],
          length = (currX - prevX) * d;

      path.curve(
        prevX + length,
        prevY,
        currX - length,
        currY,
        currX,
        currY
      );
    }

    return path;
  };
};
  

var chart = new Chartist.Line('.ct-chart', {
  labels: [1, 2, 3, 4, 5],
  series: [[1, 2, 8, 1, 7]]
}, {
  lineSmooth: Chartist.Interpolation.simple({
    divisor: 2
  })
});

    Chartist.Interpolation.cardinal = function(options) {
  var defaultOptions = {
    tension: 1
  };

  options = Chartist.extend({}, defaultOptions, options);

  var t = Math.min(1, Math.max(0, options.tension)),
    c = 1 - t;

  return function cardinal(pathCoordinates) {
    // If less than two points we need to fallback to no smoothing
    if(pathCoordinates.length <= 4) {
      return Chartist.Interpolation.none()(pathCoordinates);
    }

    var path = new Chartist.Svg.Path().move(pathCoordinates[0], pathCoordinates[1]),
      z;

    for (var i = 0, iLen = pathCoordinates.length; iLen - 2 * !z > i; i += 2) {
      var p = [
        {x: +pathCoordinates[i - 2], y: +pathCoordinates[i - 1]},
        {x: +pathCoordinates[i], y: +pathCoordinates[i + 1]},
        {x: +pathCoordinates[i + 2], y: +pathCoordinates[i + 3]},
        {x: +pathCoordinates[i + 4], y: +pathCoordinates[i + 5]}
      ];
      if (z) {
        if (!i) {
          p[0] = {x: +pathCoordinates[iLen - 2], y: +pathCoordinates[iLen - 1]};
        } else if (iLen - 4 === i) {
          p[3] = {x: +pathCoordinates[0], y: +pathCoordinates[1]};
        } else if (iLen - 2 === i) {
          p[2] = {x: +pathCoordinates[0], y: +pathCoordinates[1]};
          p[3] = {x: +pathCoordinates[2], y: +pathCoordinates[3]};
        }
      } else {
        if (iLen - 4 === i) {
          p[3] = p[2];
        } else if (!i) {
          p[0] = {x: +pathCoordinates[i], y: +pathCoordinates[i + 1]};
        }
      }

      path.curve(
        (t * (-p[0].x + 6 * p[1].x + p[2].x) / 6) + (c * p[2].x),
        (t * (-p[0].y + 6 * p[1].y + p[2].y) / 6) + (c * p[2].y),
        (t * (p[1].x + 6 * p[2].x - p[3].x) / 6) + (c * p[2].x),
        (t * (p[1].y + 6 * p[2].y - p[3].y) / 6) + (c * p[2].y),
        p[2].x,
        p[2].y
      );
    }

    return path;
  };
};

}(window, document, Chartist));
  

var chart = new Chartist.Line('.ct-chart', {
  labels: [1, 2, 3, 4, 5],
  series: [[1, 2, 8, 1, 7]]
}, {
  lineSmooth: Chartist.Interpolation.cardinal({
    tension: 1
  })
});

    Chartist.Svg.isSupported = function(feature) {
  return document.implementation.hasFeature('www.http://w3.org/TR/SVG11/feature#' + feature, '1.1');
};

/**
 * This Object contains some standard easing cubic bezier curves. Then can be used with their name in the `Chartist.Svg.animate`. You can also extend the list and use your own name in the `animate` function. Click the show code button to see the available bezier functions.
 *
 * @memberof Chartist.Svg
 */
var easingCubicBeziers = {
  easeInSine: [0.47, 0, 0.745, 0.715],
  easeOutSine: [0.39, 0.575, 0.565, 1],
  easeInOutSine: [0.445, 0.05, 0.55, 0.95],
  easeInQuad: [0.55, 0.085, 0.68, 0.53],
  easeOutQuad: [0.25, 0.46, 0.45, 0.94],
  easeInOutQuad: [0.455, 0.03, 0.515, 0.955],
  easeInCubic: [0.55, 0.055, 0.675, 0.19],
  easeOutCubic: [0.215, 0.61, 0.355, 1],
  easeInOutCubic: [0.645, 0.045, 0.355, 1],
  easeInQuart: [0.895, 0.03, 0.685, 0.22],
  easeOutQuart: [0.165, 0.84, 0.44, 1],
  easeInOutQuart: [0.77, 0, 0.175, 1],
  easeInQuint: [0.755, 0.05, 0.855, 0.06],
  easeOutQuint: [0.23, 1, 0.32, 1],
  easeInOutQuint: [0.86, 0, 0.07, 1],
  easeInExpo: [0.95, 0.05, 0.795, 0.035],
  easeOutExpo: [0.19, 1, 0.22, 1],
  easeInOutExpo: [1, 0, 0, 1],
  easeInCirc: [0.6, 0.04, 0.98, 0.335],
  easeOutCirc: [0.075, 0.82, 0.165, 1],
  easeInOutCirc: [0.785, 0.135, 0.15, 0.86],
  easeInBack: [0.6, -0.28, 0.735, 0.045],
  easeOutBack: [0.175, 0.885, 0.32, 1.275],
  easeInOutBack: [0.68, -0.55, 0.265, 1.55]
};

Chartist.Svg.Easing = easingCubicBeziers;

/**
 * This helper class is to wrap multiple `Chartist.Svg` elements into a list where you can call the `Chartist.Svg` functions on all elements in the list with one call. This is helpful when you'd like to perform calls with `Chartist.Svg` on multiple elements.
 * An instance of this class is also returned by `Chartist.Svg.querySelectorAll`.
 *
 * @memberof Chartist.Svg
 * @param {Array<Node>|NodeList} nodeList An Array of SVG DOM nodes or a SVG DOM NodeList (as returned by document.querySelectorAll)
 * @constructor
 */
function SvgList(nodeList) {
  var list = this;

  this.svgElements = [];
  for(var i = 0; i < nodeList.length; i++) {
    this.svgElements.push(new Chartist.Svg(nodeList[i]));
  }

  // Add delegation methods for Chartist.Svg
  Object.keys(Chartist.Svg.prototype).filter(function(prototypeProperty) {
    return ['constructor',
        'parent',
        'querySelector',
        'querySelectorAll',
        'replace',
        'append',
        'classes',
        'height',
        'width'].indexOf(prototypeProperty) === -1;
  }).forEach(function(prototypeProperty) {
    list[prototypeProperty] = function() {
      var args = Array.prototype.slice.call(arguments, 0);
      list.svgElements.forEach(function(element) {
        Chartist.Svg.prototype[prototypeProperty].apply(element, args);
      });
      return list;
    };
  });
}

Chartist.Svg.List = Chartist.Class.extend({
  constructor: SvgList
});
}(window, document, Chartist));