From 7e5bf7d9bc41a10ef1687b4843b87f9d35ac5298 Mon Sep 17 00:00:00 2001
From: Jakub <netghost03@gmail.com>
Date: Sun, 24 Sep 2017 18:38:37 +0200
Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20Add=20dist=20files=20to=20repo?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore                   |     1 -
 dist/vue-chartjs.full.js     | 41886 +++++++++++++++++++++++++++++++++
 dist/vue-chartjs.full.min.js |    20 +
 dist/vue-chartjs.js          |  4119 ++++
 dist/vue-chartjs.min.js      |     2 +
 5 files changed, 46027 insertions(+), 1 deletion(-)
 create mode 100644 dist/vue-chartjs.full.js
 create mode 100644 dist/vue-chartjs.full.min.js
 create mode 100644 dist/vue-chartjs.js
 create mode 100644 dist/vue-chartjs.min.js

diff --git a/.gitignore b/.gitignore
index 8de0bbbe..bc93dbb2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,5 +4,4 @@ npm-debug.log
 selenium-debug.log
 test/unit/coverage
 test/e2e/reports
-dist/
 es/
diff --git a/dist/vue-chartjs.full.js b/dist/vue-chartjs.full.js
new file mode 100644
index 00000000..a25dc138
--- /dev/null
+++ b/dist/vue-chartjs.full.js
@@ -0,0 +1,41886 @@
+/*!
+ * vue-chartjs v2.8.7
+ * (c) 2017 Jakub Juszczak <jakub@posteo.de>
+ * http://vue-chartjs.org
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("VueChartJs", [], factory);
+	else if(typeof exports === 'object')
+		exports["VueChartJs"] = factory();
+	else
+		root["VueChartJs"] = factory();
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.mixins = exports.Scatter = exports.Bubble = exports.Radar = exports.PolarArea = exports.Pie = exports.Line = exports.Doughnut = exports.HorizontalBar = exports.Bar = exports.VueCharts = undefined;
+
+	var _Bar = __webpack_require__(1);
+
+	var _Bar2 = _interopRequireDefault(_Bar);
+
+	var _HorizontalBar = __webpack_require__(180);
+
+	var _HorizontalBar2 = _interopRequireDefault(_HorizontalBar);
+
+	var _Doughnut = __webpack_require__(181);
+
+	var _Doughnut2 = _interopRequireDefault(_Doughnut);
+
+	var _Line = __webpack_require__(182);
+
+	var _Line2 = _interopRequireDefault(_Line);
+
+	var _Pie = __webpack_require__(183);
+
+	var _Pie2 = _interopRequireDefault(_Pie);
+
+	var _PolarArea = __webpack_require__(184);
+
+	var _PolarArea2 = _interopRequireDefault(_PolarArea);
+
+	var _Radar = __webpack_require__(185);
+
+	var _Radar2 = _interopRequireDefault(_Radar);
+
+	var _Bubble = __webpack_require__(186);
+
+	var _Bubble2 = _interopRequireDefault(_Bubble);
+
+	var _Scatter = __webpack_require__(187);
+
+	var _Scatter2 = _interopRequireDefault(_Scatter);
+
+	var _index = __webpack_require__(188);
+
+	var _index2 = _interopRequireDefault(_index);
+
+	var _package = __webpack_require__(228);
+
+	var _package2 = _interopRequireDefault(_package);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	var VueCharts = {
+	  version: _package2.default.version,
+	  Bar: _Bar2.default,
+	  HorizontalBar: _HorizontalBar2.default,
+	  Doughnut: _Doughnut2.default,
+	  Line: _Line2.default,
+	  Pie: _Pie2.default,
+	  PolarArea: _PolarArea2.default,
+	  Radar: _Radar2.default,
+	  Bubble: _Bubble2.default,
+	  Scatter: _Scatter2.default,
+	  mixins: _index2.default
+	};
+
+	exports.default = VueCharts;
+	exports.VueCharts = VueCharts;
+	exports.Bar = _Bar2.default;
+	exports.HorizontalBar = _HorizontalBar2.default;
+	exports.Doughnut = _Doughnut2.default;
+	exports.Line = _Line2.default;
+	exports.Pie = _Pie2.default;
+	exports.PolarArea = _PolarArea2.default;
+	exports.Radar = _Radar2.default;
+	exports.Bubble = _Bubble2.default;
+	exports.Scatter = _Scatter2.default;
+	exports.mixins = _index2.default;
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+	  props: {
+	    chartId: {
+	      default: 'bar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            },
+	            categoryPercentage: 0.5,
+	            barPercentage: 0.2
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'bar',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process, global) {/*!
+	 * Vue.js v2.4.4
+	 * (c) 2014-2017 Evan You
+	 * Released under the MIT License.
+	 */
+	'use strict';
+
+	/*  */
+
+	// these helpers produces better vm code in JS engines due to their
+	// explicitness and function inlining
+	function isUndef (v) {
+	  return v === undefined || v === null
+	}
+
+	function isDef (v) {
+	  return v !== undefined && v !== null
+	}
+
+	function isTrue (v) {
+	  return v === true
+	}
+
+	function isFalse (v) {
+	  return v === false
+	}
+
+	/**
+	 * Check if value is primitive
+	 */
+	function isPrimitive (value) {
+	  return (
+	    typeof value === 'string' ||
+	    typeof value === 'number' ||
+	    typeof value === 'boolean'
+	  )
+	}
+
+	/**
+	 * Quick object check - this is primarily used to tell
+	 * Objects from primitive values when we know the value
+	 * is a JSON-compliant type.
+	 */
+	function isObject (obj) {
+	  return obj !== null && typeof obj === 'object'
+	}
+
+	var _toString = Object.prototype.toString;
+
+	/**
+	 * Strict object type check. Only returns true
+	 * for plain JavaScript objects.
+	 */
+	function isPlainObject (obj) {
+	  return _toString.call(obj) === '[object Object]'
+	}
+
+	function isRegExp (v) {
+	  return _toString.call(v) === '[object RegExp]'
+	}
+
+	/**
+	 * Check if val is a valid array index.
+	 */
+	function isValidArrayIndex (val) {
+	  var n = parseFloat(val);
+	  return n >= 0 && Math.floor(n) === n && isFinite(val)
+	}
+
+	/**
+	 * Convert a value to a string that is actually rendered.
+	 */
+	function toString (val) {
+	  return val == null
+	    ? ''
+	    : typeof val === 'object'
+	      ? JSON.stringify(val, null, 2)
+	      : String(val)
+	}
+
+	/**
+	 * Convert a input value to a number for persistence.
+	 * If the conversion fails, return original string.
+	 */
+	function toNumber (val) {
+	  var n = parseFloat(val);
+	  return isNaN(n) ? val : n
+	}
+
+	/**
+	 * Make a map and return a function for checking if a key
+	 * is in that map.
+	 */
+	function makeMap (
+	  str,
+	  expectsLowerCase
+	) {
+	  var map = Object.create(null);
+	  var list = str.split(',');
+	  for (var i = 0; i < list.length; i++) {
+	    map[list[i]] = true;
+	  }
+	  return expectsLowerCase
+	    ? function (val) { return map[val.toLowerCase()]; }
+	    : function (val) { return map[val]; }
+	}
+
+	/**
+	 * Check if a tag is a built-in tag.
+	 */
+	var isBuiltInTag = makeMap('slot,component', true);
+
+	/**
+	 * Check if a attribute is a reserved attribute.
+	 */
+	var isReservedAttribute = makeMap('key,ref,slot,is');
+
+	/**
+	 * Remove an item from an array
+	 */
+	function remove (arr, item) {
+	  if (arr.length) {
+	    var index = arr.indexOf(item);
+	    if (index > -1) {
+	      return arr.splice(index, 1)
+	    }
+	  }
+	}
+
+	/**
+	 * Check whether the object has the property.
+	 */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	function hasOwn (obj, key) {
+	  return hasOwnProperty.call(obj, key)
+	}
+
+	/**
+	 * Create a cached version of a pure function.
+	 */
+	function cached (fn) {
+	  var cache = Object.create(null);
+	  return (function cachedFn (str) {
+	    var hit = cache[str];
+	    return hit || (cache[str] = fn(str))
+	  })
+	}
+
+	/**
+	 * Camelize a hyphen-delimited string.
+	 */
+	var camelizeRE = /-(\w)/g;
+	var camelize = cached(function (str) {
+	  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+	});
+
+	/**
+	 * Capitalize a string.
+	 */
+	var capitalize = cached(function (str) {
+	  return str.charAt(0).toUpperCase() + str.slice(1)
+	});
+
+	/**
+	 * Hyphenate a camelCase string.
+	 */
+	var hyphenateRE = /\B([A-Z])/g;
+	var hyphenate = cached(function (str) {
+	  return str.replace(hyphenateRE, '-$1').toLowerCase()
+	});
+
+	/**
+	 * Simple bind, faster than native
+	 */
+	function bind (fn, ctx) {
+	  function boundFn (a) {
+	    var l = arguments.length;
+	    return l
+	      ? l > 1
+	        ? fn.apply(ctx, arguments)
+	        : fn.call(ctx, a)
+	      : fn.call(ctx)
+	  }
+	  // record original fn length
+	  boundFn._length = fn.length;
+	  return boundFn
+	}
+
+	/**
+	 * Convert an Array-like object to a real Array.
+	 */
+	function toArray (list, start) {
+	  start = start || 0;
+	  var i = list.length - start;
+	  var ret = new Array(i);
+	  while (i--) {
+	    ret[i] = list[i + start];
+	  }
+	  return ret
+	}
+
+	/**
+	 * Mix properties into target object.
+	 */
+	function extend (to, _from) {
+	  for (var key in _from) {
+	    to[key] = _from[key];
+	  }
+	  return to
+	}
+
+	/**
+	 * Merge an Array of Objects into a single Object.
+	 */
+	function toObject (arr) {
+	  var res = {};
+	  for (var i = 0; i < arr.length; i++) {
+	    if (arr[i]) {
+	      extend(res, arr[i]);
+	    }
+	  }
+	  return res
+	}
+
+	/**
+	 * Perform no operation.
+	 * Stubbing args to make Flow happy without leaving useless transpiled code
+	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
+	 */
+	function noop (a, b, c) {}
+
+	/**
+	 * Always return false.
+	 */
+	var no = function (a, b, c) { return false; };
+
+	/**
+	 * Return same value
+	 */
+	var identity = function (_) { return _; };
+
+	/**
+	 * Generate a static keys string from compiler modules.
+	 */
+
+
+	/**
+	 * Check if two values are loosely equal - that is,
+	 * if they are plain objects, do they have the same shape?
+	 */
+	function looseEqual (a, b) {
+	  if (a === b) { return true }
+	  var isObjectA = isObject(a);
+	  var isObjectB = isObject(b);
+	  if (isObjectA && isObjectB) {
+	    try {
+	      var isArrayA = Array.isArray(a);
+	      var isArrayB = Array.isArray(b);
+	      if (isArrayA && isArrayB) {
+	        return a.length === b.length && a.every(function (e, i) {
+	          return looseEqual(e, b[i])
+	        })
+	      } else if (!isArrayA && !isArrayB) {
+	        var keysA = Object.keys(a);
+	        var keysB = Object.keys(b);
+	        return keysA.length === keysB.length && keysA.every(function (key) {
+	          return looseEqual(a[key], b[key])
+	        })
+	      } else {
+	        /* istanbul ignore next */
+	        return false
+	      }
+	    } catch (e) {
+	      /* istanbul ignore next */
+	      return false
+	    }
+	  } else if (!isObjectA && !isObjectB) {
+	    return String(a) === String(b)
+	  } else {
+	    return false
+	  }
+	}
+
+	function looseIndexOf (arr, val) {
+	  for (var i = 0; i < arr.length; i++) {
+	    if (looseEqual(arr[i], val)) { return i }
+	  }
+	  return -1
+	}
+
+	/**
+	 * Ensure a function is called only once.
+	 */
+	function once (fn) {
+	  var called = false;
+	  return function () {
+	    if (!called) {
+	      called = true;
+	      fn.apply(this, arguments);
+	    }
+	  }
+	}
+
+	var SSR_ATTR = 'data-server-rendered';
+
+	var ASSET_TYPES = [
+	  'component',
+	  'directive',
+	  'filter'
+	];
+
+	var LIFECYCLE_HOOKS = [
+	  'beforeCreate',
+	  'created',
+	  'beforeMount',
+	  'mounted',
+	  'beforeUpdate',
+	  'updated',
+	  'beforeDestroy',
+	  'destroyed',
+	  'activated',
+	  'deactivated'
+	];
+
+	/*  */
+
+	var config = ({
+	  /**
+	   * Option merge strategies (used in core/util/options)
+	   */
+	  optionMergeStrategies: Object.create(null),
+
+	  /**
+	   * Whether to suppress warnings.
+	   */
+	  silent: false,
+
+	  /**
+	   * Show production mode tip message on boot?
+	   */
+	  productionTip: process.env.NODE_ENV !== 'production',
+
+	  /**
+	   * Whether to enable devtools
+	   */
+	  devtools: process.env.NODE_ENV !== 'production',
+
+	  /**
+	   * Whether to record perf
+	   */
+	  performance: false,
+
+	  /**
+	   * Error handler for watcher errors
+	   */
+	  errorHandler: null,
+
+	  /**
+	   * Warn handler for watcher warns
+	   */
+	  warnHandler: null,
+
+	  /**
+	   * Ignore certain custom elements
+	   */
+	  ignoredElements: [],
+
+	  /**
+	   * Custom user key aliases for v-on
+	   */
+	  keyCodes: Object.create(null),
+
+	  /**
+	   * Check if a tag is reserved so that it cannot be registered as a
+	   * component. This is platform-dependent and may be overwritten.
+	   */
+	  isReservedTag: no,
+
+	  /**
+	   * Check if an attribute is reserved so that it cannot be used as a component
+	   * prop. This is platform-dependent and may be overwritten.
+	   */
+	  isReservedAttr: no,
+
+	  /**
+	   * Check if a tag is an unknown element.
+	   * Platform-dependent.
+	   */
+	  isUnknownElement: no,
+
+	  /**
+	   * Get the namespace of an element
+	   */
+	  getTagNamespace: noop,
+
+	  /**
+	   * Parse the real tag name for the specific platform.
+	   */
+	  parsePlatformTagName: identity,
+
+	  /**
+	   * Check if an attribute must be bound using property, e.g. value
+	   * Platform-dependent.
+	   */
+	  mustUseProp: no,
+
+	  /**
+	   * Exposed for legacy reasons
+	   */
+	  _lifecycleHooks: LIFECYCLE_HOOKS
+	});
+
+	/*  */
+
+	var emptyObject = Object.freeze({});
+
+	/**
+	 * Check if a string starts with $ or _
+	 */
+	function isReserved (str) {
+	  var c = (str + '').charCodeAt(0);
+	  return c === 0x24 || c === 0x5F
+	}
+
+	/**
+	 * Define a property.
+	 */
+	function def (obj, key, val, enumerable) {
+	  Object.defineProperty(obj, key, {
+	    value: val,
+	    enumerable: !!enumerable,
+	    writable: true,
+	    configurable: true
+	  });
+	}
+
+	/**
+	 * Parse simple path.
+	 */
+	var bailRE = /[^\w.$]/;
+	function parsePath (path) {
+	  if (bailRE.test(path)) {
+	    return
+	  }
+	  var segments = path.split('.');
+	  return function (obj) {
+	    for (var i = 0; i < segments.length; i++) {
+	      if (!obj) { return }
+	      obj = obj[segments[i]];
+	    }
+	    return obj
+	  }
+	}
+
+	/*  */
+
+	var warn = noop;
+	var tip = noop;
+	var formatComponentName = (null); // work around flow check
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var hasConsole = typeof console !== 'undefined';
+	  var classifyRE = /(?:^|[-_])(\w)/g;
+	  var classify = function (str) { return str
+	    .replace(classifyRE, function (c) { return c.toUpperCase(); })
+	    .replace(/[-_]/g, ''); };
+
+	  warn = function (msg, vm) {
+	    var trace = vm ? generateComponentTrace(vm) : '';
+
+	    if (config.warnHandler) {
+	      config.warnHandler.call(null, msg, vm, trace);
+	    } else if (hasConsole && (!config.silent)) {
+	      console.error(("[Vue warn]: " + msg + trace));
+	    }
+	  };
+
+	  tip = function (msg, vm) {
+	    if (hasConsole && (!config.silent)) {
+	      console.warn("[Vue tip]: " + msg + (
+	        vm ? generateComponentTrace(vm) : ''
+	      ));
+	    }
+	  };
+
+	  formatComponentName = function (vm, includeFile) {
+	    if (vm.$root === vm) {
+	      return '<Root>'
+	    }
+	    var name = typeof vm === 'string'
+	      ? vm
+	      : typeof vm === 'function' && vm.options
+	        ? vm.options.name
+	        : vm._isVue
+	          ? vm.$options.name || vm.$options._componentTag
+	          : vm.name;
+
+	    var file = vm._isVue && vm.$options.__file;
+	    if (!name && file) {
+	      var match = file.match(/([^/\\]+)\.vue$/);
+	      name = match && match[1];
+	    }
+
+	    return (
+	      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+	      (file && includeFile !== false ? (" at " + file) : '')
+	    )
+	  };
+
+	  var repeat = function (str, n) {
+	    var res = '';
+	    while (n) {
+	      if (n % 2 === 1) { res += str; }
+	      if (n > 1) { str += str; }
+	      n >>= 1;
+	    }
+	    return res
+	  };
+
+	  var generateComponentTrace = function (vm) {
+	    if (vm._isVue && vm.$parent) {
+	      var tree = [];
+	      var currentRecursiveSequence = 0;
+	      while (vm) {
+	        if (tree.length > 0) {
+	          var last = tree[tree.length - 1];
+	          if (last.constructor === vm.constructor) {
+	            currentRecursiveSequence++;
+	            vm = vm.$parent;
+	            continue
+	          } else if (currentRecursiveSequence > 0) {
+	            tree[tree.length - 1] = [last, currentRecursiveSequence];
+	            currentRecursiveSequence = 0;
+	          }
+	        }
+	        tree.push(vm);
+	        vm = vm.$parent;
+	      }
+	      return '\n\nfound in\n\n' + tree
+	        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+	            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+	            : formatComponentName(vm))); })
+	        .join('\n')
+	    } else {
+	      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
+	    }
+	  };
+	}
+
+	/*  */
+
+	function handleError (err, vm, info) {
+	  if (config.errorHandler) {
+	    config.errorHandler.call(null, err, vm, info);
+	  } else {
+	    if (process.env.NODE_ENV !== 'production') {
+	      warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+	    }
+	    /* istanbul ignore else */
+	    if (inBrowser && typeof console !== 'undefined') {
+	      console.error(err);
+	    } else {
+	      throw err
+	    }
+	  }
+	}
+
+	/*  */
+	/* globals MutationObserver */
+
+	// can we use __proto__?
+	var hasProto = '__proto__' in {};
+
+	// Browser environment sniffing
+	var inBrowser = typeof window !== 'undefined';
+	var UA = inBrowser && window.navigator.userAgent.toLowerCase();
+	var isIE = UA && /msie|trident/.test(UA);
+	var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+	var isEdge = UA && UA.indexOf('edge/') > 0;
+	var isAndroid = UA && UA.indexOf('android') > 0;
+	var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);
+	var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
+
+	// Firefox has a "watch" function on Object.prototype...
+	var nativeWatch = ({}).watch;
+
+	var supportsPassive = false;
+	if (inBrowser) {
+	  try {
+	    var opts = {};
+	    Object.defineProperty(opts, 'passive', ({
+	      get: function get () {
+	        /* istanbul ignore next */
+	        supportsPassive = true;
+	      }
+	    })); // https://github.com/facebook/flow/issues/285
+	    window.addEventListener('test-passive', null, opts);
+	  } catch (e) {}
+	}
+
+	// this needs to be lazy-evaled because vue may be required before
+	// vue-server-renderer can set VUE_ENV
+	var _isServer;
+	var isServerRendering = function () {
+	  if (_isServer === undefined) {
+	    /* istanbul ignore if */
+	    if (!inBrowser && typeof global !== 'undefined') {
+	      // detect presence of vue-server-renderer and avoid
+	      // Webpack shimming the process
+	      _isServer = global['process'].env.VUE_ENV === 'server';
+	    } else {
+	      _isServer = false;
+	    }
+	  }
+	  return _isServer
+	};
+
+	// detect devtools
+	var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+
+	/* istanbul ignore next */
+	function isNative (Ctor) {
+	  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
+	}
+
+	var hasSymbol =
+	  typeof Symbol !== 'undefined' && isNative(Symbol) &&
+	  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
+
+	/**
+	 * Defer a task to execute it asynchronously.
+	 */
+	var nextTick = (function () {
+	  var callbacks = [];
+	  var pending = false;
+	  var timerFunc;
+
+	  function nextTickHandler () {
+	    pending = false;
+	    var copies = callbacks.slice(0);
+	    callbacks.length = 0;
+	    for (var i = 0; i < copies.length; i++) {
+	      copies[i]();
+	    }
+	  }
+
+	  // the nextTick behavior leverages the microtask queue, which can be accessed
+	  // via either native Promise.then or MutationObserver.
+	  // MutationObserver has wider support, however it is seriously bugged in
+	  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+	  // completely stops working after triggering a few times... so, if native
+	  // Promise is available, we will use it:
+	  /* istanbul ignore if */
+	  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+	    var p = Promise.resolve();
+	    var logError = function (err) { console.error(err); };
+	    timerFunc = function () {
+	      p.then(nextTickHandler).catch(logError);
+	      // in problematic UIWebViews, Promise.then doesn't completely break, but
+	      // it can get stuck in a weird state where callbacks are pushed into the
+	      // microtask queue but the queue isn't being flushed, until the browser
+	      // needs to do some other work, e.g. handle a timer. Therefore we can
+	      // "force" the microtask queue to be flushed by adding an empty timer.
+	      if (isIOS) { setTimeout(noop); }
+	    };
+	  } else if (!isIE && typeof MutationObserver !== 'undefined' && (
+	    isNative(MutationObserver) ||
+	    // PhantomJS and iOS 7.x
+	    MutationObserver.toString() === '[object MutationObserverConstructor]'
+	  )) {
+	    // use MutationObserver where native Promise is not available,
+	    // e.g. PhantomJS, iOS7, Android 4.4
+	    var counter = 1;
+	    var observer = new MutationObserver(nextTickHandler);
+	    var textNode = document.createTextNode(String(counter));
+	    observer.observe(textNode, {
+	      characterData: true
+	    });
+	    timerFunc = function () {
+	      counter = (counter + 1) % 2;
+	      textNode.data = String(counter);
+	    };
+	  } else {
+	    // fallback to setTimeout
+	    /* istanbul ignore next */
+	    timerFunc = function () {
+	      setTimeout(nextTickHandler, 0);
+	    };
+	  }
+
+	  return function queueNextTick (cb, ctx) {
+	    var _resolve;
+	    callbacks.push(function () {
+	      if (cb) {
+	        try {
+	          cb.call(ctx);
+	        } catch (e) {
+	          handleError(e, ctx, 'nextTick');
+	        }
+	      } else if (_resolve) {
+	        _resolve(ctx);
+	      }
+	    });
+	    if (!pending) {
+	      pending = true;
+	      timerFunc();
+	    }
+	    if (!cb && typeof Promise !== 'undefined') {
+	      return new Promise(function (resolve, reject) {
+	        _resolve = resolve;
+	      })
+	    }
+	  }
+	})();
+
+	var _Set;
+	/* istanbul ignore if */
+	if (typeof Set !== 'undefined' && isNative(Set)) {
+	  // use native Set when available.
+	  _Set = Set;
+	} else {
+	  // a non-standard Set polyfill that only works with primitive keys.
+	  _Set = (function () {
+	    function Set () {
+	      this.set = Object.create(null);
+	    }
+	    Set.prototype.has = function has (key) {
+	      return this.set[key] === true
+	    };
+	    Set.prototype.add = function add (key) {
+	      this.set[key] = true;
+	    };
+	    Set.prototype.clear = function clear () {
+	      this.set = Object.create(null);
+	    };
+
+	    return Set;
+	  }());
+	}
+
+	/*  */
+
+
+	var uid$1 = 0;
+
+	/**
+	 * A dep is an observable that can have multiple
+	 * directives subscribing to it.
+	 */
+	var Dep = function Dep () {
+	  this.id = uid$1++;
+	  this.subs = [];
+	};
+
+	Dep.prototype.addSub = function addSub (sub) {
+	  this.subs.push(sub);
+	};
+
+	Dep.prototype.removeSub = function removeSub (sub) {
+	  remove(this.subs, sub);
+	};
+
+	Dep.prototype.depend = function depend () {
+	  if (Dep.target) {
+	    Dep.target.addDep(this);
+	  }
+	};
+
+	Dep.prototype.notify = function notify () {
+	  // stabilize the subscriber list first
+	  var subs = this.subs.slice();
+	  for (var i = 0, l = subs.length; i < l; i++) {
+	    subs[i].update();
+	  }
+	};
+
+	// the current target watcher being evaluated.
+	// this is globally unique because there could be only one
+	// watcher being evaluated at any time.
+	Dep.target = null;
+	var targetStack = [];
+
+	function pushTarget (_target) {
+	  if (Dep.target) { targetStack.push(Dep.target); }
+	  Dep.target = _target;
+	}
+
+	function popTarget () {
+	  Dep.target = targetStack.pop();
+	}
+
+	/*
+	 * not type checking this file because flow doesn't play well with
+	 * dynamically accessing methods on Array prototype
+	 */
+
+	var arrayProto = Array.prototype;
+	var arrayMethods = Object.create(arrayProto);[
+	  'push',
+	  'pop',
+	  'shift',
+	  'unshift',
+	  'splice',
+	  'sort',
+	  'reverse'
+	]
+	.forEach(function (method) {
+	  // cache original method
+	  var original = arrayProto[method];
+	  def(arrayMethods, method, function mutator () {
+	    var args = [], len = arguments.length;
+	    while ( len-- ) args[ len ] = arguments[ len ];
+
+	    var result = original.apply(this, args);
+	    var ob = this.__ob__;
+	    var inserted;
+	    switch (method) {
+	      case 'push':
+	      case 'unshift':
+	        inserted = args;
+	        break
+	      case 'splice':
+	        inserted = args.slice(2);
+	        break
+	    }
+	    if (inserted) { ob.observeArray(inserted); }
+	    // notify change
+	    ob.dep.notify();
+	    return result
+	  });
+	});
+
+	/*  */
+
+	var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+
+	/**
+	 * By default, when a reactive property is set, the new value is
+	 * also converted to become reactive. However when passing down props,
+	 * we don't want to force conversion because the value may be a nested value
+	 * under a frozen data structure. Converting it would defeat the optimization.
+	 */
+	var observerState = {
+	  shouldConvert: true
+	};
+
+	/**
+	 * Observer class that are attached to each observed
+	 * object. Once attached, the observer converts target
+	 * object's property keys into getter/setters that
+	 * collect dependencies and dispatches updates.
+	 */
+	var Observer = function Observer (value) {
+	  this.value = value;
+	  this.dep = new Dep();
+	  this.vmCount = 0;
+	  def(value, '__ob__', this);
+	  if (Array.isArray(value)) {
+	    var augment = hasProto
+	      ? protoAugment
+	      : copyAugment;
+	    augment(value, arrayMethods, arrayKeys);
+	    this.observeArray(value);
+	  } else {
+	    this.walk(value);
+	  }
+	};
+
+	/**
+	 * Walk through each property and convert them into
+	 * getter/setters. This method should only be called when
+	 * value type is Object.
+	 */
+	Observer.prototype.walk = function walk (obj) {
+	  var keys = Object.keys(obj);
+	  for (var i = 0; i < keys.length; i++) {
+	    defineReactive$$1(obj, keys[i], obj[keys[i]]);
+	  }
+	};
+
+	/**
+	 * Observe a list of Array items.
+	 */
+	Observer.prototype.observeArray = function observeArray (items) {
+	  for (var i = 0, l = items.length; i < l; i++) {
+	    observe(items[i]);
+	  }
+	};
+
+	// helpers
+
+	/**
+	 * Augment an target Object or Array by intercepting
+	 * the prototype chain using __proto__
+	 */
+	function protoAugment (target, src, keys) {
+	  /* eslint-disable no-proto */
+	  target.__proto__ = src;
+	  /* eslint-enable no-proto */
+	}
+
+	/**
+	 * Augment an target Object or Array by defining
+	 * hidden properties.
+	 */
+	/* istanbul ignore next */
+	function copyAugment (target, src, keys) {
+	  for (var i = 0, l = keys.length; i < l; i++) {
+	    var key = keys[i];
+	    def(target, key, src[key]);
+	  }
+	}
+
+	/**
+	 * Attempt to create an observer instance for a value,
+	 * returns the new observer if successfully observed,
+	 * or the existing observer if the value already has one.
+	 */
+	function observe (value, asRootData) {
+	  if (!isObject(value)) {
+	    return
+	  }
+	  var ob;
+	  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+	    ob = value.__ob__;
+	  } else if (
+	    observerState.shouldConvert &&
+	    !isServerRendering() &&
+	    (Array.isArray(value) || isPlainObject(value)) &&
+	    Object.isExtensible(value) &&
+	    !value._isVue
+	  ) {
+	    ob = new Observer(value);
+	  }
+	  if (asRootData && ob) {
+	    ob.vmCount++;
+	  }
+	  return ob
+	}
+
+	/**
+	 * Define a reactive property on an Object.
+	 */
+	function defineReactive$$1 (
+	  obj,
+	  key,
+	  val,
+	  customSetter,
+	  shallow
+	) {
+	  var dep = new Dep();
+
+	  var property = Object.getOwnPropertyDescriptor(obj, key);
+	  if (property && property.configurable === false) {
+	    return
+	  }
+
+	  // cater for pre-defined getter/setters
+	  var getter = property && property.get;
+	  var setter = property && property.set;
+
+	  var childOb = !shallow && observe(val);
+	  Object.defineProperty(obj, key, {
+	    enumerable: true,
+	    configurable: true,
+	    get: function reactiveGetter () {
+	      var value = getter ? getter.call(obj) : val;
+	      if (Dep.target) {
+	        dep.depend();
+	        if (childOb) {
+	          childOb.dep.depend();
+	          if (Array.isArray(value)) {
+	            dependArray(value);
+	          }
+	        }
+	      }
+	      return value
+	    },
+	    set: function reactiveSetter (newVal) {
+	      var value = getter ? getter.call(obj) : val;
+	      /* eslint-disable no-self-compare */
+	      if (newVal === value || (newVal !== newVal && value !== value)) {
+	        return
+	      }
+	      /* eslint-enable no-self-compare */
+	      if (process.env.NODE_ENV !== 'production' && customSetter) {
+	        customSetter();
+	      }
+	      if (setter) {
+	        setter.call(obj, newVal);
+	      } else {
+	        val = newVal;
+	      }
+	      childOb = !shallow && observe(newVal);
+	      dep.notify();
+	    }
+	  });
+	}
+
+	/**
+	 * Set a property on an object. Adds the new property and
+	 * triggers change notification if the property doesn't
+	 * already exist.
+	 */
+	function set (target, key, val) {
+	  if (Array.isArray(target) && isValidArrayIndex(key)) {
+	    target.length = Math.max(target.length, key);
+	    target.splice(key, 1, val);
+	    return val
+	  }
+	  if (hasOwn(target, key)) {
+	    target[key] = val;
+	    return val
+	  }
+	  var ob = (target).__ob__;
+	  if (target._isVue || (ob && ob.vmCount)) {
+	    process.env.NODE_ENV !== 'production' && warn(
+	      'Avoid adding reactive properties to a Vue instance or its root $data ' +
+	      'at runtime - declare it upfront in the data option.'
+	    );
+	    return val
+	  }
+	  if (!ob) {
+	    target[key] = val;
+	    return val
+	  }
+	  defineReactive$$1(ob.value, key, val);
+	  ob.dep.notify();
+	  return val
+	}
+
+	/**
+	 * Delete a property and trigger change if necessary.
+	 */
+	function del (target, key) {
+	  if (Array.isArray(target) && isValidArrayIndex(key)) {
+	    target.splice(key, 1);
+	    return
+	  }
+	  var ob = (target).__ob__;
+	  if (target._isVue || (ob && ob.vmCount)) {
+	    process.env.NODE_ENV !== 'production' && warn(
+	      'Avoid deleting properties on a Vue instance or its root $data ' +
+	      '- just set it to null.'
+	    );
+	    return
+	  }
+	  if (!hasOwn(target, key)) {
+	    return
+	  }
+	  delete target[key];
+	  if (!ob) {
+	    return
+	  }
+	  ob.dep.notify();
+	}
+
+	/**
+	 * Collect dependencies on array elements when the array is touched, since
+	 * we cannot intercept array element access like property getters.
+	 */
+	function dependArray (value) {
+	  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+	    e = value[i];
+	    e && e.__ob__ && e.__ob__.dep.depend();
+	    if (Array.isArray(e)) {
+	      dependArray(e);
+	    }
+	  }
+	}
+
+	/*  */
+
+	/**
+	 * Option overwriting strategies are functions that handle
+	 * how to merge a parent option value and a child option
+	 * value into the final value.
+	 */
+	var strats = config.optionMergeStrategies;
+
+	/**
+	 * Options with restrictions
+	 */
+	if (process.env.NODE_ENV !== 'production') {
+	  strats.el = strats.propsData = function (parent, child, vm, key) {
+	    if (!vm) {
+	      warn(
+	        "option \"" + key + "\" can only be used during instance " +
+	        'creation with the `new` keyword.'
+	      );
+	    }
+	    return defaultStrat(parent, child)
+	  };
+	}
+
+	/**
+	 * Helper that recursively merges two data objects together.
+	 */
+	function mergeData (to, from) {
+	  if (!from) { return to }
+	  var key, toVal, fromVal;
+	  var keys = Object.keys(from);
+	  for (var i = 0; i < keys.length; i++) {
+	    key = keys[i];
+	    toVal = to[key];
+	    fromVal = from[key];
+	    if (!hasOwn(to, key)) {
+	      set(to, key, fromVal);
+	    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
+	      mergeData(toVal, fromVal);
+	    }
+	  }
+	  return to
+	}
+
+	/**
+	 * Data
+	 */
+	function mergeDataOrFn (
+	  parentVal,
+	  childVal,
+	  vm
+	) {
+	  if (!vm) {
+	    // in a Vue.extend merge, both should be functions
+	    if (!childVal) {
+	      return parentVal
+	    }
+	    if (!parentVal) {
+	      return childVal
+	    }
+	    // when parentVal & childVal are both present,
+	    // we need to return a function that returns the
+	    // merged result of both functions... no need to
+	    // check if parentVal is a function here because
+	    // it has to be a function to pass previous merges.
+	    return function mergedDataFn () {
+	      return mergeData(
+	        typeof childVal === 'function' ? childVal.call(this) : childVal,
+	        typeof parentVal === 'function' ? parentVal.call(this) : parentVal
+	      )
+	    }
+	  } else if (parentVal || childVal) {
+	    return function mergedInstanceDataFn () {
+	      // instance merge
+	      var instanceData = typeof childVal === 'function'
+	        ? childVal.call(vm)
+	        : childVal;
+	      var defaultData = typeof parentVal === 'function'
+	        ? parentVal.call(vm)
+	        : parentVal;
+	      if (instanceData) {
+	        return mergeData(instanceData, defaultData)
+	      } else {
+	        return defaultData
+	      }
+	    }
+	  }
+	}
+
+	strats.data = function (
+	  parentVal,
+	  childVal,
+	  vm
+	) {
+	  if (!vm) {
+	    if (childVal && typeof childVal !== 'function') {
+	      process.env.NODE_ENV !== 'production' && warn(
+	        'The "data" option should be a function ' +
+	        'that returns a per-instance value in component ' +
+	        'definitions.',
+	        vm
+	      );
+
+	      return parentVal
+	    }
+	    return mergeDataOrFn.call(this, parentVal, childVal)
+	  }
+
+	  return mergeDataOrFn(parentVal, childVal, vm)
+	};
+
+	/**
+	 * Hooks and props are merged as arrays.
+	 */
+	function mergeHook (
+	  parentVal,
+	  childVal
+	) {
+	  return childVal
+	    ? parentVal
+	      ? parentVal.concat(childVal)
+	      : Array.isArray(childVal)
+	        ? childVal
+	        : [childVal]
+	    : parentVal
+	}
+
+	LIFECYCLE_HOOKS.forEach(function (hook) {
+	  strats[hook] = mergeHook;
+	});
+
+	/**
+	 * Assets
+	 *
+	 * When a vm is present (instance creation), we need to do
+	 * a three-way merge between constructor options, instance
+	 * options and parent options.
+	 */
+	function mergeAssets (parentVal, childVal) {
+	  var res = Object.create(parentVal || null);
+	  return childVal
+	    ? extend(res, childVal)
+	    : res
+	}
+
+	ASSET_TYPES.forEach(function (type) {
+	  strats[type + 's'] = mergeAssets;
+	});
+
+	/**
+	 * Watchers.
+	 *
+	 * Watchers hashes should not overwrite one
+	 * another, so we merge them as arrays.
+	 */
+	strats.watch = function (parentVal, childVal) {
+	  // work around Firefox's Object.prototype.watch...
+	  if (parentVal === nativeWatch) { parentVal = undefined; }
+	  if (childVal === nativeWatch) { childVal = undefined; }
+	  /* istanbul ignore if */
+	  if (!childVal) { return Object.create(parentVal || null) }
+	  if (!parentVal) { return childVal }
+	  var ret = {};
+	  extend(ret, parentVal);
+	  for (var key in childVal) {
+	    var parent = ret[key];
+	    var child = childVal[key];
+	    if (parent && !Array.isArray(parent)) {
+	      parent = [parent];
+	    }
+	    ret[key] = parent
+	      ? parent.concat(child)
+	      : Array.isArray(child) ? child : [child];
+	  }
+	  return ret
+	};
+
+	/**
+	 * Other object hashes.
+	 */
+	strats.props =
+	strats.methods =
+	strats.inject =
+	strats.computed = function (parentVal, childVal) {
+	  if (!parentVal) { return childVal }
+	  var ret = Object.create(null);
+	  extend(ret, parentVal);
+	  if (childVal) { extend(ret, childVal); }
+	  return ret
+	};
+	strats.provide = mergeDataOrFn;
+
+	/**
+	 * Default strategy.
+	 */
+	var defaultStrat = function (parentVal, childVal) {
+	  return childVal === undefined
+	    ? parentVal
+	    : childVal
+	};
+
+	/**
+	 * Validate component names
+	 */
+	function checkComponents (options) {
+	  for (var key in options.components) {
+	    var lower = key.toLowerCase();
+	    if (isBuiltInTag(lower) || config.isReservedTag(lower)) {
+	      warn(
+	        'Do not use built-in or reserved HTML elements as component ' +
+	        'id: ' + key
+	      );
+	    }
+	  }
+	}
+
+	/**
+	 * Ensure all props option syntax are normalized into the
+	 * Object-based format.
+	 */
+	function normalizeProps (options) {
+	  var props = options.props;
+	  if (!props) { return }
+	  var res = {};
+	  var i, val, name;
+	  if (Array.isArray(props)) {
+	    i = props.length;
+	    while (i--) {
+	      val = props[i];
+	      if (typeof val === 'string') {
+	        name = camelize(val);
+	        res[name] = { type: null };
+	      } else if (process.env.NODE_ENV !== 'production') {
+	        warn('props must be strings when using array syntax.');
+	      }
+	    }
+	  } else if (isPlainObject(props)) {
+	    for (var key in props) {
+	      val = props[key];
+	      name = camelize(key);
+	      res[name] = isPlainObject(val)
+	        ? val
+	        : { type: val };
+	    }
+	  }
+	  options.props = res;
+	}
+
+	/**
+	 * Normalize all injections into Object-based format
+	 */
+	function normalizeInject (options) {
+	  var inject = options.inject;
+	  if (Array.isArray(inject)) {
+	    var normalized = options.inject = {};
+	    for (var i = 0; i < inject.length; i++) {
+	      normalized[inject[i]] = inject[i];
+	    }
+	  }
+	}
+
+	/**
+	 * Normalize raw function directives into object format.
+	 */
+	function normalizeDirectives (options) {
+	  var dirs = options.directives;
+	  if (dirs) {
+	    for (var key in dirs) {
+	      var def = dirs[key];
+	      if (typeof def === 'function') {
+	        dirs[key] = { bind: def, update: def };
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Merge two option objects into a new one.
+	 * Core utility used in both instantiation and inheritance.
+	 */
+	function mergeOptions (
+	  parent,
+	  child,
+	  vm
+	) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    checkComponents(child);
+	  }
+
+	  if (typeof child === 'function') {
+	    child = child.options;
+	  }
+
+	  normalizeProps(child);
+	  normalizeInject(child);
+	  normalizeDirectives(child);
+	  var extendsFrom = child.extends;
+	  if (extendsFrom) {
+	    parent = mergeOptions(parent, extendsFrom, vm);
+	  }
+	  if (child.mixins) {
+	    for (var i = 0, l = child.mixins.length; i < l; i++) {
+	      parent = mergeOptions(parent, child.mixins[i], vm);
+	    }
+	  }
+	  var options = {};
+	  var key;
+	  for (key in parent) {
+	    mergeField(key);
+	  }
+	  for (key in child) {
+	    if (!hasOwn(parent, key)) {
+	      mergeField(key);
+	    }
+	  }
+	  function mergeField (key) {
+	    var strat = strats[key] || defaultStrat;
+	    options[key] = strat(parent[key], child[key], vm, key);
+	  }
+	  return options
+	}
+
+	/**
+	 * Resolve an asset.
+	 * This function is used because child instances need access
+	 * to assets defined in its ancestor chain.
+	 */
+	function resolveAsset (
+	  options,
+	  type,
+	  id,
+	  warnMissing
+	) {
+	  /* istanbul ignore if */
+	  if (typeof id !== 'string') {
+	    return
+	  }
+	  var assets = options[type];
+	  // check local registration variations first
+	  if (hasOwn(assets, id)) { return assets[id] }
+	  var camelizedId = camelize(id);
+	  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
+	  var PascalCaseId = capitalize(camelizedId);
+	  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
+	  // fallback to prototype chain
+	  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+	  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
+	    warn(
+	      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
+	      options
+	    );
+	  }
+	  return res
+	}
+
+	/*  */
+
+	function validateProp (
+	  key,
+	  propOptions,
+	  propsData,
+	  vm
+	) {
+	  var prop = propOptions[key];
+	  var absent = !hasOwn(propsData, key);
+	  var value = propsData[key];
+	  // handle boolean props
+	  if (isType(Boolean, prop.type)) {
+	    if (absent && !hasOwn(prop, 'default')) {
+	      value = false;
+	    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
+	      value = true;
+	    }
+	  }
+	  // check default value
+	  if (value === undefined) {
+	    value = getPropDefaultValue(vm, prop, key);
+	    // since the default value is a fresh copy,
+	    // make sure to observe it.
+	    var prevShouldConvert = observerState.shouldConvert;
+	    observerState.shouldConvert = true;
+	    observe(value);
+	    observerState.shouldConvert = prevShouldConvert;
+	  }
+	  if (process.env.NODE_ENV !== 'production') {
+	    assertProp(prop, key, value, vm, absent);
+	  }
+	  return value
+	}
+
+	/**
+	 * Get the default value of a prop.
+	 */
+	function getPropDefaultValue (vm, prop, key) {
+	  // no default, return undefined
+	  if (!hasOwn(prop, 'default')) {
+	    return undefined
+	  }
+	  var def = prop.default;
+	  // warn against non-factory defaults for Object & Array
+	  if (process.env.NODE_ENV !== 'production' && isObject(def)) {
+	    warn(
+	      'Invalid default value for prop "' + key + '": ' +
+	      'Props with type Object/Array must use a factory function ' +
+	      'to return the default value.',
+	      vm
+	    );
+	  }
+	  // the raw prop value was also undefined from previous render,
+	  // return previous default value to avoid unnecessary watcher trigger
+	  if (vm && vm.$options.propsData &&
+	    vm.$options.propsData[key] === undefined &&
+	    vm._props[key] !== undefined
+	  ) {
+	    return vm._props[key]
+	  }
+	  // call factory function for non-Function types
+	  // a value is Function if its prototype is function even across different execution context
+	  return typeof def === 'function' && getType(prop.type) !== 'Function'
+	    ? def.call(vm)
+	    : def
+	}
+
+	/**
+	 * Assert whether a prop is valid.
+	 */
+	function assertProp (
+	  prop,
+	  name,
+	  value,
+	  vm,
+	  absent
+	) {
+	  if (prop.required && absent) {
+	    warn(
+	      'Missing required prop: "' + name + '"',
+	      vm
+	    );
+	    return
+	  }
+	  if (value == null && !prop.required) {
+	    return
+	  }
+	  var type = prop.type;
+	  var valid = !type || type === true;
+	  var expectedTypes = [];
+	  if (type) {
+	    if (!Array.isArray(type)) {
+	      type = [type];
+	    }
+	    for (var i = 0; i < type.length && !valid; i++) {
+	      var assertedType = assertType(value, type[i]);
+	      expectedTypes.push(assertedType.expectedType || '');
+	      valid = assertedType.valid;
+	    }
+	  }
+	  if (!valid) {
+	    warn(
+	      'Invalid prop: type check failed for prop "' + name + '".' +
+	      ' Expected ' + expectedTypes.map(capitalize).join(', ') +
+	      ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',
+	      vm
+	    );
+	    return
+	  }
+	  var validator = prop.validator;
+	  if (validator) {
+	    if (!validator(value)) {
+	      warn(
+	        'Invalid prop: custom validator check failed for prop "' + name + '".',
+	        vm
+	      );
+	    }
+	  }
+	}
+
+	var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
+
+	function assertType (value, type) {
+	  var valid;
+	  var expectedType = getType(type);
+	  if (simpleCheckRE.test(expectedType)) {
+	    var t = typeof value;
+	    valid = t === expectedType.toLowerCase();
+	    // for primitive wrapper objects
+	    if (!valid && t === 'object') {
+	      valid = value instanceof type;
+	    }
+	  } else if (expectedType === 'Object') {
+	    valid = isPlainObject(value);
+	  } else if (expectedType === 'Array') {
+	    valid = Array.isArray(value);
+	  } else {
+	    valid = value instanceof type;
+	  }
+	  return {
+	    valid: valid,
+	    expectedType: expectedType
+	  }
+	}
+
+	/**
+	 * Use function string name to check built-in types,
+	 * because a simple equality check will fail when running
+	 * across different vms / iframes.
+	 */
+	function getType (fn) {
+	  var match = fn && fn.toString().match(/^\s*function (\w+)/);
+	  return match ? match[1] : ''
+	}
+
+	function isType (type, fn) {
+	  if (!Array.isArray(fn)) {
+	    return getType(fn) === getType(type)
+	  }
+	  for (var i = 0, len = fn.length; i < len; i++) {
+	    if (getType(fn[i]) === getType(type)) {
+	      return true
+	    }
+	  }
+	  /* istanbul ignore next */
+	  return false
+	}
+
+	/*  */
+
+	/* not type checking this file because flow doesn't play well with Proxy */
+
+	var initProxy;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var allowedGlobals = makeMap(
+	    'Infinity,undefined,NaN,isFinite,isNaN,' +
+	    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+	    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
+	    'require' // for Webpack/Browserify
+	  );
+
+	  var warnNonPresent = function (target, key) {
+	    warn(
+	      "Property or method \"" + key + "\" is not defined on the instance but " +
+	      "referenced during render. Make sure to declare reactive data " +
+	      "properties in the data option.",
+	      target
+	    );
+	  };
+
+	  var hasProxy =
+	    typeof Proxy !== 'undefined' &&
+	    Proxy.toString().match(/native code/);
+
+	  if (hasProxy) {
+	    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');
+	    config.keyCodes = new Proxy(config.keyCodes, {
+	      set: function set (target, key, value) {
+	        if (isBuiltInModifier(key)) {
+	          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+	          return false
+	        } else {
+	          target[key] = value;
+	          return true
+	        }
+	      }
+	    });
+	  }
+
+	  var hasHandler = {
+	    has: function has (target, key) {
+	      var has = key in target;
+	      var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';
+	      if (!has && !isAllowed) {
+	        warnNonPresent(target, key);
+	      }
+	      return has || !isAllowed
+	    }
+	  };
+
+	  var getHandler = {
+	    get: function get (target, key) {
+	      if (typeof key === 'string' && !(key in target)) {
+	        warnNonPresent(target, key);
+	      }
+	      return target[key]
+	    }
+	  };
+
+	  initProxy = function initProxy (vm) {
+	    if (hasProxy) {
+	      // determine which proxy handler to use
+	      var options = vm.$options;
+	      var handlers = options.render && options.render._withStripped
+	        ? getHandler
+	        : hasHandler;
+	      vm._renderProxy = new Proxy(vm, handlers);
+	    } else {
+	      vm._renderProxy = vm;
+	    }
+	  };
+	}
+
+	var mark;
+	var measure;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var perf = inBrowser && window.performance;
+	  /* istanbul ignore if */
+	  if (
+	    perf &&
+	    perf.mark &&
+	    perf.measure &&
+	    perf.clearMarks &&
+	    perf.clearMeasures
+	  ) {
+	    mark = function (tag) { return perf.mark(tag); };
+	    measure = function (name, startTag, endTag) {
+	      perf.measure(name, startTag, endTag);
+	      perf.clearMarks(startTag);
+	      perf.clearMarks(endTag);
+	      perf.clearMeasures(name);
+	    };
+	  }
+	}
+
+	/*  */
+
+	var VNode = function VNode (
+	  tag,
+	  data,
+	  children,
+	  text,
+	  elm,
+	  context,
+	  componentOptions,
+	  asyncFactory
+	) {
+	  this.tag = tag;
+	  this.data = data;
+	  this.children = children;
+	  this.text = text;
+	  this.elm = elm;
+	  this.ns = undefined;
+	  this.context = context;
+	  this.functionalContext = undefined;
+	  this.key = data && data.key;
+	  this.componentOptions = componentOptions;
+	  this.componentInstance = undefined;
+	  this.parent = undefined;
+	  this.raw = false;
+	  this.isStatic = false;
+	  this.isRootInsert = true;
+	  this.isComment = false;
+	  this.isCloned = false;
+	  this.isOnce = false;
+	  this.asyncFactory = asyncFactory;
+	  this.asyncMeta = undefined;
+	  this.isAsyncPlaceholder = false;
+	};
+
+	var prototypeAccessors = { child: {} };
+
+	// DEPRECATED: alias for componentInstance for backwards compat.
+	/* istanbul ignore next */
+	prototypeAccessors.child.get = function () {
+	  return this.componentInstance
+	};
+
+	Object.defineProperties( VNode.prototype, prototypeAccessors );
+
+	var createEmptyVNode = function (text) {
+	  if ( text === void 0 ) text = '';
+
+	  var node = new VNode();
+	  node.text = text;
+	  node.isComment = true;
+	  return node
+	};
+
+	function createTextVNode (val) {
+	  return new VNode(undefined, undefined, undefined, String(val))
+	}
+
+	// optimized shallow clone
+	// used for static nodes and slot nodes because they may be reused across
+	// multiple renders, cloning them avoids errors when DOM manipulations rely
+	// on their elm reference.
+	function cloneVNode (vnode, deep) {
+	  var cloned = new VNode(
+	    vnode.tag,
+	    vnode.data,
+	    vnode.children,
+	    vnode.text,
+	    vnode.elm,
+	    vnode.context,
+	    vnode.componentOptions,
+	    vnode.asyncFactory
+	  );
+	  cloned.ns = vnode.ns;
+	  cloned.isStatic = vnode.isStatic;
+	  cloned.key = vnode.key;
+	  cloned.isComment = vnode.isComment;
+	  cloned.isCloned = true;
+	  if (deep && vnode.children) {
+	    cloned.children = cloneVNodes(vnode.children);
+	  }
+	  return cloned
+	}
+
+	function cloneVNodes (vnodes, deep) {
+	  var len = vnodes.length;
+	  var res = new Array(len);
+	  for (var i = 0; i < len; i++) {
+	    res[i] = cloneVNode(vnodes[i], deep);
+	  }
+	  return res
+	}
+
+	/*  */
+
+	var normalizeEvent = cached(function (name) {
+	  var passive = name.charAt(0) === '&';
+	  name = passive ? name.slice(1) : name;
+	  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+	  name = once$$1 ? name.slice(1) : name;
+	  var capture = name.charAt(0) === '!';
+	  name = capture ? name.slice(1) : name;
+	  var plain = !(passive || once$$1 || capture);
+	  return {
+	    name: name,
+	    plain: plain,
+	    once: once$$1,
+	    capture: capture,
+	    passive: passive
+	  }
+	});
+
+	function createFnInvoker (fns) {
+	  function invoker () {
+	    var arguments$1 = arguments;
+
+	    var fns = invoker.fns;
+	    if (Array.isArray(fns)) {
+	      var cloned = fns.slice();
+	      for (var i = 0; i < cloned.length; i++) {
+	        cloned[i].apply(null, arguments$1);
+	      }
+	    } else {
+	      // return handler return value for single handlers
+	      return fns.apply(null, arguments)
+	    }
+	  }
+	  invoker.fns = fns;
+	  return invoker
+	}
+
+	// #6552
+	function prioritizePlainEvents (a, b) {
+	  return a.plain ? -1 : b.plain ? 1 : 0
+	}
+
+	function updateListeners (
+	  on,
+	  oldOn,
+	  add,
+	  remove$$1,
+	  vm
+	) {
+	  var name, cur, old, event;
+	  var toAdd = [];
+	  var hasModifier = false;
+	  for (name in on) {
+	    cur = on[name];
+	    old = oldOn[name];
+	    event = normalizeEvent(name);
+	    if (!event.plain) { hasModifier = true; }
+	    if (isUndef(cur)) {
+	      process.env.NODE_ENV !== 'production' && warn(
+	        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
+	        vm
+	      );
+	    } else if (isUndef(old)) {
+	      if (isUndef(cur.fns)) {
+	        cur = on[name] = createFnInvoker(cur);
+	      }
+	      event.handler = cur;
+	      toAdd.push(event);
+	    } else if (cur !== old) {
+	      old.fns = cur;
+	      on[name] = old;
+	    }
+	  }
+	  if (toAdd.length) {
+	    if (hasModifier) { toAdd.sort(prioritizePlainEvents); }
+	    for (var i = 0; i < toAdd.length; i++) {
+	      var event$1 = toAdd[i];
+	      add(event$1.name, event$1.handler, event$1.once, event$1.capture, event$1.passive);
+	    }
+	  }
+	  for (name in oldOn) {
+	    if (isUndef(on[name])) {
+	      event = normalizeEvent(name);
+	      remove$$1(event.name, oldOn[name], event.capture);
+	    }
+	  }
+	}
+
+	/*  */
+
+	function mergeVNodeHook (def, hookKey, hook) {
+	  var invoker;
+	  var oldHook = def[hookKey];
+
+	  function wrappedHook () {
+	    hook.apply(this, arguments);
+	    // important: remove merged hook to ensure it's called only once
+	    // and prevent memory leak
+	    remove(invoker.fns, wrappedHook);
+	  }
+
+	  if (isUndef(oldHook)) {
+	    // no existing hook
+	    invoker = createFnInvoker([wrappedHook]);
+	  } else {
+	    /* istanbul ignore if */
+	    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+	      // already a merged invoker
+	      invoker = oldHook;
+	      invoker.fns.push(wrappedHook);
+	    } else {
+	      // existing plain hook
+	      invoker = createFnInvoker([oldHook, wrappedHook]);
+	    }
+	  }
+
+	  invoker.merged = true;
+	  def[hookKey] = invoker;
+	}
+
+	/*  */
+
+	function extractPropsFromVNodeData (
+	  data,
+	  Ctor,
+	  tag
+	) {
+	  // we are only extracting raw values here.
+	  // validation and default values are handled in the child
+	  // component itself.
+	  var propOptions = Ctor.options.props;
+	  if (isUndef(propOptions)) {
+	    return
+	  }
+	  var res = {};
+	  var attrs = data.attrs;
+	  var props = data.props;
+	  if (isDef(attrs) || isDef(props)) {
+	    for (var key in propOptions) {
+	      var altKey = hyphenate(key);
+	      if (process.env.NODE_ENV !== 'production') {
+	        var keyInLowerCase = key.toLowerCase();
+	        if (
+	          key !== keyInLowerCase &&
+	          attrs && hasOwn(attrs, keyInLowerCase)
+	        ) {
+	          tip(
+	            "Prop \"" + keyInLowerCase + "\" is passed to component " +
+	            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
+	            " \"" + key + "\". " +
+	            "Note that HTML attributes are case-insensitive and camelCased " +
+	            "props need to use their kebab-case equivalents when using in-DOM " +
+	            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
+	          );
+	        }
+	      }
+	      checkProp(res, props, key, altKey, true) ||
+	      checkProp(res, attrs, key, altKey, false);
+	    }
+	  }
+	  return res
+	}
+
+	function checkProp (
+	  res,
+	  hash,
+	  key,
+	  altKey,
+	  preserve
+	) {
+	  if (isDef(hash)) {
+	    if (hasOwn(hash, key)) {
+	      res[key] = hash[key];
+	      if (!preserve) {
+	        delete hash[key];
+	      }
+	      return true
+	    } else if (hasOwn(hash, altKey)) {
+	      res[key] = hash[altKey];
+	      if (!preserve) {
+	        delete hash[altKey];
+	      }
+	      return true
+	    }
+	  }
+	  return false
+	}
+
+	/*  */
+
+	// The template compiler attempts to minimize the need for normalization by
+	// statically analyzing the template at compile time.
+	//
+	// For plain HTML markup, normalization can be completely skipped because the
+	// generated render function is guaranteed to return Array<VNode>. There are
+	// two cases where extra normalization is needed:
+
+	// 1. When the children contains components - because a functional component
+	// may return an Array instead of a single root. In this case, just a simple
+	// normalization is needed - if any child is an Array, we flatten the whole
+	// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+	// because functional components already normalize their own children.
+	function simpleNormalizeChildren (children) {
+	  for (var i = 0; i < children.length; i++) {
+	    if (Array.isArray(children[i])) {
+	      return Array.prototype.concat.apply([], children)
+	    }
+	  }
+	  return children
+	}
+
+	// 2. When the children contains constructs that always generated nested Arrays,
+	// e.g. <template>, <slot>, v-for, or when the children is provided by user
+	// with hand-written render functions / JSX. In such cases a full normalization
+	// is needed to cater to all possible types of children values.
+	function normalizeChildren (children) {
+	  return isPrimitive(children)
+	    ? [createTextVNode(children)]
+	    : Array.isArray(children)
+	      ? normalizeArrayChildren(children)
+	      : undefined
+	}
+
+	function isTextNode (node) {
+	  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
+	}
+
+	function normalizeArrayChildren (children, nestedIndex) {
+	  var res = [];
+	  var i, c, last;
+	  for (i = 0; i < children.length; i++) {
+	    c = children[i];
+	    if (isUndef(c) || typeof c === 'boolean') { continue }
+	    last = res[res.length - 1];
+	    //  nested
+	    if (Array.isArray(c)) {
+	      res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i)));
+	    } else if (isPrimitive(c)) {
+	      if (isTextNode(last)) {
+	        // merge adjacent text nodes
+	        // this is necessary for SSR hydration because text nodes are
+	        // essentially merged when rendered to HTML strings
+	        (last).text += String(c);
+	      } else if (c !== '') {
+	        // convert primitive to vnode
+	        res.push(createTextVNode(c));
+	      }
+	    } else {
+	      if (isTextNode(c) && isTextNode(last)) {
+	        // merge adjacent text nodes
+	        res[res.length - 1] = createTextVNode(last.text + c.text);
+	      } else {
+	        // default key for nested array children (likely generated by v-for)
+	        if (isTrue(children._isVList) &&
+	          isDef(c.tag) &&
+	          isUndef(c.key) &&
+	          isDef(nestedIndex)) {
+	          c.key = "__vlist" + nestedIndex + "_" + i + "__";
+	        }
+	        res.push(c);
+	      }
+	    }
+	  }
+	  return res
+	}
+
+	/*  */
+
+	function ensureCtor (comp, base) {
+	  if (comp.__esModule && comp.default) {
+	    comp = comp.default;
+	  }
+	  return isObject(comp)
+	    ? base.extend(comp)
+	    : comp
+	}
+
+	function createAsyncPlaceholder (
+	  factory,
+	  data,
+	  context,
+	  children,
+	  tag
+	) {
+	  var node = createEmptyVNode();
+	  node.asyncFactory = factory;
+	  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+	  return node
+	}
+
+	function resolveAsyncComponent (
+	  factory,
+	  baseCtor,
+	  context
+	) {
+	  if (isTrue(factory.error) && isDef(factory.errorComp)) {
+	    return factory.errorComp
+	  }
+
+	  if (isDef(factory.resolved)) {
+	    return factory.resolved
+	  }
+
+	  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+	    return factory.loadingComp
+	  }
+
+	  if (isDef(factory.contexts)) {
+	    // already pending
+	    factory.contexts.push(context);
+	  } else {
+	    var contexts = factory.contexts = [context];
+	    var sync = true;
+
+	    var forceRender = function () {
+	      for (var i = 0, l = contexts.length; i < l; i++) {
+	        contexts[i].$forceUpdate();
+	      }
+	    };
+
+	    var resolve = once(function (res) {
+	      // cache resolved
+	      factory.resolved = ensureCtor(res, baseCtor);
+	      // invoke callbacks only if this is not a synchronous resolve
+	      // (async resolves are shimmed as synchronous during SSR)
+	      if (!sync) {
+	        forceRender();
+	      }
+	    });
+
+	    var reject = once(function (reason) {
+	      process.env.NODE_ENV !== 'production' && warn(
+	        "Failed to resolve async component: " + (String(factory)) +
+	        (reason ? ("\nReason: " + reason) : '')
+	      );
+	      if (isDef(factory.errorComp)) {
+	        factory.error = true;
+	        forceRender();
+	      }
+	    });
+
+	    var res = factory(resolve, reject);
+
+	    if (isObject(res)) {
+	      if (typeof res.then === 'function') {
+	        // () => Promise
+	        if (isUndef(factory.resolved)) {
+	          res.then(resolve, reject);
+	        }
+	      } else if (isDef(res.component) && typeof res.component.then === 'function') {
+	        res.component.then(resolve, reject);
+
+	        if (isDef(res.error)) {
+	          factory.errorComp = ensureCtor(res.error, baseCtor);
+	        }
+
+	        if (isDef(res.loading)) {
+	          factory.loadingComp = ensureCtor(res.loading, baseCtor);
+	          if (res.delay === 0) {
+	            factory.loading = true;
+	          } else {
+	            setTimeout(function () {
+	              if (isUndef(factory.resolved) && isUndef(factory.error)) {
+	                factory.loading = true;
+	                forceRender();
+	              }
+	            }, res.delay || 200);
+	          }
+	        }
+
+	        if (isDef(res.timeout)) {
+	          setTimeout(function () {
+	            if (isUndef(factory.resolved)) {
+	              reject(
+	                process.env.NODE_ENV !== 'production'
+	                  ? ("timeout (" + (res.timeout) + "ms)")
+	                  : null
+	              );
+	            }
+	          }, res.timeout);
+	        }
+	      }
+	    }
+
+	    sync = false;
+	    // return in case resolved synchronously
+	    return factory.loading
+	      ? factory.loadingComp
+	      : factory.resolved
+	  }
+	}
+
+	/*  */
+
+	function isAsyncPlaceholder (node) {
+	  return node.isComment && node.asyncFactory
+	}
+
+	/*  */
+
+	function getFirstComponentChild (children) {
+	  if (Array.isArray(children)) {
+	    for (var i = 0; i < children.length; i++) {
+	      var c = children[i];
+	      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+	        return c
+	      }
+	    }
+	  }
+	}
+
+	/*  */
+
+	/*  */
+
+	function initEvents (vm) {
+	  vm._events = Object.create(null);
+	  vm._hasHookEvent = false;
+	  // init parent attached events
+	  var listeners = vm.$options._parentListeners;
+	  if (listeners) {
+	    updateComponentListeners(vm, listeners);
+	  }
+	}
+
+	var target;
+
+	function add (event, fn, once$$1) {
+	  if (once$$1) {
+	    target.$once(event, fn);
+	  } else {
+	    target.$on(event, fn);
+	  }
+	}
+
+	function remove$1 (event, fn) {
+	  target.$off(event, fn);
+	}
+
+	function updateComponentListeners (
+	  vm,
+	  listeners,
+	  oldListeners
+	) {
+	  target = vm;
+	  updateListeners(listeners, oldListeners || {}, add, remove$1, vm);
+	}
+
+	function eventsMixin (Vue) {
+	  var hookRE = /^hook:/;
+	  Vue.prototype.$on = function (event, fn) {
+	    var this$1 = this;
+
+	    var vm = this;
+	    if (Array.isArray(event)) {
+	      for (var i = 0, l = event.length; i < l; i++) {
+	        this$1.$on(event[i], fn);
+	      }
+	    } else {
+	      (vm._events[event] || (vm._events[event] = [])).push(fn);
+	      // optimize hook:event cost by using a boolean flag marked at registration
+	      // instead of a hash lookup
+	      if (hookRE.test(event)) {
+	        vm._hasHookEvent = true;
+	      }
+	    }
+	    return vm
+	  };
+
+	  Vue.prototype.$once = function (event, fn) {
+	    var vm = this;
+	    function on () {
+	      vm.$off(event, on);
+	      fn.apply(vm, arguments);
+	    }
+	    on.fn = fn;
+	    vm.$on(event, on);
+	    return vm
+	  };
+
+	  Vue.prototype.$off = function (event, fn) {
+	    var this$1 = this;
+
+	    var vm = this;
+	    // all
+	    if (!arguments.length) {
+	      vm._events = Object.create(null);
+	      return vm
+	    }
+	    // array of events
+	    if (Array.isArray(event)) {
+	      for (var i = 0, l = event.length; i < l; i++) {
+	        this$1.$off(event[i], fn);
+	      }
+	      return vm
+	    }
+	    // specific event
+	    var cbs = vm._events[event];
+	    if (!cbs) {
+	      return vm
+	    }
+	    if (arguments.length === 1) {
+	      vm._events[event] = null;
+	      return vm
+	    }
+	    if (fn) {
+	      // specific handler
+	      var cb;
+	      var i$1 = cbs.length;
+	      while (i$1--) {
+	        cb = cbs[i$1];
+	        if (cb === fn || cb.fn === fn) {
+	          cbs.splice(i$1, 1);
+	          break
+	        }
+	      }
+	    }
+	    return vm
+	  };
+
+	  Vue.prototype.$emit = function (event) {
+	    var vm = this;
+	    if (process.env.NODE_ENV !== 'production') {
+	      var lowerCaseEvent = event.toLowerCase();
+	      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+	        tip(
+	          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
+	          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+	          "Note that HTML attributes are case-insensitive and you cannot use " +
+	          "v-on to listen to camelCase events when using in-DOM templates. " +
+	          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
+	        );
+	      }
+	    }
+	    var cbs = vm._events[event];
+	    if (cbs) {
+	      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+	      var args = toArray(arguments, 1);
+	      for (var i = 0, l = cbs.length; i < l; i++) {
+	        try {
+	          cbs[i].apply(vm, args);
+	        } catch (e) {
+	          handleError(e, vm, ("event handler for \"" + event + "\""));
+	        }
+	      }
+	    }
+	    return vm
+	  };
+	}
+
+	/*  */
+
+	/**
+	 * Runtime helper for resolving raw children VNodes into a slot object.
+	 */
+	function resolveSlots (
+	  children,
+	  context
+	) {
+	  var slots = {};
+	  if (!children) {
+	    return slots
+	  }
+	  var defaultSlot = [];
+	  for (var i = 0, l = children.length; i < l; i++) {
+	    var child = children[i];
+	    var data = child.data;
+	    // remove slot attribute if the node is resolved as a Vue slot node
+	    if (data && data.attrs && data.attrs.slot) {
+	      delete data.attrs.slot;
+	    }
+	    // named slots should only be respected if the vnode was rendered in the
+	    // same context.
+	    if ((child.context === context || child.functionalContext === context) &&
+	      data && data.slot != null
+	    ) {
+	      var name = child.data.slot;
+	      var slot = (slots[name] || (slots[name] = []));
+	      if (child.tag === 'template') {
+	        slot.push.apply(slot, child.children);
+	      } else {
+	        slot.push(child);
+	      }
+	    } else {
+	      defaultSlot.push(child);
+	    }
+	  }
+	  // ignore whitespace
+	  if (!defaultSlot.every(isWhitespace)) {
+	    slots.default = defaultSlot;
+	  }
+	  return slots
+	}
+
+	function isWhitespace (node) {
+	  return node.isComment || node.text === ' '
+	}
+
+	function resolveScopedSlots (
+	  fns, // see flow/vnode
+	  res
+	) {
+	  res = res || {};
+	  for (var i = 0; i < fns.length; i++) {
+	    if (Array.isArray(fns[i])) {
+	      resolveScopedSlots(fns[i], res);
+	    } else {
+	      res[fns[i].key] = fns[i].fn;
+	    }
+	  }
+	  return res
+	}
+
+	/*  */
+
+	var activeInstance = null;
+	var isUpdatingChildComponent = false;
+
+	function initLifecycle (vm) {
+	  var options = vm.$options;
+
+	  // locate first non-abstract parent
+	  var parent = options.parent;
+	  if (parent && !options.abstract) {
+	    while (parent.$options.abstract && parent.$parent) {
+	      parent = parent.$parent;
+	    }
+	    parent.$children.push(vm);
+	  }
+
+	  vm.$parent = parent;
+	  vm.$root = parent ? parent.$root : vm;
+
+	  vm.$children = [];
+	  vm.$refs = {};
+
+	  vm._watcher = null;
+	  vm._inactive = null;
+	  vm._directInactive = false;
+	  vm._isMounted = false;
+	  vm._isDestroyed = false;
+	  vm._isBeingDestroyed = false;
+	}
+
+	function lifecycleMixin (Vue) {
+	  Vue.prototype._update = function (vnode, hydrating) {
+	    var vm = this;
+	    if (vm._isMounted) {
+	      callHook(vm, 'beforeUpdate');
+	    }
+	    var prevEl = vm.$el;
+	    var prevVnode = vm._vnode;
+	    var prevActiveInstance = activeInstance;
+	    activeInstance = vm;
+	    vm._vnode = vnode;
+	    // Vue.prototype.__patch__ is injected in entry points
+	    // based on the rendering backend used.
+	    if (!prevVnode) {
+	      // initial render
+	      vm.$el = vm.__patch__(
+	        vm.$el, vnode, hydrating, false /* removeOnly */,
+	        vm.$options._parentElm,
+	        vm.$options._refElm
+	      );
+	      // no need for the ref nodes after initial patch
+	      // this prevents keeping a detached DOM tree in memory (#5851)
+	      vm.$options._parentElm = vm.$options._refElm = null;
+	    } else {
+	      // updates
+	      vm.$el = vm.__patch__(prevVnode, vnode);
+	    }
+	    activeInstance = prevActiveInstance;
+	    // update __vue__ reference
+	    if (prevEl) {
+	      prevEl.__vue__ = null;
+	    }
+	    if (vm.$el) {
+	      vm.$el.__vue__ = vm;
+	    }
+	    // if parent is an HOC, update its $el as well
+	    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+	      vm.$parent.$el = vm.$el;
+	    }
+	    // updated hook is called by the scheduler to ensure that children are
+	    // updated in a parent's updated hook.
+	  };
+
+	  Vue.prototype.$forceUpdate = function () {
+	    var vm = this;
+	    if (vm._watcher) {
+	      vm._watcher.update();
+	    }
+	  };
+
+	  Vue.prototype.$destroy = function () {
+	    var vm = this;
+	    if (vm._isBeingDestroyed) {
+	      return
+	    }
+	    callHook(vm, 'beforeDestroy');
+	    vm._isBeingDestroyed = true;
+	    // remove self from parent
+	    var parent = vm.$parent;
+	    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+	      remove(parent.$children, vm);
+	    }
+	    // teardown watchers
+	    if (vm._watcher) {
+	      vm._watcher.teardown();
+	    }
+	    var i = vm._watchers.length;
+	    while (i--) {
+	      vm._watchers[i].teardown();
+	    }
+	    // remove reference from data ob
+	    // frozen object may not have observer.
+	    if (vm._data.__ob__) {
+	      vm._data.__ob__.vmCount--;
+	    }
+	    // call the last hook...
+	    vm._isDestroyed = true;
+	    // invoke destroy hooks on current rendered tree
+	    vm.__patch__(vm._vnode, null);
+	    // fire destroyed hook
+	    callHook(vm, 'destroyed');
+	    // turn off all instance listeners.
+	    vm.$off();
+	    // remove __vue__ reference
+	    if (vm.$el) {
+	      vm.$el.__vue__ = null;
+	    }
+	  };
+	}
+
+	function mountComponent (
+	  vm,
+	  el,
+	  hydrating
+	) {
+	  vm.$el = el;
+	  if (!vm.$options.render) {
+	    vm.$options.render = createEmptyVNode;
+	    if (process.env.NODE_ENV !== 'production') {
+	      /* istanbul ignore if */
+	      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+	        vm.$options.el || el) {
+	        warn(
+	          'You are using the runtime-only build of Vue where the template ' +
+	          'compiler is not available. Either pre-compile the templates into ' +
+	          'render functions, or use the compiler-included build.',
+	          vm
+	        );
+	      } else {
+	        warn(
+	          'Failed to mount component: template or render function not defined.',
+	          vm
+	        );
+	      }
+	    }
+	  }
+	  callHook(vm, 'beforeMount');
+
+	  var updateComponent;
+	  /* istanbul ignore if */
+	  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+	    updateComponent = function () {
+	      var name = vm._name;
+	      var id = vm._uid;
+	      var startTag = "vue-perf-start:" + id;
+	      var endTag = "vue-perf-end:" + id;
+
+	      mark(startTag);
+	      var vnode = vm._render();
+	      mark(endTag);
+	      measure((name + " render"), startTag, endTag);
+
+	      mark(startTag);
+	      vm._update(vnode, hydrating);
+	      mark(endTag);
+	      measure((name + " patch"), startTag, endTag);
+	    };
+	  } else {
+	    updateComponent = function () {
+	      vm._update(vm._render(), hydrating);
+	    };
+	  }
+
+	  vm._watcher = new Watcher(vm, updateComponent, noop);
+	  hydrating = false;
+
+	  // manually mounted instance, call mounted on self
+	  // mounted is called for render-created child components in its inserted hook
+	  if (vm.$vnode == null) {
+	    vm._isMounted = true;
+	    callHook(vm, 'mounted');
+	  }
+	  return vm
+	}
+
+	function updateChildComponent (
+	  vm,
+	  propsData,
+	  listeners,
+	  parentVnode,
+	  renderChildren
+	) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    isUpdatingChildComponent = true;
+	  }
+
+	  // determine whether component has slot children
+	  // we need to do this before overwriting $options._renderChildren
+	  var hasChildren = !!(
+	    renderChildren ||               // has new static slots
+	    vm.$options._renderChildren ||  // has old static slots
+	    parentVnode.data.scopedSlots || // has new scoped slots
+	    vm.$scopedSlots !== emptyObject // has old scoped slots
+	  );
+
+	  vm.$options._parentVnode = parentVnode;
+	  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+
+	  if (vm._vnode) { // update child tree's parent
+	    vm._vnode.parent = parentVnode;
+	  }
+	  vm.$options._renderChildren = renderChildren;
+
+	  // update $attrs and $listeners hash
+	  // these are also reactive so they may trigger child update if the child
+	  // used them during render
+	  vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject;
+	  vm.$listeners = listeners || emptyObject;
+
+	  // update props
+	  if (propsData && vm.$options.props) {
+	    observerState.shouldConvert = false;
+	    var props = vm._props;
+	    var propKeys = vm.$options._propKeys || [];
+	    for (var i = 0; i < propKeys.length; i++) {
+	      var key = propKeys[i];
+	      props[key] = validateProp(key, vm.$options.props, propsData, vm);
+	    }
+	    observerState.shouldConvert = true;
+	    // keep a copy of raw propsData
+	    vm.$options.propsData = propsData;
+	  }
+
+	  // update listeners
+	  if (listeners) {
+	    var oldListeners = vm.$options._parentListeners;
+	    vm.$options._parentListeners = listeners;
+	    updateComponentListeners(vm, listeners, oldListeners);
+	  }
+	  // resolve slots + force update if has children
+	  if (hasChildren) {
+	    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+	    vm.$forceUpdate();
+	  }
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    isUpdatingChildComponent = false;
+	  }
+	}
+
+	function isInInactiveTree (vm) {
+	  while (vm && (vm = vm.$parent)) {
+	    if (vm._inactive) { return true }
+	  }
+	  return false
+	}
+
+	function activateChildComponent (vm, direct) {
+	  if (direct) {
+	    vm._directInactive = false;
+	    if (isInInactiveTree(vm)) {
+	      return
+	    }
+	  } else if (vm._directInactive) {
+	    return
+	  }
+	  if (vm._inactive || vm._inactive === null) {
+	    vm._inactive = false;
+	    for (var i = 0; i < vm.$children.length; i++) {
+	      activateChildComponent(vm.$children[i]);
+	    }
+	    callHook(vm, 'activated');
+	  }
+	}
+
+	function deactivateChildComponent (vm, direct) {
+	  if (direct) {
+	    vm._directInactive = true;
+	    if (isInInactiveTree(vm)) {
+	      return
+	    }
+	  }
+	  if (!vm._inactive) {
+	    vm._inactive = true;
+	    for (var i = 0; i < vm.$children.length; i++) {
+	      deactivateChildComponent(vm.$children[i]);
+	    }
+	    callHook(vm, 'deactivated');
+	  }
+	}
+
+	function callHook (vm, hook) {
+	  var handlers = vm.$options[hook];
+	  if (handlers) {
+	    for (var i = 0, j = handlers.length; i < j; i++) {
+	      try {
+	        handlers[i].call(vm);
+	      } catch (e) {
+	        handleError(e, vm, (hook + " hook"));
+	      }
+	    }
+	  }
+	  if (vm._hasHookEvent) {
+	    vm.$emit('hook:' + hook);
+	  }
+	}
+
+	/*  */
+
+
+	var MAX_UPDATE_COUNT = 100;
+
+	var queue = [];
+	var activatedChildren = [];
+	var has = {};
+	var circular = {};
+	var waiting = false;
+	var flushing = false;
+	var index = 0;
+
+	/**
+	 * Reset the scheduler's state.
+	 */
+	function resetSchedulerState () {
+	  index = queue.length = activatedChildren.length = 0;
+	  has = {};
+	  if (process.env.NODE_ENV !== 'production') {
+	    circular = {};
+	  }
+	  waiting = flushing = false;
+	}
+
+	/**
+	 * Flush both queues and run the watchers.
+	 */
+	function flushSchedulerQueue () {
+	  flushing = true;
+	  var watcher, id;
+
+	  // Sort queue before flush.
+	  // This ensures that:
+	  // 1. Components are updated from parent to child. (because parent is always
+	  //    created before the child)
+	  // 2. A component's user watchers are run before its render watcher (because
+	  //    user watchers are created before the render watcher)
+	  // 3. If a component is destroyed during a parent component's watcher run,
+	  //    its watchers can be skipped.
+	  queue.sort(function (a, b) { return a.id - b.id; });
+
+	  // do not cache length because more watchers might be pushed
+	  // as we run existing watchers
+	  for (index = 0; index < queue.length; index++) {
+	    watcher = queue[index];
+	    id = watcher.id;
+	    has[id] = null;
+	    watcher.run();
+	    // in dev build, check and stop circular updates.
+	    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+	      circular[id] = (circular[id] || 0) + 1;
+	      if (circular[id] > MAX_UPDATE_COUNT) {
+	        warn(
+	          'You may have an infinite update loop ' + (
+	            watcher.user
+	              ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+	              : "in a component render function."
+	          ),
+	          watcher.vm
+	        );
+	        break
+	      }
+	    }
+	  }
+
+	  // keep copies of post queues before resetting state
+	  var activatedQueue = activatedChildren.slice();
+	  var updatedQueue = queue.slice();
+
+	  resetSchedulerState();
+
+	  // call component updated and activated hooks
+	  callActivatedHooks(activatedQueue);
+	  callUpdatedHooks(updatedQueue);
+
+	  // devtool hook
+	  /* istanbul ignore if */
+	  if (devtools && config.devtools) {
+	    devtools.emit('flush');
+	  }
+	}
+
+	function callUpdatedHooks (queue) {
+	  var i = queue.length;
+	  while (i--) {
+	    var watcher = queue[i];
+	    var vm = watcher.vm;
+	    if (vm._watcher === watcher && vm._isMounted) {
+	      callHook(vm, 'updated');
+	    }
+	  }
+	}
+
+	/**
+	 * Queue a kept-alive component that was activated during patch.
+	 * The queue will be processed after the entire tree has been patched.
+	 */
+	function queueActivatedComponent (vm) {
+	  // setting _inactive to false here so that a render function can
+	  // rely on checking whether it's in an inactive tree (e.g. router-view)
+	  vm._inactive = false;
+	  activatedChildren.push(vm);
+	}
+
+	function callActivatedHooks (queue) {
+	  for (var i = 0; i < queue.length; i++) {
+	    queue[i]._inactive = true;
+	    activateChildComponent(queue[i], true /* true */);
+	  }
+	}
+
+	/**
+	 * Push a watcher into the watcher queue.
+	 * Jobs with duplicate IDs will be skipped unless it's
+	 * pushed when the queue is being flushed.
+	 */
+	function queueWatcher (watcher) {
+	  var id = watcher.id;
+	  if (has[id] == null) {
+	    has[id] = true;
+	    if (!flushing) {
+	      queue.push(watcher);
+	    } else {
+	      // if already flushing, splice the watcher based on its id
+	      // if already past its id, it will be run next immediately.
+	      var i = queue.length - 1;
+	      while (i > index && queue[i].id > watcher.id) {
+	        i--;
+	      }
+	      queue.splice(i + 1, 0, watcher);
+	    }
+	    // queue the flush
+	    if (!waiting) {
+	      waiting = true;
+	      nextTick(flushSchedulerQueue);
+	    }
+	  }
+	}
+
+	/*  */
+
+	var uid$2 = 0;
+
+	/**
+	 * A watcher parses an expression, collects dependencies,
+	 * and fires callback when the expression value changes.
+	 * This is used for both the $watch() api and directives.
+	 */
+	var Watcher = function Watcher (
+	  vm,
+	  expOrFn,
+	  cb,
+	  options
+	) {
+	  this.vm = vm;
+	  vm._watchers.push(this);
+	  // options
+	  if (options) {
+	    this.deep = !!options.deep;
+	    this.user = !!options.user;
+	    this.lazy = !!options.lazy;
+	    this.sync = !!options.sync;
+	  } else {
+	    this.deep = this.user = this.lazy = this.sync = false;
+	  }
+	  this.cb = cb;
+	  this.id = ++uid$2; // uid for batching
+	  this.active = true;
+	  this.dirty = this.lazy; // for lazy watchers
+	  this.deps = [];
+	  this.newDeps = [];
+	  this.depIds = new _Set();
+	  this.newDepIds = new _Set();
+	  this.expression = process.env.NODE_ENV !== 'production'
+	    ? expOrFn.toString()
+	    : '';
+	  // parse expression for getter
+	  if (typeof expOrFn === 'function') {
+	    this.getter = expOrFn;
+	  } else {
+	    this.getter = parsePath(expOrFn);
+	    if (!this.getter) {
+	      this.getter = function () {};
+	      process.env.NODE_ENV !== 'production' && warn(
+	        "Failed watching path: \"" + expOrFn + "\" " +
+	        'Watcher only accepts simple dot-delimited paths. ' +
+	        'For full control, use a function instead.',
+	        vm
+	      );
+	    }
+	  }
+	  this.value = this.lazy
+	    ? undefined
+	    : this.get();
+	};
+
+	/**
+	 * Evaluate the getter, and re-collect dependencies.
+	 */
+	Watcher.prototype.get = function get () {
+	  pushTarget(this);
+	  var value;
+	  var vm = this.vm;
+	  try {
+	    value = this.getter.call(vm, vm);
+	  } catch (e) {
+	    if (this.user) {
+	      handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+	    } else {
+	      throw e
+	    }
+	  } finally {
+	    // "touch" every property so they are all tracked as
+	    // dependencies for deep watching
+	    if (this.deep) {
+	      traverse(value);
+	    }
+	    popTarget();
+	    this.cleanupDeps();
+	  }
+	  return value
+	};
+
+	/**
+	 * Add a dependency to this directive.
+	 */
+	Watcher.prototype.addDep = function addDep (dep) {
+	  var id = dep.id;
+	  if (!this.newDepIds.has(id)) {
+	    this.newDepIds.add(id);
+	    this.newDeps.push(dep);
+	    if (!this.depIds.has(id)) {
+	      dep.addSub(this);
+	    }
+	  }
+	};
+
+	/**
+	 * Clean up for dependency collection.
+	 */
+	Watcher.prototype.cleanupDeps = function cleanupDeps () {
+	    var this$1 = this;
+
+	  var i = this.deps.length;
+	  while (i--) {
+	    var dep = this$1.deps[i];
+	    if (!this$1.newDepIds.has(dep.id)) {
+	      dep.removeSub(this$1);
+	    }
+	  }
+	  var tmp = this.depIds;
+	  this.depIds = this.newDepIds;
+	  this.newDepIds = tmp;
+	  this.newDepIds.clear();
+	  tmp = this.deps;
+	  this.deps = this.newDeps;
+	  this.newDeps = tmp;
+	  this.newDeps.length = 0;
+	};
+
+	/**
+	 * Subscriber interface.
+	 * Will be called when a dependency changes.
+	 */
+	Watcher.prototype.update = function update () {
+	  /* istanbul ignore else */
+	  if (this.lazy) {
+	    this.dirty = true;
+	  } else if (this.sync) {
+	    this.run();
+	  } else {
+	    queueWatcher(this);
+	  }
+	};
+
+	/**
+	 * Scheduler job interface.
+	 * Will be called by the scheduler.
+	 */
+	Watcher.prototype.run = function run () {
+	  if (this.active) {
+	    var value = this.get();
+	    if (
+	      value !== this.value ||
+	      // Deep watchers and watchers on Object/Arrays should fire even
+	      // when the value is the same, because the value may
+	      // have mutated.
+	      isObject(value) ||
+	      this.deep
+	    ) {
+	      // set new value
+	      var oldValue = this.value;
+	      this.value = value;
+	      if (this.user) {
+	        try {
+	          this.cb.call(this.vm, value, oldValue);
+	        } catch (e) {
+	          handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+	        }
+	      } else {
+	        this.cb.call(this.vm, value, oldValue);
+	      }
+	    }
+	  }
+	};
+
+	/**
+	 * Evaluate the value of the watcher.
+	 * This only gets called for lazy watchers.
+	 */
+	Watcher.prototype.evaluate = function evaluate () {
+	  this.value = this.get();
+	  this.dirty = false;
+	};
+
+	/**
+	 * Depend on all deps collected by this watcher.
+	 */
+	Watcher.prototype.depend = function depend () {
+	    var this$1 = this;
+
+	  var i = this.deps.length;
+	  while (i--) {
+	    this$1.deps[i].depend();
+	  }
+	};
+
+	/**
+	 * Remove self from all dependencies' subscriber list.
+	 */
+	Watcher.prototype.teardown = function teardown () {
+	    var this$1 = this;
+
+	  if (this.active) {
+	    // remove self from vm's watcher list
+	    // this is a somewhat expensive operation so we skip it
+	    // if the vm is being destroyed.
+	    if (!this.vm._isBeingDestroyed) {
+	      remove(this.vm._watchers, this);
+	    }
+	    var i = this.deps.length;
+	    while (i--) {
+	      this$1.deps[i].removeSub(this$1);
+	    }
+	    this.active = false;
+	  }
+	};
+
+	/**
+	 * Recursively traverse an object to evoke all converted
+	 * getters, so that every nested property inside the object
+	 * is collected as a "deep" dependency.
+	 */
+	var seenObjects = new _Set();
+	function traverse (val) {
+	  seenObjects.clear();
+	  _traverse(val, seenObjects);
+	}
+
+	function _traverse (val, seen) {
+	  var i, keys;
+	  var isA = Array.isArray(val);
+	  if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {
+	    return
+	  }
+	  if (val.__ob__) {
+	    var depId = val.__ob__.dep.id;
+	    if (seen.has(depId)) {
+	      return
+	    }
+	    seen.add(depId);
+	  }
+	  if (isA) {
+	    i = val.length;
+	    while (i--) { _traverse(val[i], seen); }
+	  } else {
+	    keys = Object.keys(val);
+	    i = keys.length;
+	    while (i--) { _traverse(val[keys[i]], seen); }
+	  }
+	}
+
+	/*  */
+
+	var sharedPropertyDefinition = {
+	  enumerable: true,
+	  configurable: true,
+	  get: noop,
+	  set: noop
+	};
+
+	function proxy (target, sourceKey, key) {
+	  sharedPropertyDefinition.get = function proxyGetter () {
+	    return this[sourceKey][key]
+	  };
+	  sharedPropertyDefinition.set = function proxySetter (val) {
+	    this[sourceKey][key] = val;
+	  };
+	  Object.defineProperty(target, key, sharedPropertyDefinition);
+	}
+
+	function initState (vm) {
+	  vm._watchers = [];
+	  var opts = vm.$options;
+	  if (opts.props) { initProps(vm, opts.props); }
+	  if (opts.methods) { initMethods(vm, opts.methods); }
+	  if (opts.data) {
+	    initData(vm);
+	  } else {
+	    observe(vm._data = {}, true /* asRootData */);
+	  }
+	  if (opts.computed) { initComputed(vm, opts.computed); }
+	  if (opts.watch && opts.watch !== nativeWatch) {
+	    initWatch(vm, opts.watch);
+	  }
+	}
+
+	function checkOptionType (vm, name) {
+	  var option = vm.$options[name];
+	  if (!isPlainObject(option)) {
+	    warn(
+	      ("component option \"" + name + "\" should be an object."),
+	      vm
+	    );
+	  }
+	}
+
+	function initProps (vm, propsOptions) {
+	  var propsData = vm.$options.propsData || {};
+	  var props = vm._props = {};
+	  // cache prop keys so that future props updates can iterate using Array
+	  // instead of dynamic object key enumeration.
+	  var keys = vm.$options._propKeys = [];
+	  var isRoot = !vm.$parent;
+	  // root instance props should be converted
+	  observerState.shouldConvert = isRoot;
+	  var loop = function ( key ) {
+	    keys.push(key);
+	    var value = validateProp(key, propsOptions, propsData, vm);
+	    /* istanbul ignore else */
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (isReservedAttribute(key) || config.isReservedAttr(key)) {
+	        warn(
+	          ("\"" + key + "\" is a reserved attribute and cannot be used as component prop."),
+	          vm
+	        );
+	      }
+	      defineReactive$$1(props, key, value, function () {
+	        if (vm.$parent && !isUpdatingChildComponent) {
+	          warn(
+	            "Avoid mutating a prop directly since the value will be " +
+	            "overwritten whenever the parent component re-renders. " +
+	            "Instead, use a data or computed property based on the prop's " +
+	            "value. Prop being mutated: \"" + key + "\"",
+	            vm
+	          );
+	        }
+	      });
+	    } else {
+	      defineReactive$$1(props, key, value);
+	    }
+	    // static props are already proxied on the component's prototype
+	    // during Vue.extend(). We only need to proxy props defined at
+	    // instantiation here.
+	    if (!(key in vm)) {
+	      proxy(vm, "_props", key);
+	    }
+	  };
+
+	  for (var key in propsOptions) loop( key );
+	  observerState.shouldConvert = true;
+	}
+
+	function initData (vm) {
+	  var data = vm.$options.data;
+	  data = vm._data = typeof data === 'function'
+	    ? getData(data, vm)
+	    : data || {};
+	  if (!isPlainObject(data)) {
+	    data = {};
+	    process.env.NODE_ENV !== 'production' && warn(
+	      'data functions should return an object:\n' +
+	      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
+	      vm
+	    );
+	  }
+	  // proxy data on instance
+	  var keys = Object.keys(data);
+	  var props = vm.$options.props;
+	  var methods = vm.$options.methods;
+	  var i = keys.length;
+	  while (i--) {
+	    var key = keys[i];
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (methods && hasOwn(methods, key)) {
+	        warn(
+	          ("Method \"" + key + "\" has already been defined as a data property."),
+	          vm
+	        );
+	      }
+	    }
+	    if (props && hasOwn(props, key)) {
+	      process.env.NODE_ENV !== 'production' && warn(
+	        "The data property \"" + key + "\" is already declared as a prop. " +
+	        "Use prop default value instead.",
+	        vm
+	      );
+	    } else if (!isReserved(key)) {
+	      proxy(vm, "_data", key);
+	    }
+	  }
+	  // observe data
+	  observe(data, true /* asRootData */);
+	}
+
+	function getData (data, vm) {
+	  try {
+	    return data.call(vm)
+	  } catch (e) {
+	    handleError(e, vm, "data()");
+	    return {}
+	  }
+	}
+
+	var computedWatcherOptions = { lazy: true };
+
+	function initComputed (vm, computed) {
+	  process.env.NODE_ENV !== 'production' && checkOptionType(vm, 'computed');
+	  var watchers = vm._computedWatchers = Object.create(null);
+	  // computed properties are just getters during SSR
+	  var isSSR = isServerRendering();
+
+	  for (var key in computed) {
+	    var userDef = computed[key];
+	    var getter = typeof userDef === 'function' ? userDef : userDef.get;
+	    if (process.env.NODE_ENV !== 'production' && getter == null) {
+	      warn(
+	        ("Getter is missing for computed property \"" + key + "\"."),
+	        vm
+	      );
+	    }
+
+	    if (!isSSR) {
+	      // create internal watcher for the computed property.
+	      watchers[key] = new Watcher(
+	        vm,
+	        getter || noop,
+	        noop,
+	        computedWatcherOptions
+	      );
+	    }
+
+	    // component-defined computed properties are already defined on the
+	    // component prototype. We only need to define computed properties defined
+	    // at instantiation here.
+	    if (!(key in vm)) {
+	      defineComputed(vm, key, userDef);
+	    } else if (process.env.NODE_ENV !== 'production') {
+	      if (key in vm.$data) {
+	        warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+	      } else if (vm.$options.props && key in vm.$options.props) {
+	        warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+	      }
+	    }
+	  }
+	}
+
+	function defineComputed (
+	  target,
+	  key,
+	  userDef
+	) {
+	  var shouldCache = !isServerRendering();
+	  if (typeof userDef === 'function') {
+	    sharedPropertyDefinition.get = shouldCache
+	      ? createComputedGetter(key)
+	      : userDef;
+	    sharedPropertyDefinition.set = noop;
+	  } else {
+	    sharedPropertyDefinition.get = userDef.get
+	      ? shouldCache && userDef.cache !== false
+	        ? createComputedGetter(key)
+	        : userDef.get
+	      : noop;
+	    sharedPropertyDefinition.set = userDef.set
+	      ? userDef.set
+	      : noop;
+	  }
+	  if (process.env.NODE_ENV !== 'production' &&
+	      sharedPropertyDefinition.set === noop) {
+	    sharedPropertyDefinition.set = function () {
+	      warn(
+	        ("Computed property \"" + key + "\" was assigned to but it has no setter."),
+	        this
+	      );
+	    };
+	  }
+	  Object.defineProperty(target, key, sharedPropertyDefinition);
+	}
+
+	function createComputedGetter (key) {
+	  return function computedGetter () {
+	    var watcher = this._computedWatchers && this._computedWatchers[key];
+	    if (watcher) {
+	      if (watcher.dirty) {
+	        watcher.evaluate();
+	      }
+	      if (Dep.target) {
+	        watcher.depend();
+	      }
+	      return watcher.value
+	    }
+	  }
+	}
+
+	function initMethods (vm, methods) {
+	  process.env.NODE_ENV !== 'production' && checkOptionType(vm, 'methods');
+	  var props = vm.$options.props;
+	  for (var key in methods) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (methods[key] == null) {
+	        warn(
+	          "Method \"" + key + "\" has an undefined value in the component definition. " +
+	          "Did you reference the function correctly?",
+	          vm
+	        );
+	      }
+	      if (props && hasOwn(props, key)) {
+	        warn(
+	          ("Method \"" + key + "\" has already been defined as a prop."),
+	          vm
+	        );
+	      }
+	      if ((key in vm) && isReserved(key)) {
+	        warn(
+	          "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+	          "Avoid defining component methods that start with _ or $."
+	        );
+	      }
+	    }
+	    vm[key] = methods[key] == null ? noop : bind(methods[key], vm);
+	  }
+	}
+
+	function initWatch (vm, watch) {
+	  process.env.NODE_ENV !== 'production' && checkOptionType(vm, 'watch');
+	  for (var key in watch) {
+	    var handler = watch[key];
+	    if (Array.isArray(handler)) {
+	      for (var i = 0; i < handler.length; i++) {
+	        createWatcher(vm, key, handler[i]);
+	      }
+	    } else {
+	      createWatcher(vm, key, handler);
+	    }
+	  }
+	}
+
+	function createWatcher (
+	  vm,
+	  keyOrFn,
+	  handler,
+	  options
+	) {
+	  if (isPlainObject(handler)) {
+	    options = handler;
+	    handler = handler.handler;
+	  }
+	  if (typeof handler === 'string') {
+	    handler = vm[handler];
+	  }
+	  return vm.$watch(keyOrFn, handler, options)
+	}
+
+	function stateMixin (Vue) {
+	  // flow somehow has problems with directly declared definition object
+	  // when using Object.defineProperty, so we have to procedurally build up
+	  // the object here.
+	  var dataDef = {};
+	  dataDef.get = function () { return this._data };
+	  var propsDef = {};
+	  propsDef.get = function () { return this._props };
+	  if (process.env.NODE_ENV !== 'production') {
+	    dataDef.set = function (newData) {
+	      warn(
+	        'Avoid replacing instance root $data. ' +
+	        'Use nested data properties instead.',
+	        this
+	      );
+	    };
+	    propsDef.set = function () {
+	      warn("$props is readonly.", this);
+	    };
+	  }
+	  Object.defineProperty(Vue.prototype, '$data', dataDef);
+	  Object.defineProperty(Vue.prototype, '$props', propsDef);
+
+	  Vue.prototype.$set = set;
+	  Vue.prototype.$delete = del;
+
+	  Vue.prototype.$watch = function (
+	    expOrFn,
+	    cb,
+	    options
+	  ) {
+	    var vm = this;
+	    if (isPlainObject(cb)) {
+	      return createWatcher(vm, expOrFn, cb, options)
+	    }
+	    options = options || {};
+	    options.user = true;
+	    var watcher = new Watcher(vm, expOrFn, cb, options);
+	    if (options.immediate) {
+	      cb.call(vm, watcher.value);
+	    }
+	    return function unwatchFn () {
+	      watcher.teardown();
+	    }
+	  };
+	}
+
+	/*  */
+
+	function initProvide (vm) {
+	  var provide = vm.$options.provide;
+	  if (provide) {
+	    vm._provided = typeof provide === 'function'
+	      ? provide.call(vm)
+	      : provide;
+	  }
+	}
+
+	function initInjections (vm) {
+	  var result = resolveInject(vm.$options.inject, vm);
+	  if (result) {
+	    observerState.shouldConvert = false;
+	    Object.keys(result).forEach(function (key) {
+	      /* istanbul ignore else */
+	      if (process.env.NODE_ENV !== 'production') {
+	        defineReactive$$1(vm, key, result[key], function () {
+	          warn(
+	            "Avoid mutating an injected value directly since the changes will be " +
+	            "overwritten whenever the provided component re-renders. " +
+	            "injection being mutated: \"" + key + "\"",
+	            vm
+	          );
+	        });
+	      } else {
+	        defineReactive$$1(vm, key, result[key]);
+	      }
+	    });
+	    observerState.shouldConvert = true;
+	  }
+	}
+
+	function resolveInject (inject, vm) {
+	  if (inject) {
+	    // inject is :any because flow is not smart enough to figure out cached
+	    var result = Object.create(null);
+	    var keys = hasSymbol
+	        ? Reflect.ownKeys(inject).filter(function (key) {
+	          /* istanbul ignore next */
+	          return Object.getOwnPropertyDescriptor(inject, key).enumerable
+	        })
+	        : Object.keys(inject);
+
+	    for (var i = 0; i < keys.length; i++) {
+	      var key = keys[i];
+	      var provideKey = inject[key];
+	      var source = vm;
+	      while (source) {
+	        if (source._provided && provideKey in source._provided) {
+	          result[key] = source._provided[provideKey];
+	          break
+	        }
+	        source = source.$parent;
+	      }
+	      if (process.env.NODE_ENV !== 'production' && !source) {
+	        warn(("Injection \"" + key + "\" not found"), vm);
+	      }
+	    }
+	    return result
+	  }
+	}
+
+	/*  */
+
+	function createFunctionalComponent (
+	  Ctor,
+	  propsData,
+	  data,
+	  context,
+	  children
+	) {
+	  var props = {};
+	  var propOptions = Ctor.options.props;
+	  if (isDef(propOptions)) {
+	    for (var key in propOptions) {
+	      props[key] = validateProp(key, propOptions, propsData || emptyObject);
+	    }
+	  } else {
+	    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
+	    if (isDef(data.props)) { mergeProps(props, data.props); }
+	  }
+	  // ensure the createElement function in functional components
+	  // gets a unique context - this is necessary for correct named slot check
+	  var _context = Object.create(context);
+	  var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };
+	  var vnode = Ctor.options.render.call(null, h, {
+	    data: data,
+	    props: props,
+	    children: children,
+	    parent: context,
+	    listeners: data.on || emptyObject,
+	    injections: resolveInject(Ctor.options.inject, context),
+	    slots: function () { return resolveSlots(children, context); }
+	  });
+	  if (vnode instanceof VNode) {
+	    vnode.functionalContext = context;
+	    vnode.functionalOptions = Ctor.options;
+	    if (data.slot) {
+	      (vnode.data || (vnode.data = {})).slot = data.slot;
+	    }
+	  }
+	  return vnode
+	}
+
+	function mergeProps (to, from) {
+	  for (var key in from) {
+	    to[camelize(key)] = from[key];
+	  }
+	}
+
+	/*  */
+
+	// hooks to be invoked on component VNodes during patch
+	var componentVNodeHooks = {
+	  init: function init (
+	    vnode,
+	    hydrating,
+	    parentElm,
+	    refElm
+	  ) {
+	    if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {
+	      var child = vnode.componentInstance = createComponentInstanceForVnode(
+	        vnode,
+	        activeInstance,
+	        parentElm,
+	        refElm
+	      );
+	      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+	    } else if (vnode.data.keepAlive) {
+	      // kept-alive components, treat as a patch
+	      var mountedNode = vnode; // work around flow
+	      componentVNodeHooks.prepatch(mountedNode, mountedNode);
+	    }
+	  },
+
+	  prepatch: function prepatch (oldVnode, vnode) {
+	    var options = vnode.componentOptions;
+	    var child = vnode.componentInstance = oldVnode.componentInstance;
+	    updateChildComponent(
+	      child,
+	      options.propsData, // updated props
+	      options.listeners, // updated listeners
+	      vnode, // new parent vnode
+	      options.children // new children
+	    );
+	  },
+
+	  insert: function insert (vnode) {
+	    var context = vnode.context;
+	    var componentInstance = vnode.componentInstance;
+	    if (!componentInstance._isMounted) {
+	      componentInstance._isMounted = true;
+	      callHook(componentInstance, 'mounted');
+	    }
+	    if (vnode.data.keepAlive) {
+	      if (context._isMounted) {
+	        // vue-router#1212
+	        // During updates, a kept-alive component's child components may
+	        // change, so directly walking the tree here may call activated hooks
+	        // on incorrect children. Instead we push them into a queue which will
+	        // be processed after the whole patch process ended.
+	        queueActivatedComponent(componentInstance);
+	      } else {
+	        activateChildComponent(componentInstance, true /* direct */);
+	      }
+	    }
+	  },
+
+	  destroy: function destroy (vnode) {
+	    var componentInstance = vnode.componentInstance;
+	    if (!componentInstance._isDestroyed) {
+	      if (!vnode.data.keepAlive) {
+	        componentInstance.$destroy();
+	      } else {
+	        deactivateChildComponent(componentInstance, true /* direct */);
+	      }
+	    }
+	  }
+	};
+
+	var hooksToMerge = Object.keys(componentVNodeHooks);
+
+	function createComponent (
+	  Ctor,
+	  data,
+	  context,
+	  children,
+	  tag
+	) {
+	  if (isUndef(Ctor)) {
+	    return
+	  }
+
+	  var baseCtor = context.$options._base;
+
+	  // plain options object: turn it into a constructor
+	  if (isObject(Ctor)) {
+	    Ctor = baseCtor.extend(Ctor);
+	  }
+
+	  // if at this stage it's not a constructor or an async component factory,
+	  // reject.
+	  if (typeof Ctor !== 'function') {
+	    if (process.env.NODE_ENV !== 'production') {
+	      warn(("Invalid Component definition: " + (String(Ctor))), context);
+	    }
+	    return
+	  }
+
+	  // async component
+	  var asyncFactory;
+	  if (isUndef(Ctor.cid)) {
+	    asyncFactory = Ctor;
+	    Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context);
+	    if (Ctor === undefined) {
+	      // return a placeholder node for async component, which is rendered
+	      // as a comment node but preserves all the raw information for the node.
+	      // the information will be used for async server-rendering and hydration.
+	      return createAsyncPlaceholder(
+	        asyncFactory,
+	        data,
+	        context,
+	        children,
+	        tag
+	      )
+	    }
+	  }
+
+	  data = data || {};
+
+	  // resolve constructor options in case global mixins are applied after
+	  // component constructor creation
+	  resolveConstructorOptions(Ctor);
+
+	  // transform component v-model data into props & events
+	  if (isDef(data.model)) {
+	    transformModel(Ctor.options, data);
+	  }
+
+	  // extract props
+	  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+
+	  // functional component
+	  if (isTrue(Ctor.options.functional)) {
+	    return createFunctionalComponent(Ctor, propsData, data, context, children)
+	  }
+
+	  // extract listeners, since these needs to be treated as
+	  // child component listeners instead of DOM listeners
+	  var listeners = data.on;
+	  // replace with listeners with .native modifier
+	  // so it gets processed during parent component patch.
+	  data.on = data.nativeOn;
+
+	  if (isTrue(Ctor.options.abstract)) {
+	    // abstract components do not keep anything
+	    // other than props & listeners & slot
+
+	    // work around flow
+	    var slot = data.slot;
+	    data = {};
+	    if (slot) {
+	      data.slot = slot;
+	    }
+	  }
+
+	  // merge component management hooks onto the placeholder node
+	  mergeHooks(data);
+
+	  // return a placeholder vnode
+	  var name = Ctor.options.name || tag;
+	  var vnode = new VNode(
+	    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
+	    data, undefined, undefined, undefined, context,
+	    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
+	    asyncFactory
+	  );
+	  return vnode
+	}
+
+	function createComponentInstanceForVnode (
+	  vnode, // we know it's MountedComponentVNode but flow doesn't
+	  parent, // activeInstance in lifecycle state
+	  parentElm,
+	  refElm
+	) {
+	  var vnodeComponentOptions = vnode.componentOptions;
+	  var options = {
+	    _isComponent: true,
+	    parent: parent,
+	    propsData: vnodeComponentOptions.propsData,
+	    _componentTag: vnodeComponentOptions.tag,
+	    _parentVnode: vnode,
+	    _parentListeners: vnodeComponentOptions.listeners,
+	    _renderChildren: vnodeComponentOptions.children,
+	    _parentElm: parentElm || null,
+	    _refElm: refElm || null
+	  };
+	  // check inline-template render functions
+	  var inlineTemplate = vnode.data.inlineTemplate;
+	  if (isDef(inlineTemplate)) {
+	    options.render = inlineTemplate.render;
+	    options.staticRenderFns = inlineTemplate.staticRenderFns;
+	  }
+	  return new vnodeComponentOptions.Ctor(options)
+	}
+
+	function mergeHooks (data) {
+	  if (!data.hook) {
+	    data.hook = {};
+	  }
+	  for (var i = 0; i < hooksToMerge.length; i++) {
+	    var key = hooksToMerge[i];
+	    var fromParent = data.hook[key];
+	    var ours = componentVNodeHooks[key];
+	    data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;
+	  }
+	}
+
+	function mergeHook$1 (one, two) {
+	  return function (a, b, c, d) {
+	    one(a, b, c, d);
+	    two(a, b, c, d);
+	  }
+	}
+
+	// transform component v-model info (value and callback) into
+	// prop and event handler respectively.
+	function transformModel (options, data) {
+	  var prop = (options.model && options.model.prop) || 'value';
+	  var event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value;
+	  var on = data.on || (data.on = {});
+	  if (isDef(on[event])) {
+	    on[event] = [data.model.callback].concat(on[event]);
+	  } else {
+	    on[event] = data.model.callback;
+	  }
+	}
+
+	/*  */
+
+	var SIMPLE_NORMALIZE = 1;
+	var ALWAYS_NORMALIZE = 2;
+
+	// wrapper function for providing a more flexible interface
+	// without getting yelled at by flow
+	function createElement (
+	  context,
+	  tag,
+	  data,
+	  children,
+	  normalizationType,
+	  alwaysNormalize
+	) {
+	  if (Array.isArray(data) || isPrimitive(data)) {
+	    normalizationType = children;
+	    children = data;
+	    data = undefined;
+	  }
+	  if (isTrue(alwaysNormalize)) {
+	    normalizationType = ALWAYS_NORMALIZE;
+	  }
+	  return _createElement(context, tag, data, children, normalizationType)
+	}
+
+	function _createElement (
+	  context,
+	  tag,
+	  data,
+	  children,
+	  normalizationType
+	) {
+	  if (isDef(data) && isDef((data).__ob__)) {
+	    process.env.NODE_ENV !== 'production' && warn(
+	      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
+	      'Always create fresh vnode data objects in each render!',
+	      context
+	    );
+	    return createEmptyVNode()
+	  }
+	  // object syntax in v-bind
+	  if (isDef(data) && isDef(data.is)) {
+	    tag = data.is;
+	  }
+	  if (!tag) {
+	    // in case of component :is set to falsy value
+	    return createEmptyVNode()
+	  }
+	  // warn against non-primitive key
+	  if (process.env.NODE_ENV !== 'production' &&
+	    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
+	  ) {
+	    warn(
+	      'Avoid using non-primitive value as key, ' +
+	      'use string/number value instead.',
+	      context
+	    );
+	  }
+	  // support single function children as default scoped slot
+	  if (Array.isArray(children) &&
+	    typeof children[0] === 'function'
+	  ) {
+	    data = data || {};
+	    data.scopedSlots = { default: children[0] };
+	    children.length = 0;
+	  }
+	  if (normalizationType === ALWAYS_NORMALIZE) {
+	    children = normalizeChildren(children);
+	  } else if (normalizationType === SIMPLE_NORMALIZE) {
+	    children = simpleNormalizeChildren(children);
+	  }
+	  var vnode, ns;
+	  if (typeof tag === 'string') {
+	    var Ctor;
+	    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+	    if (config.isReservedTag(tag)) {
+	      // platform built-in elements
+	      vnode = new VNode(
+	        config.parsePlatformTagName(tag), data, children,
+	        undefined, undefined, context
+	      );
+	    } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
+	      // component
+	      vnode = createComponent(Ctor, data, context, children, tag);
+	    } else {
+	      // unknown or unlisted namespaced elements
+	      // check at runtime because it may get assigned a namespace when its
+	      // parent normalizes children
+	      vnode = new VNode(
+	        tag, data, children,
+	        undefined, undefined, context
+	      );
+	    }
+	  } else {
+	    // direct component options / constructor
+	    vnode = createComponent(tag, data, context, children);
+	  }
+	  if (isDef(vnode)) {
+	    if (ns) { applyNS(vnode, ns); }
+	    return vnode
+	  } else {
+	    return createEmptyVNode()
+	  }
+	}
+
+	function applyNS (vnode, ns) {
+	  vnode.ns = ns;
+	  if (vnode.tag === 'foreignObject') {
+	    // use default namespace inside foreignObject
+	    return
+	  }
+	  if (isDef(vnode.children)) {
+	    for (var i = 0, l = vnode.children.length; i < l; i++) {
+	      var child = vnode.children[i];
+	      if (isDef(child.tag) && isUndef(child.ns)) {
+	        applyNS(child, ns);
+	      }
+	    }
+	  }
+	}
+
+	/*  */
+
+	/**
+	 * Runtime helper for rendering v-for lists.
+	 */
+	function renderList (
+	  val,
+	  render
+	) {
+	  var ret, i, l, keys, key;
+	  if (Array.isArray(val) || typeof val === 'string') {
+	    ret = new Array(val.length);
+	    for (i = 0, l = val.length; i < l; i++) {
+	      ret[i] = render(val[i], i);
+	    }
+	  } else if (typeof val === 'number') {
+	    ret = new Array(val);
+	    for (i = 0; i < val; i++) {
+	      ret[i] = render(i + 1, i);
+	    }
+	  } else if (isObject(val)) {
+	    keys = Object.keys(val);
+	    ret = new Array(keys.length);
+	    for (i = 0, l = keys.length; i < l; i++) {
+	      key = keys[i];
+	      ret[i] = render(val[key], key, i);
+	    }
+	  }
+	  if (isDef(ret)) {
+	    (ret)._isVList = true;
+	  }
+	  return ret
+	}
+
+	/*  */
+
+	/**
+	 * Runtime helper for rendering <slot>
+	 */
+	function renderSlot (
+	  name,
+	  fallback,
+	  props,
+	  bindObject
+	) {
+	  var scopedSlotFn = this.$scopedSlots[name];
+	  if (scopedSlotFn) { // scoped slot
+	    props = props || {};
+	    if (bindObject) {
+	      props = extend(extend({}, bindObject), props);
+	    }
+	    return scopedSlotFn(props) || fallback
+	  } else {
+	    var slotNodes = this.$slots[name];
+	    // warn duplicate slot usage
+	    if (slotNodes && process.env.NODE_ENV !== 'production') {
+	      slotNodes._rendered && warn(
+	        "Duplicate presence of slot \"" + name + "\" found in the same render tree " +
+	        "- this will likely cause render errors.",
+	        this
+	      );
+	      slotNodes._rendered = true;
+	    }
+	    return slotNodes || fallback
+	  }
+	}
+
+	/*  */
+
+	/**
+	 * Runtime helper for resolving filters
+	 */
+	function resolveFilter (id) {
+	  return resolveAsset(this.$options, 'filters', id, true) || identity
+	}
+
+	/*  */
+
+	/**
+	 * Runtime helper for checking keyCodes from config.
+	 */
+	function checkKeyCodes (
+	  eventKeyCode,
+	  key,
+	  builtInAlias
+	) {
+	  var keyCodes = config.keyCodes[key] || builtInAlias;
+	  if (Array.isArray(keyCodes)) {
+	    return keyCodes.indexOf(eventKeyCode) === -1
+	  } else {
+	    return keyCodes !== eventKeyCode
+	  }
+	}
+
+	/*  */
+
+	/**
+	 * Runtime helper for merging v-bind="object" into a VNode's data.
+	 */
+	function bindObjectProps (
+	  data,
+	  tag,
+	  value,
+	  asProp,
+	  isSync
+	) {
+	  if (value) {
+	    if (!isObject(value)) {
+	      process.env.NODE_ENV !== 'production' && warn(
+	        'v-bind without argument expects an Object or Array value',
+	        this
+	      );
+	    } else {
+	      if (Array.isArray(value)) {
+	        value = toObject(value);
+	      }
+	      var hash;
+	      var loop = function ( key ) {
+	        if (
+	          key === 'class' ||
+	          key === 'style' ||
+	          isReservedAttribute(key)
+	        ) {
+	          hash = data;
+	        } else {
+	          var type = data.attrs && data.attrs.type;
+	          hash = asProp || config.mustUseProp(tag, type, key)
+	            ? data.domProps || (data.domProps = {})
+	            : data.attrs || (data.attrs = {});
+	        }
+	        if (!(key in hash)) {
+	          hash[key] = value[key];
+
+	          if (isSync) {
+	            var on = data.on || (data.on = {});
+	            on[("update:" + key)] = function ($event) {
+	              value[key] = $event;
+	            };
+	          }
+	        }
+	      };
+
+	      for (var key in value) loop( key );
+	    }
+	  }
+	  return data
+	}
+
+	/*  */
+
+	/**
+	 * Runtime helper for rendering static trees.
+	 */
+	function renderStatic (
+	  index,
+	  isInFor
+	) {
+	  var tree = this._staticTrees[index];
+	  // if has already-rendered static tree and not inside v-for,
+	  // we can reuse the same tree by doing a shallow clone.
+	  if (tree && !isInFor) {
+	    return Array.isArray(tree)
+	      ? cloneVNodes(tree)
+	      : cloneVNode(tree)
+	  }
+	  // otherwise, render a fresh tree.
+	  tree = this._staticTrees[index] =
+	    this.$options.staticRenderFns[index].call(this._renderProxy);
+	  markStatic(tree, ("__static__" + index), false);
+	  return tree
+	}
+
+	/**
+	 * Runtime helper for v-once.
+	 * Effectively it means marking the node as static with a unique key.
+	 */
+	function markOnce (
+	  tree,
+	  index,
+	  key
+	) {
+	  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+	  return tree
+	}
+
+	function markStatic (
+	  tree,
+	  key,
+	  isOnce
+	) {
+	  if (Array.isArray(tree)) {
+	    for (var i = 0; i < tree.length; i++) {
+	      if (tree[i] && typeof tree[i] !== 'string') {
+	        markStaticNode(tree[i], (key + "_" + i), isOnce);
+	      }
+	    }
+	  } else {
+	    markStaticNode(tree, key, isOnce);
+	  }
+	}
+
+	function markStaticNode (node, key, isOnce) {
+	  node.isStatic = true;
+	  node.key = key;
+	  node.isOnce = isOnce;
+	}
+
+	/*  */
+
+	function bindObjectListeners (data, value) {
+	  if (value) {
+	    if (!isPlainObject(value)) {
+	      process.env.NODE_ENV !== 'production' && warn(
+	        'v-on without argument expects an Object value',
+	        this
+	      );
+	    } else {
+	      var on = data.on = data.on ? extend({}, data.on) : {};
+	      for (var key in value) {
+	        var existing = on[key];
+	        var ours = value[key];
+	        on[key] = existing ? [].concat(ours, existing) : ours;
+	      }
+	    }
+	  }
+	  return data
+	}
+
+	/*  */
+
+	function initRender (vm) {
+	  vm._vnode = null; // the root of the child tree
+	  vm._staticTrees = null;
+	  var parentVnode = vm.$vnode = vm.$options._parentVnode; // the placeholder node in parent tree
+	  var renderContext = parentVnode && parentVnode.context;
+	  vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);
+	  vm.$scopedSlots = emptyObject;
+	  // bind the createElement fn to this instance
+	  // so that we get proper render context inside it.
+	  // args order: tag, data, children, normalizationType, alwaysNormalize
+	  // internal version is used by render functions compiled from templates
+	  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+	  // normalization is always applied for the public version, used in
+	  // user-written render functions.
+	  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+
+	  // $attrs & $listeners are exposed for easier HOC creation.
+	  // they need to be reactive so that HOCs using them are always updated
+	  var parentData = parentVnode && parentVnode.data;
+
+	  /* istanbul ignore else */
+	  if (process.env.NODE_ENV !== 'production') {
+	    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
+	      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+	    }, true);
+	    defineReactive$$1(vm, '$listeners', vm.$options._parentListeners || emptyObject, function () {
+	      !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+	    }, true);
+	  } else {
+	    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true);
+	    defineReactive$$1(vm, '$listeners', vm.$options._parentListeners || emptyObject, null, true);
+	  }
+	}
+
+	function renderMixin (Vue) {
+	  Vue.prototype.$nextTick = function (fn) {
+	    return nextTick(fn, this)
+	  };
+
+	  Vue.prototype._render = function () {
+	    var vm = this;
+	    var ref = vm.$options;
+	    var render = ref.render;
+	    var staticRenderFns = ref.staticRenderFns;
+	    var _parentVnode = ref._parentVnode;
+
+	    if (vm._isMounted) {
+	      // if the parent didn't update, the slot nodes will be the ones from
+	      // last render. They need to be cloned to ensure "freshness" for this render.
+	      for (var key in vm.$slots) {
+	        var slot = vm.$slots[key];
+	        if (slot._rendered) {
+	          vm.$slots[key] = cloneVNodes(slot, true /* deep */);
+	        }
+	      }
+	    }
+
+	    vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject;
+
+	    if (staticRenderFns && !vm._staticTrees) {
+	      vm._staticTrees = [];
+	    }
+	    // set parent vnode. this allows render functions to have access
+	    // to the data on the placeholder node.
+	    vm.$vnode = _parentVnode;
+	    // render self
+	    var vnode;
+	    try {
+	      vnode = render.call(vm._renderProxy, vm.$createElement);
+	    } catch (e) {
+	      handleError(e, vm, "render function");
+	      // return error render result,
+	      // or previous vnode to prevent render error causing blank component
+	      /* istanbul ignore else */
+	      if (process.env.NODE_ENV !== 'production') {
+	        vnode = vm.$options.renderError
+	          ? vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)
+	          : vm._vnode;
+	      } else {
+	        vnode = vm._vnode;
+	      }
+	    }
+	    // return empty vnode in case the render function errored out
+	    if (!(vnode instanceof VNode)) {
+	      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
+	        warn(
+	          'Multiple root nodes returned from render function. Render function ' +
+	          'should return a single root node.',
+	          vm
+	        );
+	      }
+	      vnode = createEmptyVNode();
+	    }
+	    // set parent
+	    vnode.parent = _parentVnode;
+	    return vnode
+	  };
+
+	  // internal render helpers.
+	  // these are exposed on the instance prototype to reduce generated render
+	  // code size.
+	  Vue.prototype._o = markOnce;
+	  Vue.prototype._n = toNumber;
+	  Vue.prototype._s = toString;
+	  Vue.prototype._l = renderList;
+	  Vue.prototype._t = renderSlot;
+	  Vue.prototype._q = looseEqual;
+	  Vue.prototype._i = looseIndexOf;
+	  Vue.prototype._m = renderStatic;
+	  Vue.prototype._f = resolveFilter;
+	  Vue.prototype._k = checkKeyCodes;
+	  Vue.prototype._b = bindObjectProps;
+	  Vue.prototype._v = createTextVNode;
+	  Vue.prototype._e = createEmptyVNode;
+	  Vue.prototype._u = resolveScopedSlots;
+	  Vue.prototype._g = bindObjectListeners;
+	}
+
+	/*  */
+
+	var uid = 0;
+
+	function initMixin (Vue) {
+	  Vue.prototype._init = function (options) {
+	    var vm = this;
+	    // a uid
+	    vm._uid = uid++;
+
+	    var startTag, endTag;
+	    /* istanbul ignore if */
+	    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+	      startTag = "vue-perf-init:" + (vm._uid);
+	      endTag = "vue-perf-end:" + (vm._uid);
+	      mark(startTag);
+	    }
+
+	    // a flag to avoid this being observed
+	    vm._isVue = true;
+	    // merge options
+	    if (options && options._isComponent) {
+	      // optimize internal component instantiation
+	      // since dynamic options merging is pretty slow, and none of the
+	      // internal component options needs special treatment.
+	      initInternalComponent(vm, options);
+	    } else {
+	      vm.$options = mergeOptions(
+	        resolveConstructorOptions(vm.constructor),
+	        options || {},
+	        vm
+	      );
+	    }
+	    /* istanbul ignore else */
+	    if (process.env.NODE_ENV !== 'production') {
+	      initProxy(vm);
+	    } else {
+	      vm._renderProxy = vm;
+	    }
+	    // expose real self
+	    vm._self = vm;
+	    initLifecycle(vm);
+	    initEvents(vm);
+	    initRender(vm);
+	    callHook(vm, 'beforeCreate');
+	    initInjections(vm); // resolve injections before data/props
+	    initState(vm);
+	    initProvide(vm); // resolve provide after data/props
+	    callHook(vm, 'created');
+
+	    /* istanbul ignore if */
+	    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+	      vm._name = formatComponentName(vm, false);
+	      mark(endTag);
+	      measure(((vm._name) + " init"), startTag, endTag);
+	    }
+
+	    if (vm.$options.el) {
+	      vm.$mount(vm.$options.el);
+	    }
+	  };
+	}
+
+	function initInternalComponent (vm, options) {
+	  var opts = vm.$options = Object.create(vm.constructor.options);
+	  // doing this because it's faster than dynamic enumeration.
+	  opts.parent = options.parent;
+	  opts.propsData = options.propsData;
+	  opts._parentVnode = options._parentVnode;
+	  opts._parentListeners = options._parentListeners;
+	  opts._renderChildren = options._renderChildren;
+	  opts._componentTag = options._componentTag;
+	  opts._parentElm = options._parentElm;
+	  opts._refElm = options._refElm;
+	  if (options.render) {
+	    opts.render = options.render;
+	    opts.staticRenderFns = options.staticRenderFns;
+	  }
+	}
+
+	function resolveConstructorOptions (Ctor) {
+	  var options = Ctor.options;
+	  if (Ctor.super) {
+	    var superOptions = resolveConstructorOptions(Ctor.super);
+	    var cachedSuperOptions = Ctor.superOptions;
+	    if (superOptions !== cachedSuperOptions) {
+	      // super option changed,
+	      // need to resolve new options.
+	      Ctor.superOptions = superOptions;
+	      // check if there are any late-modified/attached options (#4976)
+	      var modifiedOptions = resolveModifiedOptions(Ctor);
+	      // update base extend options
+	      if (modifiedOptions) {
+	        extend(Ctor.extendOptions, modifiedOptions);
+	      }
+	      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+	      if (options.name) {
+	        options.components[options.name] = Ctor;
+	      }
+	    }
+	  }
+	  return options
+	}
+
+	function resolveModifiedOptions (Ctor) {
+	  var modified;
+	  var latest = Ctor.options;
+	  var extended = Ctor.extendOptions;
+	  var sealed = Ctor.sealedOptions;
+	  for (var key in latest) {
+	    if (latest[key] !== sealed[key]) {
+	      if (!modified) { modified = {}; }
+	      modified[key] = dedupe(latest[key], extended[key], sealed[key]);
+	    }
+	  }
+	  return modified
+	}
+
+	function dedupe (latest, extended, sealed) {
+	  // compare latest and sealed to ensure lifecycle hooks won't be duplicated
+	  // between merges
+	  if (Array.isArray(latest)) {
+	    var res = [];
+	    sealed = Array.isArray(sealed) ? sealed : [sealed];
+	    extended = Array.isArray(extended) ? extended : [extended];
+	    for (var i = 0; i < latest.length; i++) {
+	      // push original options and not sealed options to exclude duplicated options
+	      if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {
+	        res.push(latest[i]);
+	      }
+	    }
+	    return res
+	  } else {
+	    return latest
+	  }
+	}
+
+	function Vue$3 (options) {
+	  if (process.env.NODE_ENV !== 'production' &&
+	    !(this instanceof Vue$3)
+	  ) {
+	    warn('Vue is a constructor and should be called with the `new` keyword');
+	  }
+	  this._init(options);
+	}
+
+	initMixin(Vue$3);
+	stateMixin(Vue$3);
+	eventsMixin(Vue$3);
+	lifecycleMixin(Vue$3);
+	renderMixin(Vue$3);
+
+	/*  */
+
+	function initUse (Vue) {
+	  Vue.use = function (plugin) {
+	    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
+	    if (installedPlugins.indexOf(plugin) > -1) {
+	      return this
+	    }
+
+	    // additional parameters
+	    var args = toArray(arguments, 1);
+	    args.unshift(this);
+	    if (typeof plugin.install === 'function') {
+	      plugin.install.apply(plugin, args);
+	    } else if (typeof plugin === 'function') {
+	      plugin.apply(null, args);
+	    }
+	    installedPlugins.push(plugin);
+	    return this
+	  };
+	}
+
+	/*  */
+
+	function initMixin$1 (Vue) {
+	  Vue.mixin = function (mixin) {
+	    this.options = mergeOptions(this.options, mixin);
+	    return this
+	  };
+	}
+
+	/*  */
+
+	function initExtend (Vue) {
+	  /**
+	   * Each instance constructor, including Vue, has a unique
+	   * cid. This enables us to create wrapped "child
+	   * constructors" for prototypal inheritance and cache them.
+	   */
+	  Vue.cid = 0;
+	  var cid = 1;
+
+	  /**
+	   * Class inheritance
+	   */
+	  Vue.extend = function (extendOptions) {
+	    extendOptions = extendOptions || {};
+	    var Super = this;
+	    var SuperId = Super.cid;
+	    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+	    if (cachedCtors[SuperId]) {
+	      return cachedCtors[SuperId]
+	    }
+
+	    var name = extendOptions.name || Super.options.name;
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (!/^[a-zA-Z][\w-]*$/.test(name)) {
+	        warn(
+	          'Invalid component name: "' + name + '". Component names ' +
+	          'can only contain alphanumeric characters and the hyphen, ' +
+	          'and must start with a letter.'
+	        );
+	      }
+	    }
+
+	    var Sub = function VueComponent (options) {
+	      this._init(options);
+	    };
+	    Sub.prototype = Object.create(Super.prototype);
+	    Sub.prototype.constructor = Sub;
+	    Sub.cid = cid++;
+	    Sub.options = mergeOptions(
+	      Super.options,
+	      extendOptions
+	    );
+	    Sub['super'] = Super;
+
+	    // For props and computed properties, we define the proxy getters on
+	    // the Vue instances at extension time, on the extended prototype. This
+	    // avoids Object.defineProperty calls for each instance created.
+	    if (Sub.options.props) {
+	      initProps$1(Sub);
+	    }
+	    if (Sub.options.computed) {
+	      initComputed$1(Sub);
+	    }
+
+	    // allow further extension/mixin/plugin usage
+	    Sub.extend = Super.extend;
+	    Sub.mixin = Super.mixin;
+	    Sub.use = Super.use;
+
+	    // create asset registers, so extended classes
+	    // can have their private assets too.
+	    ASSET_TYPES.forEach(function (type) {
+	      Sub[type] = Super[type];
+	    });
+	    // enable recursive self-lookup
+	    if (name) {
+	      Sub.options.components[name] = Sub;
+	    }
+
+	    // keep a reference to the super options at extension time.
+	    // later at instantiation we can check if Super's options have
+	    // been updated.
+	    Sub.superOptions = Super.options;
+	    Sub.extendOptions = extendOptions;
+	    Sub.sealedOptions = extend({}, Sub.options);
+
+	    // cache constructor
+	    cachedCtors[SuperId] = Sub;
+	    return Sub
+	  };
+	}
+
+	function initProps$1 (Comp) {
+	  var props = Comp.options.props;
+	  for (var key in props) {
+	    proxy(Comp.prototype, "_props", key);
+	  }
+	}
+
+	function initComputed$1 (Comp) {
+	  var computed = Comp.options.computed;
+	  for (var key in computed) {
+	    defineComputed(Comp.prototype, key, computed[key]);
+	  }
+	}
+
+	/*  */
+
+	function initAssetRegisters (Vue) {
+	  /**
+	   * Create asset registration methods.
+	   */
+	  ASSET_TYPES.forEach(function (type) {
+	    Vue[type] = function (
+	      id,
+	      definition
+	    ) {
+	      if (!definition) {
+	        return this.options[type + 's'][id]
+	      } else {
+	        /* istanbul ignore if */
+	        if (process.env.NODE_ENV !== 'production') {
+	          if (type === 'component' && config.isReservedTag(id)) {
+	            warn(
+	              'Do not use built-in or reserved HTML elements as component ' +
+	              'id: ' + id
+	            );
+	          }
+	        }
+	        if (type === 'component' && isPlainObject(definition)) {
+	          definition.name = definition.name || id;
+	          definition = this.options._base.extend(definition);
+	        }
+	        if (type === 'directive' && typeof definition === 'function') {
+	          definition = { bind: definition, update: definition };
+	        }
+	        this.options[type + 's'][id] = definition;
+	        return definition
+	      }
+	    };
+	  });
+	}
+
+	/*  */
+
+	var patternTypes = [String, RegExp, Array];
+
+	function getComponentName (opts) {
+	  return opts && (opts.Ctor.options.name || opts.tag)
+	}
+
+	function matches (pattern, name) {
+	  if (Array.isArray(pattern)) {
+	    return pattern.indexOf(name) > -1
+	  } else if (typeof pattern === 'string') {
+	    return pattern.split(',').indexOf(name) > -1
+	  } else if (isRegExp(pattern)) {
+	    return pattern.test(name)
+	  }
+	  /* istanbul ignore next */
+	  return false
+	}
+
+	function pruneCache (cache, current, filter) {
+	  for (var key in cache) {
+	    var cachedNode = cache[key];
+	    if (cachedNode) {
+	      var name = getComponentName(cachedNode.componentOptions);
+	      if (name && !filter(name)) {
+	        if (cachedNode !== current) {
+	          pruneCacheEntry(cachedNode);
+	        }
+	        cache[key] = null;
+	      }
+	    }
+	  }
+	}
+
+	function pruneCacheEntry (vnode) {
+	  if (vnode) {
+	    vnode.componentInstance.$destroy();
+	  }
+	}
+
+	var KeepAlive = {
+	  name: 'keep-alive',
+	  abstract: true,
+
+	  props: {
+	    include: patternTypes,
+	    exclude: patternTypes
+	  },
+
+	  created: function created () {
+	    this.cache = Object.create(null);
+	  },
+
+	  destroyed: function destroyed () {
+	    var this$1 = this;
+
+	    for (var key in this$1.cache) {
+	      pruneCacheEntry(this$1.cache[key]);
+	    }
+	  },
+
+	  watch: {
+	    include: function include (val) {
+	      pruneCache(this.cache, this._vnode, function (name) { return matches(val, name); });
+	    },
+	    exclude: function exclude (val) {
+	      pruneCache(this.cache, this._vnode, function (name) { return !matches(val, name); });
+	    }
+	  },
+
+	  render: function render () {
+	    var vnode = getFirstComponentChild(this.$slots.default);
+	    var componentOptions = vnode && vnode.componentOptions;
+	    if (componentOptions) {
+	      // check pattern
+	      var name = getComponentName(componentOptions);
+	      if (name && (
+	        (this.include && !matches(this.include, name)) ||
+	        (this.exclude && matches(this.exclude, name))
+	      )) {
+	        return vnode
+	      }
+	      var key = vnode.key == null
+	        // same constructor may get registered as different local components
+	        // so cid alone is not enough (#3269)
+	        ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+	        : vnode.key;
+	      if (this.cache[key]) {
+	        vnode.componentInstance = this.cache[key].componentInstance;
+	      } else {
+	        this.cache[key] = vnode;
+	      }
+	      vnode.data.keepAlive = true;
+	    }
+	    return vnode
+	  }
+	};
+
+	var builtInComponents = {
+	  KeepAlive: KeepAlive
+	};
+
+	/*  */
+
+	function initGlobalAPI (Vue) {
+	  // config
+	  var configDef = {};
+	  configDef.get = function () { return config; };
+	  if (process.env.NODE_ENV !== 'production') {
+	    configDef.set = function () {
+	      warn(
+	        'Do not replace the Vue.config object, set individual fields instead.'
+	      );
+	    };
+	  }
+	  Object.defineProperty(Vue, 'config', configDef);
+
+	  // exposed util methods.
+	  // NOTE: these are not considered part of the public API - avoid relying on
+	  // them unless you are aware of the risk.
+	  Vue.util = {
+	    warn: warn,
+	    extend: extend,
+	    mergeOptions: mergeOptions,
+	    defineReactive: defineReactive$$1
+	  };
+
+	  Vue.set = set;
+	  Vue.delete = del;
+	  Vue.nextTick = nextTick;
+
+	  Vue.options = Object.create(null);
+	  ASSET_TYPES.forEach(function (type) {
+	    Vue.options[type + 's'] = Object.create(null);
+	  });
+
+	  // this is used to identify the "base" constructor to extend all plain-object
+	  // components with in Weex's multi-instance scenarios.
+	  Vue.options._base = Vue;
+
+	  extend(Vue.options.components, builtInComponents);
+
+	  initUse(Vue);
+	  initMixin$1(Vue);
+	  initExtend(Vue);
+	  initAssetRegisters(Vue);
+	}
+
+	initGlobalAPI(Vue$3);
+
+	Object.defineProperty(Vue$3.prototype, '$isServer', {
+	  get: isServerRendering
+	});
+
+	Object.defineProperty(Vue$3.prototype, '$ssrContext', {
+	  get: function get () {
+	    /* istanbul ignore next */
+	    return this.$vnode && this.$vnode.ssrContext
+	  }
+	});
+
+	Vue$3.version = '2.4.4';
+
+	/*  */
+
+	// these are reserved for web because they are directly compiled away
+	// during template compilation
+	var isReservedAttr = makeMap('style,class');
+
+	// attributes that should be using props for binding
+	var acceptValue = makeMap('input,textarea,option,select,progress');
+	var mustUseProp = function (tag, type, attr) {
+	  return (
+	    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
+	    (attr === 'selected' && tag === 'option') ||
+	    (attr === 'checked' && tag === 'input') ||
+	    (attr === 'muted' && tag === 'video')
+	  )
+	};
+
+	var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+
+	var isBooleanAttr = makeMap(
+	  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+	  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+	  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+	  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+	  'required,reversed,scoped,seamless,selected,sortable,translate,' +
+	  'truespeed,typemustmatch,visible'
+	);
+
+	var xlinkNS = 'http://www.w3.org/1999/xlink';
+
+	var isXlink = function (name) {
+	  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+	};
+
+	var getXlinkProp = function (name) {
+	  return isXlink(name) ? name.slice(6, name.length) : ''
+	};
+
+	var isFalsyAttrValue = function (val) {
+	  return val == null || val === false
+	};
+
+	/*  */
+
+	function genClassForVnode (vnode) {
+	  var data = vnode.data;
+	  var parentNode = vnode;
+	  var childNode = vnode;
+	  while (isDef(childNode.componentInstance)) {
+	    childNode = childNode.componentInstance._vnode;
+	    if (childNode.data) {
+	      data = mergeClassData(childNode.data, data);
+	    }
+	  }
+	  while (isDef(parentNode = parentNode.parent)) {
+	    if (parentNode.data) {
+	      data = mergeClassData(data, parentNode.data);
+	    }
+	  }
+	  return renderClass(data.staticClass, data.class)
+	}
+
+	function mergeClassData (child, parent) {
+	  return {
+	    staticClass: concat(child.staticClass, parent.staticClass),
+	    class: isDef(child.class)
+	      ? [child.class, parent.class]
+	      : parent.class
+	  }
+	}
+
+	function renderClass (
+	  staticClass,
+	  dynamicClass
+	) {
+	  if (isDef(staticClass) || isDef(dynamicClass)) {
+	    return concat(staticClass, stringifyClass(dynamicClass))
+	  }
+	  /* istanbul ignore next */
+	  return ''
+	}
+
+	function concat (a, b) {
+	  return a ? b ? (a + ' ' + b) : a : (b || '')
+	}
+
+	function stringifyClass (value) {
+	  if (Array.isArray(value)) {
+	    return stringifyArray(value)
+	  }
+	  if (isObject(value)) {
+	    return stringifyObject(value)
+	  }
+	  if (typeof value === 'string') {
+	    return value
+	  }
+	  /* istanbul ignore next */
+	  return ''
+	}
+
+	function stringifyArray (value) {
+	  var res = '';
+	  var stringified;
+	  for (var i = 0, l = value.length; i < l; i++) {
+	    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
+	      if (res) { res += ' '; }
+	      res += stringified;
+	    }
+	  }
+	  return res
+	}
+
+	function stringifyObject (value) {
+	  var res = '';
+	  for (var key in value) {
+	    if (value[key]) {
+	      if (res) { res += ' '; }
+	      res += key;
+	    }
+	  }
+	  return res
+	}
+
+	/*  */
+
+	var namespaceMap = {
+	  svg: 'http://www.w3.org/2000/svg',
+	  math: 'http://www.w3.org/1998/Math/MathML'
+	};
+
+	var isHTMLTag = makeMap(
+	  'html,body,base,head,link,meta,style,title,' +
+	  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+	  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+	  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+	  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+	  'embed,object,param,source,canvas,script,noscript,del,ins,' +
+	  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+	  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+	  'output,progress,select,textarea,' +
+	  'details,dialog,menu,menuitem,summary,' +
+	  'content,element,shadow,template,blockquote,iframe,tfoot'
+	);
+
+	// this map is intentionally selective, only covering SVG elements that may
+	// contain child elements.
+	var isSVG = makeMap(
+	  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+	  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+	  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
+	  true
+	);
+
+
+
+	var isReservedTag = function (tag) {
+	  return isHTMLTag(tag) || isSVG(tag)
+	};
+
+	function getTagNamespace (tag) {
+	  if (isSVG(tag)) {
+	    return 'svg'
+	  }
+	  // basic support for MathML
+	  // note it doesn't support other MathML elements being component roots
+	  if (tag === 'math') {
+	    return 'math'
+	  }
+	}
+
+	var unknownElementCache = Object.create(null);
+	function isUnknownElement (tag) {
+	  /* istanbul ignore if */
+	  if (!inBrowser) {
+	    return true
+	  }
+	  if (isReservedTag(tag)) {
+	    return false
+	  }
+	  tag = tag.toLowerCase();
+	  /* istanbul ignore if */
+	  if (unknownElementCache[tag] != null) {
+	    return unknownElementCache[tag]
+	  }
+	  var el = document.createElement(tag);
+	  if (tag.indexOf('-') > -1) {
+	    // http://stackoverflow.com/a/28210364/1070244
+	    return (unknownElementCache[tag] = (
+	      el.constructor === window.HTMLUnknownElement ||
+	      el.constructor === window.HTMLElement
+	    ))
+	  } else {
+	    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
+	  }
+	}
+
+	var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+
+	/*  */
+
+	/**
+	 * Query an element selector if it's not an element already.
+	 */
+	function query (el) {
+	  if (typeof el === 'string') {
+	    var selected = document.querySelector(el);
+	    if (!selected) {
+	      process.env.NODE_ENV !== 'production' && warn(
+	        'Cannot find element: ' + el
+	      );
+	      return document.createElement('div')
+	    }
+	    return selected
+	  } else {
+	    return el
+	  }
+	}
+
+	/*  */
+
+	function createElement$1 (tagName, vnode) {
+	  var elm = document.createElement(tagName);
+	  if (tagName !== 'select') {
+	    return elm
+	  }
+	  // false or null will remove the attribute but undefined will not
+	  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
+	    elm.setAttribute('multiple', 'multiple');
+	  }
+	  return elm
+	}
+
+	function createElementNS (namespace, tagName) {
+	  return document.createElementNS(namespaceMap[namespace], tagName)
+	}
+
+	function createTextNode (text) {
+	  return document.createTextNode(text)
+	}
+
+	function createComment (text) {
+	  return document.createComment(text)
+	}
+
+	function insertBefore (parentNode, newNode, referenceNode) {
+	  parentNode.insertBefore(newNode, referenceNode);
+	}
+
+	function removeChild (node, child) {
+	  node.removeChild(child);
+	}
+
+	function appendChild (node, child) {
+	  node.appendChild(child);
+	}
+
+	function parentNode (node) {
+	  return node.parentNode
+	}
+
+	function nextSibling (node) {
+	  return node.nextSibling
+	}
+
+	function tagName (node) {
+	  return node.tagName
+	}
+
+	function setTextContent (node, text) {
+	  node.textContent = text;
+	}
+
+	function setAttribute (node, key, val) {
+	  node.setAttribute(key, val);
+	}
+
+
+	var nodeOps = Object.freeze({
+		createElement: createElement$1,
+		createElementNS: createElementNS,
+		createTextNode: createTextNode,
+		createComment: createComment,
+		insertBefore: insertBefore,
+		removeChild: removeChild,
+		appendChild: appendChild,
+		parentNode: parentNode,
+		nextSibling: nextSibling,
+		tagName: tagName,
+		setTextContent: setTextContent,
+		setAttribute: setAttribute
+	});
+
+	/*  */
+
+	var ref = {
+	  create: function create (_, vnode) {
+	    registerRef(vnode);
+	  },
+	  update: function update (oldVnode, vnode) {
+	    if (oldVnode.data.ref !== vnode.data.ref) {
+	      registerRef(oldVnode, true);
+	      registerRef(vnode);
+	    }
+	  },
+	  destroy: function destroy (vnode) {
+	    registerRef(vnode, true);
+	  }
+	};
+
+	function registerRef (vnode, isRemoval) {
+	  var key = vnode.data.ref;
+	  if (!key) { return }
+
+	  var vm = vnode.context;
+	  var ref = vnode.componentInstance || vnode.elm;
+	  var refs = vm.$refs;
+	  if (isRemoval) {
+	    if (Array.isArray(refs[key])) {
+	      remove(refs[key], ref);
+	    } else if (refs[key] === ref) {
+	      refs[key] = undefined;
+	    }
+	  } else {
+	    if (vnode.data.refInFor) {
+	      if (!Array.isArray(refs[key])) {
+	        refs[key] = [ref];
+	      } else if (refs[key].indexOf(ref) < 0) {
+	        // $flow-disable-line
+	        refs[key].push(ref);
+	      }
+	    } else {
+	      refs[key] = ref;
+	    }
+	  }
+	}
+
+	/**
+	 * Virtual DOM patching algorithm based on Snabbdom by
+	 * Simon Friis Vindum (@paldepind)
+	 * Licensed under the MIT License
+	 * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+	 *
+	 * modified by Evan You (@yyx990803)
+	 *
+	 * Not type-checking this because this file is perf-critical and the cost
+	 * of making flow understand it is not worth it.
+	 */
+
+	var emptyNode = new VNode('', {}, []);
+
+	var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+
+	function sameVnode (a, b) {
+	  return (
+	    a.key === b.key && (
+	      (
+	        a.tag === b.tag &&
+	        a.isComment === b.isComment &&
+	        isDef(a.data) === isDef(b.data) &&
+	        sameInputType(a, b)
+	      ) || (
+	        isTrue(a.isAsyncPlaceholder) &&
+	        a.asyncFactory === b.asyncFactory &&
+	        isUndef(b.asyncFactory.error)
+	      )
+	    )
+	  )
+	}
+
+	function sameInputType (a, b) {
+	  if (a.tag !== 'input') { return true }
+	  var i;
+	  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
+	  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
+	  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
+	}
+
+	function createKeyToOldIdx (children, beginIdx, endIdx) {
+	  var i, key;
+	  var map = {};
+	  for (i = beginIdx; i <= endIdx; ++i) {
+	    key = children[i].key;
+	    if (isDef(key)) { map[key] = i; }
+	  }
+	  return map
+	}
+
+	function createPatchFunction (backend) {
+	  var i, j;
+	  var cbs = {};
+
+	  var modules = backend.modules;
+	  var nodeOps = backend.nodeOps;
+
+	  for (i = 0; i < hooks.length; ++i) {
+	    cbs[hooks[i]] = [];
+	    for (j = 0; j < modules.length; ++j) {
+	      if (isDef(modules[j][hooks[i]])) {
+	        cbs[hooks[i]].push(modules[j][hooks[i]]);
+	      }
+	    }
+	  }
+
+	  function emptyNodeAt (elm) {
+	    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
+	  }
+
+	  function createRmCb (childElm, listeners) {
+	    function remove$$1 () {
+	      if (--remove$$1.listeners === 0) {
+	        removeNode(childElm);
+	      }
+	    }
+	    remove$$1.listeners = listeners;
+	    return remove$$1
+	  }
+
+	  function removeNode (el) {
+	    var parent = nodeOps.parentNode(el);
+	    // element may have already been removed due to v-html / v-text
+	    if (isDef(parent)) {
+	      nodeOps.removeChild(parent, el);
+	    }
+	  }
+
+	  var inPre = 0;
+	  function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {
+	    vnode.isRootInsert = !nested; // for transition enter check
+	    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+	      return
+	    }
+
+	    var data = vnode.data;
+	    var children = vnode.children;
+	    var tag = vnode.tag;
+	    if (isDef(tag)) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        if (data && data.pre) {
+	          inPre++;
+	        }
+	        if (
+	          !inPre &&
+	          !vnode.ns &&
+	          !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&
+	          config.isUnknownElement(tag)
+	        ) {
+	          warn(
+	            'Unknown custom element: <' + tag + '> - did you ' +
+	            'register the component correctly? For recursive components, ' +
+	            'make sure to provide the "name" option.',
+	            vnode.context
+	          );
+	        }
+	      }
+	      vnode.elm = vnode.ns
+	        ? nodeOps.createElementNS(vnode.ns, tag)
+	        : nodeOps.createElement(tag, vnode);
+	      setScope(vnode);
+
+	      /* istanbul ignore if */
+	      {
+	        createChildren(vnode, children, insertedVnodeQueue);
+	        if (isDef(data)) {
+	          invokeCreateHooks(vnode, insertedVnodeQueue);
+	        }
+	        insert(parentElm, vnode.elm, refElm);
+	      }
+
+	      if (process.env.NODE_ENV !== 'production' && data && data.pre) {
+	        inPre--;
+	      }
+	    } else if (isTrue(vnode.isComment)) {
+	      vnode.elm = nodeOps.createComment(vnode.text);
+	      insert(parentElm, vnode.elm, refElm);
+	    } else {
+	      vnode.elm = nodeOps.createTextNode(vnode.text);
+	      insert(parentElm, vnode.elm, refElm);
+	    }
+	  }
+
+	  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
+	    var i = vnode.data;
+	    if (isDef(i)) {
+	      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+	      if (isDef(i = i.hook) && isDef(i = i.init)) {
+	        i(vnode, false /* hydrating */, parentElm, refElm);
+	      }
+	      // after calling the init hook, if the vnode is a child component
+	      // it should've created a child instance and mounted it. the child
+	      // component also has set the placeholder vnode's elm.
+	      // in that case we can just return the element and be done.
+	      if (isDef(vnode.componentInstance)) {
+	        initComponent(vnode, insertedVnodeQueue);
+	        if (isTrue(isReactivated)) {
+	          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+	        }
+	        return true
+	      }
+	    }
+	  }
+
+	  function initComponent (vnode, insertedVnodeQueue) {
+	    if (isDef(vnode.data.pendingInsert)) {
+	      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+	      vnode.data.pendingInsert = null;
+	    }
+	    vnode.elm = vnode.componentInstance.$el;
+	    if (isPatchable(vnode)) {
+	      invokeCreateHooks(vnode, insertedVnodeQueue);
+	      setScope(vnode);
+	    } else {
+	      // empty component root.
+	      // skip all element-related modules except for ref (#3455)
+	      registerRef(vnode);
+	      // make sure to invoke the insert hook
+	      insertedVnodeQueue.push(vnode);
+	    }
+	  }
+
+	  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
+	    var i;
+	    // hack for #4339: a reactivated component with inner transition
+	    // does not trigger because the inner node's created hooks are not called
+	    // again. It's not ideal to involve module-specific logic in here but
+	    // there doesn't seem to be a better way to do it.
+	    var innerNode = vnode;
+	    while (innerNode.componentInstance) {
+	      innerNode = innerNode.componentInstance._vnode;
+	      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
+	        for (i = 0; i < cbs.activate.length; ++i) {
+	          cbs.activate[i](emptyNode, innerNode);
+	        }
+	        insertedVnodeQueue.push(innerNode);
+	        break
+	      }
+	    }
+	    // unlike a newly created component,
+	    // a reactivated keep-alive component doesn't insert itself
+	    insert(parentElm, vnode.elm, refElm);
+	  }
+
+	  function insert (parent, elm, ref$$1) {
+	    if (isDef(parent)) {
+	      if (isDef(ref$$1)) {
+	        if (ref$$1.parentNode === parent) {
+	          nodeOps.insertBefore(parent, elm, ref$$1);
+	        }
+	      } else {
+	        nodeOps.appendChild(parent, elm);
+	      }
+	    }
+	  }
+
+	  function createChildren (vnode, children, insertedVnodeQueue) {
+	    if (Array.isArray(children)) {
+	      for (var i = 0; i < children.length; ++i) {
+	        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);
+	      }
+	    } else if (isPrimitive(vnode.text)) {
+	      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));
+	    }
+	  }
+
+	  function isPatchable (vnode) {
+	    while (vnode.componentInstance) {
+	      vnode = vnode.componentInstance._vnode;
+	    }
+	    return isDef(vnode.tag)
+	  }
+
+	  function invokeCreateHooks (vnode, insertedVnodeQueue) {
+	    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+	      cbs.create[i$1](emptyNode, vnode);
+	    }
+	    i = vnode.data.hook; // Reuse variable
+	    if (isDef(i)) {
+	      if (isDef(i.create)) { i.create(emptyNode, vnode); }
+	      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
+	    }
+	  }
+
+	  // set scope id attribute for scoped CSS.
+	  // this is implemented as a special case to avoid the overhead
+	  // of going through the normal attribute patching process.
+	  function setScope (vnode) {
+	    var i;
+	    var ancestor = vnode;
+	    while (ancestor) {
+	      if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
+	        nodeOps.setAttribute(vnode.elm, i, '');
+	      }
+	      ancestor = ancestor.parent;
+	    }
+	    // for slot content they should also get the scopeId from the host instance.
+	    if (isDef(i = activeInstance) &&
+	      i !== vnode.context &&
+	      isDef(i = i.$options._scopeId)
+	    ) {
+	      nodeOps.setAttribute(vnode.elm, i, '');
+	    }
+	  }
+
+	  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+	    for (; startIdx <= endIdx; ++startIdx) {
+	      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);
+	    }
+	  }
+
+	  function invokeDestroyHook (vnode) {
+	    var i, j;
+	    var data = vnode.data;
+	    if (isDef(data)) {
+	      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
+	      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
+	    }
+	    if (isDef(i = vnode.children)) {
+	      for (j = 0; j < vnode.children.length; ++j) {
+	        invokeDestroyHook(vnode.children[j]);
+	      }
+	    }
+	  }
+
+	  function removeVnodes (parentElm, vnodes, startIdx, endIdx) {
+	    for (; startIdx <= endIdx; ++startIdx) {
+	      var ch = vnodes[startIdx];
+	      if (isDef(ch)) {
+	        if (isDef(ch.tag)) {
+	          removeAndInvokeRemoveHook(ch);
+	          invokeDestroyHook(ch);
+	        } else { // Text node
+	          removeNode(ch.elm);
+	        }
+	      }
+	    }
+	  }
+
+	  function removeAndInvokeRemoveHook (vnode, rm) {
+	    if (isDef(rm) || isDef(vnode.data)) {
+	      var i;
+	      var listeners = cbs.remove.length + 1;
+	      if (isDef(rm)) {
+	        // we have a recursively passed down rm callback
+	        // increase the listeners count
+	        rm.listeners += listeners;
+	      } else {
+	        // directly removing
+	        rm = createRmCb(vnode.elm, listeners);
+	      }
+	      // recursively invoke hooks on child component root node
+	      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
+	        removeAndInvokeRemoveHook(i, rm);
+	      }
+	      for (i = 0; i < cbs.remove.length; ++i) {
+	        cbs.remove[i](vnode, rm);
+	      }
+	      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
+	        i(vnode, rm);
+	      } else {
+	        rm();
+	      }
+	    } else {
+	      removeNode(vnode.elm);
+	    }
+	  }
+
+	  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+	    var oldStartIdx = 0;
+	    var newStartIdx = 0;
+	    var oldEndIdx = oldCh.length - 1;
+	    var oldStartVnode = oldCh[0];
+	    var oldEndVnode = oldCh[oldEndIdx];
+	    var newEndIdx = newCh.length - 1;
+	    var newStartVnode = newCh[0];
+	    var newEndVnode = newCh[newEndIdx];
+	    var oldKeyToIdx, idxInOld, elmToMove, refElm;
+
+	    // removeOnly is a special flag used only by <transition-group>
+	    // to ensure removed elements stay in correct relative positions
+	    // during leaving transitions
+	    var canMove = !removeOnly;
+
+	    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+	      if (isUndef(oldStartVnode)) {
+	        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+	      } else if (isUndef(oldEndVnode)) {
+	        oldEndVnode = oldCh[--oldEndIdx];
+	      } else if (sameVnode(oldStartVnode, newStartVnode)) {
+	        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
+	        oldStartVnode = oldCh[++oldStartIdx];
+	        newStartVnode = newCh[++newStartIdx];
+	      } else if (sameVnode(oldEndVnode, newEndVnode)) {
+	        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
+	        oldEndVnode = oldCh[--oldEndIdx];
+	        newEndVnode = newCh[--newEndIdx];
+	      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
+	        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
+	        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+	        oldStartVnode = oldCh[++oldStartIdx];
+	        newEndVnode = newCh[--newEndIdx];
+	      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
+	        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
+	        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+	        oldEndVnode = oldCh[--oldEndIdx];
+	        newStartVnode = newCh[++newStartIdx];
+	      } else {
+	        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+	        idxInOld = isDef(newStartVnode.key)
+	          ? oldKeyToIdx[newStartVnode.key]
+	          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+	        if (isUndef(idxInOld)) { // New element
+	          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
+	        } else {
+	          elmToMove = oldCh[idxInOld];
+	          /* istanbul ignore if */
+	          if (process.env.NODE_ENV !== 'production' && !elmToMove) {
+	            warn(
+	              'It seems there are duplicate keys that is causing an update error. ' +
+	              'Make sure each v-for item has a unique key.'
+	            );
+	          }
+	          if (sameVnode(elmToMove, newStartVnode)) {
+	            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
+	            oldCh[idxInOld] = undefined;
+	            canMove && nodeOps.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
+	          } else {
+	            // same key but different element. treat as new element
+	            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
+	          }
+	        }
+	        newStartVnode = newCh[++newStartIdx];
+	      }
+	    }
+	    if (oldStartIdx > oldEndIdx) {
+	      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+	      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+	    } else if (newStartIdx > newEndIdx) {
+	      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
+	    }
+	  }
+
+	  function findIdxInOld (node, oldCh, start, end) {
+	    for (var i = start; i < end; i++) {
+	      var c = oldCh[i];
+	      if (isDef(c) && sameVnode(node, c)) { return i }
+	    }
+	  }
+
+	  function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {
+	    if (oldVnode === vnode) {
+	      return
+	    }
+
+	    var elm = vnode.elm = oldVnode.elm;
+
+	    if (isTrue(oldVnode.isAsyncPlaceholder)) {
+	      if (isDef(vnode.asyncFactory.resolved)) {
+	        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+	      } else {
+	        vnode.isAsyncPlaceholder = true;
+	      }
+	      return
+	    }
+
+	    // reuse element for static trees.
+	    // note we only do this if the vnode is cloned -
+	    // if the new node is not cloned it means the render functions have been
+	    // reset by the hot-reload-api and we need to do a proper re-render.
+	    if (isTrue(vnode.isStatic) &&
+	      isTrue(oldVnode.isStatic) &&
+	      vnode.key === oldVnode.key &&
+	      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
+	    ) {
+	      vnode.componentInstance = oldVnode.componentInstance;
+	      return
+	    }
+
+	    var i;
+	    var data = vnode.data;
+	    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
+	      i(oldVnode, vnode);
+	    }
+
+	    var oldCh = oldVnode.children;
+	    var ch = vnode.children;
+	    if (isDef(data) && isPatchable(vnode)) {
+	      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
+	      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
+	    }
+	    if (isUndef(vnode.text)) {
+	      if (isDef(oldCh) && isDef(ch)) {
+	        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+	      } else if (isDef(ch)) {
+	        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
+	        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+	      } else if (isDef(oldCh)) {
+	        removeVnodes(elm, oldCh, 0, oldCh.length - 1);
+	      } else if (isDef(oldVnode.text)) {
+	        nodeOps.setTextContent(elm, '');
+	      }
+	    } else if (oldVnode.text !== vnode.text) {
+	      nodeOps.setTextContent(elm, vnode.text);
+	    }
+	    if (isDef(data)) {
+	      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
+	    }
+	  }
+
+	  function invokeInsertHook (vnode, queue, initial) {
+	    // delay insert hooks for component root nodes, invoke them after the
+	    // element is really inserted
+	    if (isTrue(initial) && isDef(vnode.parent)) {
+	      vnode.parent.data.pendingInsert = queue;
+	    } else {
+	      for (var i = 0; i < queue.length; ++i) {
+	        queue[i].data.hook.insert(queue[i]);
+	      }
+	    }
+	  }
+
+	  var bailed = false;
+	  // list of modules that can skip create hook during hydration because they
+	  // are already rendered on the client or has no need for initialization
+	  var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');
+
+	  // Note: this is a browser-only function so we can assume elms are DOM nodes.
+	  function hydrate (elm, vnode, insertedVnodeQueue) {
+	    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+	      vnode.elm = elm;
+	      vnode.isAsyncPlaceholder = true;
+	      return true
+	    }
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (!assertNodeMatch(elm, vnode)) {
+	        return false
+	      }
+	    }
+	    vnode.elm = elm;
+	    var tag = vnode.tag;
+	    var data = vnode.data;
+	    var children = vnode.children;
+	    if (isDef(data)) {
+	      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
+	      if (isDef(i = vnode.componentInstance)) {
+	        // child component. it should have hydrated its own tree.
+	        initComponent(vnode, insertedVnodeQueue);
+	        return true
+	      }
+	    }
+	    if (isDef(tag)) {
+	      if (isDef(children)) {
+	        // empty element, allow client to pick up and populate children
+	        if (!elm.hasChildNodes()) {
+	          createChildren(vnode, children, insertedVnodeQueue);
+	        } else {
+	          // v-html and domProps: innerHTML
+	          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
+	            if (i !== elm.innerHTML) {
+	              /* istanbul ignore if */
+	              if (process.env.NODE_ENV !== 'production' &&
+	                typeof console !== 'undefined' &&
+	                !bailed
+	              ) {
+	                bailed = true;
+	                console.warn('Parent: ', elm);
+	                console.warn('server innerHTML: ', i);
+	                console.warn('client innerHTML: ', elm.innerHTML);
+	              }
+	              return false
+	            }
+	          } else {
+	            // iterate and compare children lists
+	            var childrenMatch = true;
+	            var childNode = elm.firstChild;
+	            for (var i$1 = 0; i$1 < children.length; i$1++) {
+	              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {
+	                childrenMatch = false;
+	                break
+	              }
+	              childNode = childNode.nextSibling;
+	            }
+	            // if childNode is not null, it means the actual childNodes list is
+	            // longer than the virtual children list.
+	            if (!childrenMatch || childNode) {
+	              /* istanbul ignore if */
+	              if (process.env.NODE_ENV !== 'production' &&
+	                typeof console !== 'undefined' &&
+	                !bailed
+	              ) {
+	                bailed = true;
+	                console.warn('Parent: ', elm);
+	                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+	              }
+	              return false
+	            }
+	          }
+	        }
+	      }
+	      if (isDef(data)) {
+	        for (var key in data) {
+	          if (!isRenderedModule(key)) {
+	            invokeCreateHooks(vnode, insertedVnodeQueue);
+	            break
+	          }
+	        }
+	      }
+	    } else if (elm.data !== vnode.text) {
+	      elm.data = vnode.text;
+	    }
+	    return true
+	  }
+
+	  function assertNodeMatch (node, vnode) {
+	    if (isDef(vnode.tag)) {
+	      return (
+	        vnode.tag.indexOf('vue-component') === 0 ||
+	        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
+	      )
+	    } else {
+	      return node.nodeType === (vnode.isComment ? 8 : 3)
+	    }
+	  }
+
+	  return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
+	    if (isUndef(vnode)) {
+	      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
+	      return
+	    }
+
+	    var isInitialPatch = false;
+	    var insertedVnodeQueue = [];
+
+	    if (isUndef(oldVnode)) {
+	      // empty mount (likely as component), create new root element
+	      isInitialPatch = true;
+	      createElm(vnode, insertedVnodeQueue, parentElm, refElm);
+	    } else {
+	      var isRealElement = isDef(oldVnode.nodeType);
+	      if (!isRealElement && sameVnode(oldVnode, vnode)) {
+	        // patch existing root node
+	        patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);
+	      } else {
+	        if (isRealElement) {
+	          // mounting to a real element
+	          // check if this is server-rendered content and if we can perform
+	          // a successful hydration.
+	          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+	            oldVnode.removeAttribute(SSR_ATTR);
+	            hydrating = true;
+	          }
+	          if (isTrue(hydrating)) {
+	            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+	              invokeInsertHook(vnode, insertedVnodeQueue, true);
+	              return oldVnode
+	            } else if (process.env.NODE_ENV !== 'production') {
+	              warn(
+	                'The client-side rendered virtual DOM tree is not matching ' +
+	                'server-rendered content. This is likely caused by incorrect ' +
+	                'HTML markup, for example nesting block-level elements inside ' +
+	                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+	                'full client-side render.'
+	              );
+	            }
+	          }
+	          // either not server-rendered, or hydration failed.
+	          // create an empty node and replace it
+	          oldVnode = emptyNodeAt(oldVnode);
+	        }
+	        // replacing existing element
+	        var oldElm = oldVnode.elm;
+	        var parentElm$1 = nodeOps.parentNode(oldElm);
+	        createElm(
+	          vnode,
+	          insertedVnodeQueue,
+	          // extremely rare edge case: do not insert if old element is in a
+	          // leaving transition. Only happens when combining transition +
+	          // keep-alive + HOCs. (#4590)
+	          oldElm._leaveCb ? null : parentElm$1,
+	          nodeOps.nextSibling(oldElm)
+	        );
+
+	        if (isDef(vnode.parent)) {
+	          // component root element replaced.
+	          // update parent placeholder node element, recursively
+	          var ancestor = vnode.parent;
+	          var patchable = isPatchable(vnode);
+	          while (ancestor) {
+	            for (var i = 0; i < cbs.destroy.length; ++i) {
+	              cbs.destroy[i](ancestor);
+	            }
+	            ancestor.elm = vnode.elm;
+	            if (patchable) {
+	              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+	                cbs.create[i$1](emptyNode, ancestor);
+	              }
+	              // #6513
+	              // invoke insert hooks that may have been merged by create hooks.
+	              // e.g. for directives that uses the "inserted" hook.
+	              var insert = ancestor.data.hook.insert;
+	              if (insert.merged) {
+	                // start at index 1 to avoid re-invoking component mounted hook
+	                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+	                  insert.fns[i$2]();
+	                }
+	              }
+	            }
+	            ancestor = ancestor.parent;
+	          }
+	        }
+
+	        if (isDef(parentElm$1)) {
+	          removeVnodes(parentElm$1, [oldVnode], 0, 0);
+	        } else if (isDef(oldVnode.tag)) {
+	          invokeDestroyHook(oldVnode);
+	        }
+	      }
+	    }
+
+	    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+	    return vnode.elm
+	  }
+	}
+
+	/*  */
+
+	var directives = {
+	  create: updateDirectives,
+	  update: updateDirectives,
+	  destroy: function unbindDirectives (vnode) {
+	    updateDirectives(vnode, emptyNode);
+	  }
+	};
+
+	function updateDirectives (oldVnode, vnode) {
+	  if (oldVnode.data.directives || vnode.data.directives) {
+	    _update(oldVnode, vnode);
+	  }
+	}
+
+	function _update (oldVnode, vnode) {
+	  var isCreate = oldVnode === emptyNode;
+	  var isDestroy = vnode === emptyNode;
+	  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+	  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+
+	  var dirsWithInsert = [];
+	  var dirsWithPostpatch = [];
+
+	  var key, oldDir, dir;
+	  for (key in newDirs) {
+	    oldDir = oldDirs[key];
+	    dir = newDirs[key];
+	    if (!oldDir) {
+	      // new directive, bind
+	      callHook$1(dir, 'bind', vnode, oldVnode);
+	      if (dir.def && dir.def.inserted) {
+	        dirsWithInsert.push(dir);
+	      }
+	    } else {
+	      // existing directive, update
+	      dir.oldValue = oldDir.value;
+	      callHook$1(dir, 'update', vnode, oldVnode);
+	      if (dir.def && dir.def.componentUpdated) {
+	        dirsWithPostpatch.push(dir);
+	      }
+	    }
+	  }
+
+	  if (dirsWithInsert.length) {
+	    var callInsert = function () {
+	      for (var i = 0; i < dirsWithInsert.length; i++) {
+	        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+	      }
+	    };
+	    if (isCreate) {
+	      mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert);
+	    } else {
+	      callInsert();
+	    }
+	  }
+
+	  if (dirsWithPostpatch.length) {
+	    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {
+	      for (var i = 0; i < dirsWithPostpatch.length; i++) {
+	        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+	      }
+	    });
+	  }
+
+	  if (!isCreate) {
+	    for (key in oldDirs) {
+	      if (!newDirs[key]) {
+	        // no longer present, unbind
+	        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+	      }
+	    }
+	  }
+	}
+
+	var emptyModifiers = Object.create(null);
+
+	function normalizeDirectives$1 (
+	  dirs,
+	  vm
+	) {
+	  var res = Object.create(null);
+	  if (!dirs) {
+	    return res
+	  }
+	  var i, dir;
+	  for (i = 0; i < dirs.length; i++) {
+	    dir = dirs[i];
+	    if (!dir.modifiers) {
+	      dir.modifiers = emptyModifiers;
+	    }
+	    res[getRawDirName(dir)] = dir;
+	    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+	  }
+	  return res
+	}
+
+	function getRawDirName (dir) {
+	  return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
+	}
+
+	function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
+	  var fn = dir.def && dir.def[hook];
+	  if (fn) {
+	    try {
+	      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+	    } catch (e) {
+	      handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+	    }
+	  }
+	}
+
+	var baseModules = [
+	  ref,
+	  directives
+	];
+
+	/*  */
+
+	function updateAttrs (oldVnode, vnode) {
+	  var opts = vnode.componentOptions;
+	  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+	    return
+	  }
+	  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+	    return
+	  }
+	  var key, cur, old;
+	  var elm = vnode.elm;
+	  var oldAttrs = oldVnode.data.attrs || {};
+	  var attrs = vnode.data.attrs || {};
+	  // clone observed objects, as the user probably wants to mutate it
+	  if (isDef(attrs.__ob__)) {
+	    attrs = vnode.data.attrs = extend({}, attrs);
+	  }
+
+	  for (key in attrs) {
+	    cur = attrs[key];
+	    old = oldAttrs[key];
+	    if (old !== cur) {
+	      setAttr(elm, key, cur);
+	    }
+	  }
+	  // #4391: in IE9, setting type can reset value for input[type=radio]
+	  /* istanbul ignore if */
+	  if (isIE9 && attrs.value !== oldAttrs.value) {
+	    setAttr(elm, 'value', attrs.value);
+	  }
+	  for (key in oldAttrs) {
+	    if (isUndef(attrs[key])) {
+	      if (isXlink(key)) {
+	        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+	      } else if (!isEnumeratedAttr(key)) {
+	        elm.removeAttribute(key);
+	      }
+	    }
+	  }
+	}
+
+	function setAttr (el, key, value) {
+	  if (isBooleanAttr(key)) {
+	    // set attribute for blank value
+	    // e.g. <option disabled>Select one</option>
+	    if (isFalsyAttrValue(value)) {
+	      el.removeAttribute(key);
+	    } else {
+	      // technically allowfullscreen is a boolean attribute for <iframe>,
+	      // but Flash expects a value of "true" when used on <embed> tag
+	      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
+	        ? 'true'
+	        : key;
+	      el.setAttribute(key, value);
+	    }
+	  } else if (isEnumeratedAttr(key)) {
+	    el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');
+	  } else if (isXlink(key)) {
+	    if (isFalsyAttrValue(value)) {
+	      el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+	    } else {
+	      el.setAttributeNS(xlinkNS, key, value);
+	    }
+	  } else {
+	    if (isFalsyAttrValue(value)) {
+	      el.removeAttribute(key);
+	    } else {
+	      el.setAttribute(key, value);
+	    }
+	  }
+	}
+
+	var attrs = {
+	  create: updateAttrs,
+	  update: updateAttrs
+	};
+
+	/*  */
+
+	function updateClass (oldVnode, vnode) {
+	  var el = vnode.elm;
+	  var data = vnode.data;
+	  var oldData = oldVnode.data;
+	  if (
+	    isUndef(data.staticClass) &&
+	    isUndef(data.class) && (
+	      isUndef(oldData) || (
+	        isUndef(oldData.staticClass) &&
+	        isUndef(oldData.class)
+	      )
+	    )
+	  ) {
+	    return
+	  }
+
+	  var cls = genClassForVnode(vnode);
+
+	  // handle transition classes
+	  var transitionClass = el._transitionClasses;
+	  if (isDef(transitionClass)) {
+	    cls = concat(cls, stringifyClass(transitionClass));
+	  }
+
+	  // set the class
+	  if (cls !== el._prevClass) {
+	    el.setAttribute('class', cls);
+	    el._prevClass = cls;
+	  }
+	}
+
+	var klass = {
+	  create: updateClass,
+	  update: updateClass
+	};
+
+	/*  */
+
+	var validDivisionCharRE = /[\w).+\-_$\]]/;
+
+
+
+	function wrapFilter (exp, filter) {
+	  var i = filter.indexOf('(');
+	  if (i < 0) {
+	    // _f: resolveFilter
+	    return ("_f(\"" + filter + "\")(" + exp + ")")
+	  } else {
+	    var name = filter.slice(0, i);
+	    var args = filter.slice(i + 1);
+	    return ("_f(\"" + name + "\")(" + exp + "," + args)
+	  }
+	}
+
+	/*  */
+
+	/*  */
+
+	/**
+	 * Cross-platform code generation for component v-model
+	 */
+
+
+	/**
+	 * Cross-platform codegen helper for generating v-model value assignment code.
+	 */
+
+
+	/**
+	 * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)
+	 *
+	 * for loop possible cases:
+	 *
+	 * - test
+	 * - test[idx]
+	 * - test[test1[idx]]
+	 * - test["a"][idx]
+	 * - xxx.test[a[a].test1[idx]]
+	 * - test.xxx.a["asa"][test1[idx]]
+	 *
+	 */
+
+	var str;
+	var index$1;
+
+	/*  */
+
+	// in some cases, the event used has to be determined at runtime
+	// so we used some reserved tokens during compile.
+	var RANGE_TOKEN = '__r';
+	var CHECKBOX_RADIO_TOKEN = '__c';
+
+	/*  */
+
+	// normalize v-model event tokens that can only be determined at runtime.
+	// it's important to place the event as the first in the array because
+	// the whole point is ensuring the v-model callback gets called before
+	// user-attached handlers.
+	function normalizeEvents (on) {
+	  var event;
+	  /* istanbul ignore if */
+	  if (isDef(on[RANGE_TOKEN])) {
+	    // IE input[type=range] only supports `change` event
+	    event = isIE ? 'change' : 'input';
+	    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+	    delete on[RANGE_TOKEN];
+	  }
+	  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+	    // Chrome fires microtasks in between click/change, leads to #4521
+	    event = isChrome ? 'click' : 'change';
+	    on[event] = [].concat(on[CHECKBOX_RADIO_TOKEN], on[event] || []);
+	    delete on[CHECKBOX_RADIO_TOKEN];
+	  }
+	}
+
+	var target$1;
+
+	function add$1 (
+	  event,
+	  handler,
+	  once$$1,
+	  capture,
+	  passive
+	) {
+	  if (once$$1) {
+	    var oldHandler = handler;
+	    var _target = target$1; // save current target element in closure
+	    handler = function (ev) {
+	      var res = arguments.length === 1
+	        ? oldHandler(ev)
+	        : oldHandler.apply(null, arguments);
+	      if (res !== null) {
+	        remove$2(event, handler, capture, _target);
+	      }
+	    };
+	  }
+	  target$1.addEventListener(
+	    event,
+	    handler,
+	    supportsPassive
+	      ? { capture: capture, passive: passive }
+	      : capture
+	  );
+	}
+
+	function remove$2 (
+	  event,
+	  handler,
+	  capture,
+	  _target
+	) {
+	  (_target || target$1).removeEventListener(event, handler, capture);
+	}
+
+	function updateDOMListeners (oldVnode, vnode) {
+	  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+	    return
+	  }
+	  var on = vnode.data.on || {};
+	  var oldOn = oldVnode.data.on || {};
+	  target$1 = vnode.elm;
+	  normalizeEvents(on);
+	  updateListeners(on, oldOn, add$1, remove$2, vnode.context);
+	}
+
+	var events = {
+	  create: updateDOMListeners,
+	  update: updateDOMListeners
+	};
+
+	/*  */
+
+	function updateDOMProps (oldVnode, vnode) {
+	  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+	    return
+	  }
+	  var key, cur;
+	  var elm = vnode.elm;
+	  var oldProps = oldVnode.data.domProps || {};
+	  var props = vnode.data.domProps || {};
+	  // clone observed objects, as the user probably wants to mutate it
+	  if (isDef(props.__ob__)) {
+	    props = vnode.data.domProps = extend({}, props);
+	  }
+
+	  for (key in oldProps) {
+	    if (isUndef(props[key])) {
+	      elm[key] = '';
+	    }
+	  }
+	  for (key in props) {
+	    cur = props[key];
+	    // ignore children if the node has textContent or innerHTML,
+	    // as these will throw away existing DOM nodes and cause removal errors
+	    // on subsequent patches (#3360)
+	    if (key === 'textContent' || key === 'innerHTML') {
+	      if (vnode.children) { vnode.children.length = 0; }
+	      if (cur === oldProps[key]) { continue }
+	    }
+
+	    if (key === 'value') {
+	      // store value as _value as well since
+	      // non-string values will be stringified
+	      elm._value = cur;
+	      // avoid resetting cursor position when value is the same
+	      var strCur = isUndef(cur) ? '' : String(cur);
+	      if (shouldUpdateValue(elm, vnode, strCur)) {
+	        elm.value = strCur;
+	      }
+	    } else {
+	      elm[key] = cur;
+	    }
+	  }
+	}
+
+	// check platforms/web/util/attrs.js acceptValue
+
+
+	function shouldUpdateValue (
+	  elm,
+	  vnode,
+	  checkVal
+	) {
+	  return (!elm.composing && (
+	    vnode.tag === 'option' ||
+	    isDirty(elm, checkVal) ||
+	    isInputChanged(elm, checkVal)
+	  ))
+	}
+
+	function isDirty (elm, checkVal) {
+	  // return true when textbox (.number and .trim) loses focus and its value is
+	  // not equal to the updated value
+	  var notInFocus = true;
+	  // #6157
+	  // work around IE bug when accessing document.activeElement in an iframe
+	  try { notInFocus = document.activeElement !== elm; } catch (e) {}
+	  return notInFocus && elm.value !== checkVal
+	}
+
+	function isInputChanged (elm, newVal) {
+	  var value = elm.value;
+	  var modifiers = elm._vModifiers; // injected by v-model runtime
+	  if (isDef(modifiers) && modifiers.number) {
+	    return toNumber(value) !== toNumber(newVal)
+	  }
+	  if (isDef(modifiers) && modifiers.trim) {
+	    return value.trim() !== newVal.trim()
+	  }
+	  return value !== newVal
+	}
+
+	var domProps = {
+	  create: updateDOMProps,
+	  update: updateDOMProps
+	};
+
+	/*  */
+
+	var parseStyleText = cached(function (cssText) {
+	  var res = {};
+	  var listDelimiter = /;(?![^(]*\))/g;
+	  var propertyDelimiter = /:(.+)/;
+	  cssText.split(listDelimiter).forEach(function (item) {
+	    if (item) {
+	      var tmp = item.split(propertyDelimiter);
+	      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+	    }
+	  });
+	  return res
+	});
+
+	// merge static and dynamic style data on the same vnode
+	function normalizeStyleData (data) {
+	  var style = normalizeStyleBinding(data.style);
+	  // static style is pre-processed into an object during compilation
+	  // and is always a fresh object, so it's safe to merge into it
+	  return data.staticStyle
+	    ? extend(data.staticStyle, style)
+	    : style
+	}
+
+	// normalize possible array / string values into Object
+	function normalizeStyleBinding (bindingStyle) {
+	  if (Array.isArray(bindingStyle)) {
+	    return toObject(bindingStyle)
+	  }
+	  if (typeof bindingStyle === 'string') {
+	    return parseStyleText(bindingStyle)
+	  }
+	  return bindingStyle
+	}
+
+	/**
+	 * parent component style should be after child's
+	 * so that parent component's style could override it
+	 */
+	function getStyle (vnode, checkChild) {
+	  var res = {};
+	  var styleData;
+
+	  if (checkChild) {
+	    var childNode = vnode;
+	    while (childNode.componentInstance) {
+	      childNode = childNode.componentInstance._vnode;
+	      if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {
+	        extend(res, styleData);
+	      }
+	    }
+	  }
+
+	  if ((styleData = normalizeStyleData(vnode.data))) {
+	    extend(res, styleData);
+	  }
+
+	  var parentNode = vnode;
+	  while ((parentNode = parentNode.parent)) {
+	    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+	      extend(res, styleData);
+	    }
+	  }
+	  return res
+	}
+
+	/*  */
+
+	var cssVarRE = /^--/;
+	var importantRE = /\s*!important$/;
+	var setProp = function (el, name, val) {
+	  /* istanbul ignore if */
+	  if (cssVarRE.test(name)) {
+	    el.style.setProperty(name, val);
+	  } else if (importantRE.test(val)) {
+	    el.style.setProperty(name, val.replace(importantRE, ''), 'important');
+	  } else {
+	    var normalizedName = normalize(name);
+	    if (Array.isArray(val)) {
+	      // Support values array created by autoprefixer, e.g.
+	      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+	      // Set them one by one, and the browser will only set those it can recognize
+	      for (var i = 0, len = val.length; i < len; i++) {
+	        el.style[normalizedName] = val[i];
+	      }
+	    } else {
+	      el.style[normalizedName] = val;
+	    }
+	  }
+	};
+
+	var vendorNames = ['Webkit', 'Moz', 'ms'];
+
+	var emptyStyle;
+	var normalize = cached(function (prop) {
+	  emptyStyle = emptyStyle || document.createElement('div').style;
+	  prop = camelize(prop);
+	  if (prop !== 'filter' && (prop in emptyStyle)) {
+	    return prop
+	  }
+	  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+	  for (var i = 0; i < vendorNames.length; i++) {
+	    var name = vendorNames[i] + capName;
+	    if (name in emptyStyle) {
+	      return name
+	    }
+	  }
+	});
+
+	function updateStyle (oldVnode, vnode) {
+	  var data = vnode.data;
+	  var oldData = oldVnode.data;
+
+	  if (isUndef(data.staticStyle) && isUndef(data.style) &&
+	    isUndef(oldData.staticStyle) && isUndef(oldData.style)
+	  ) {
+	    return
+	  }
+
+	  var cur, name;
+	  var el = vnode.elm;
+	  var oldStaticStyle = oldData.staticStyle;
+	  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+
+	  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+	  var oldStyle = oldStaticStyle || oldStyleBinding;
+
+	  var style = normalizeStyleBinding(vnode.data.style) || {};
+
+	  // store normalized style under a different key for next diff
+	  // make sure to clone it if it's reactive, since the user likely wants
+	  // to mutate it.
+	  vnode.data.normalizedStyle = isDef(style.__ob__)
+	    ? extend({}, style)
+	    : style;
+
+	  var newStyle = getStyle(vnode, true);
+
+	  for (name in oldStyle) {
+	    if (isUndef(newStyle[name])) {
+	      setProp(el, name, '');
+	    }
+	  }
+	  for (name in newStyle) {
+	    cur = newStyle[name];
+	    if (cur !== oldStyle[name]) {
+	      // ie9 setting to null has no effect, must use empty string
+	      setProp(el, name, cur == null ? '' : cur);
+	    }
+	  }
+	}
+
+	var style = {
+	  create: updateStyle,
+	  update: updateStyle
+	};
+
+	/*  */
+
+	/**
+	 * Add class with compatibility for SVG since classList is not supported on
+	 * SVG elements in IE
+	 */
+	function addClass (el, cls) {
+	  /* istanbul ignore if */
+	  if (!cls || !(cls = cls.trim())) {
+	    return
+	  }
+
+	  /* istanbul ignore else */
+	  if (el.classList) {
+	    if (cls.indexOf(' ') > -1) {
+	      cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); });
+	    } else {
+	      el.classList.add(cls);
+	    }
+	  } else {
+	    var cur = " " + (el.getAttribute('class') || '') + " ";
+	    if (cur.indexOf(' ' + cls + ' ') < 0) {
+	      el.setAttribute('class', (cur + cls).trim());
+	    }
+	  }
+	}
+
+	/**
+	 * Remove class with compatibility for SVG since classList is not supported on
+	 * SVG elements in IE
+	 */
+	function removeClass (el, cls) {
+	  /* istanbul ignore if */
+	  if (!cls || !(cls = cls.trim())) {
+	    return
+	  }
+
+	  /* istanbul ignore else */
+	  if (el.classList) {
+	    if (cls.indexOf(' ') > -1) {
+	      cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); });
+	    } else {
+	      el.classList.remove(cls);
+	    }
+	    if (!el.classList.length) {
+	      el.removeAttribute('class');
+	    }
+	  } else {
+	    var cur = " " + (el.getAttribute('class') || '') + " ";
+	    var tar = ' ' + cls + ' ';
+	    while (cur.indexOf(tar) >= 0) {
+	      cur = cur.replace(tar, ' ');
+	    }
+	    cur = cur.trim();
+	    if (cur) {
+	      el.setAttribute('class', cur);
+	    } else {
+	      el.removeAttribute('class');
+	    }
+	  }
+	}
+
+	/*  */
+
+	function resolveTransition (def$$1) {
+	  if (!def$$1) {
+	    return
+	  }
+	  /* istanbul ignore else */
+	  if (typeof def$$1 === 'object') {
+	    var res = {};
+	    if (def$$1.css !== false) {
+	      extend(res, autoCssTransition(def$$1.name || 'v'));
+	    }
+	    extend(res, def$$1);
+	    return res
+	  } else if (typeof def$$1 === 'string') {
+	    return autoCssTransition(def$$1)
+	  }
+	}
+
+	var autoCssTransition = cached(function (name) {
+	  return {
+	    enterClass: (name + "-enter"),
+	    enterToClass: (name + "-enter-to"),
+	    enterActiveClass: (name + "-enter-active"),
+	    leaveClass: (name + "-leave"),
+	    leaveToClass: (name + "-leave-to"),
+	    leaveActiveClass: (name + "-leave-active")
+	  }
+	});
+
+	var hasTransition = inBrowser && !isIE9;
+	var TRANSITION = 'transition';
+	var ANIMATION = 'animation';
+
+	// Transition property/event sniffing
+	var transitionProp = 'transition';
+	var transitionEndEvent = 'transitionend';
+	var animationProp = 'animation';
+	var animationEndEvent = 'animationend';
+	if (hasTransition) {
+	  /* istanbul ignore if */
+	  if (window.ontransitionend === undefined &&
+	    window.onwebkittransitionend !== undefined
+	  ) {
+	    transitionProp = 'WebkitTransition';
+	    transitionEndEvent = 'webkitTransitionEnd';
+	  }
+	  if (window.onanimationend === undefined &&
+	    window.onwebkitanimationend !== undefined
+	  ) {
+	    animationProp = 'WebkitAnimation';
+	    animationEndEvent = 'webkitAnimationEnd';
+	  }
+	}
+
+	// binding to window is necessary to make hot reload work in IE in strict mode
+	var raf = inBrowser && window.requestAnimationFrame
+	  ? window.requestAnimationFrame.bind(window)
+	  : setTimeout;
+
+	function nextFrame (fn) {
+	  raf(function () {
+	    raf(fn);
+	  });
+	}
+
+	function addTransitionClass (el, cls) {
+	  var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+	  if (transitionClasses.indexOf(cls) < 0) {
+	    transitionClasses.push(cls);
+	    addClass(el, cls);
+	  }
+	}
+
+	function removeTransitionClass (el, cls) {
+	  if (el._transitionClasses) {
+	    remove(el._transitionClasses, cls);
+	  }
+	  removeClass(el, cls);
+	}
+
+	function whenTransitionEnds (
+	  el,
+	  expectedType,
+	  cb
+	) {
+	  var ref = getTransitionInfo(el, expectedType);
+	  var type = ref.type;
+	  var timeout = ref.timeout;
+	  var propCount = ref.propCount;
+	  if (!type) { return cb() }
+	  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+	  var ended = 0;
+	  var end = function () {
+	    el.removeEventListener(event, onEnd);
+	    cb();
+	  };
+	  var onEnd = function (e) {
+	    if (e.target === el) {
+	      if (++ended >= propCount) {
+	        end();
+	      }
+	    }
+	  };
+	  setTimeout(function () {
+	    if (ended < propCount) {
+	      end();
+	    }
+	  }, timeout + 1);
+	  el.addEventListener(event, onEnd);
+	}
+
+	var transformRE = /\b(transform|all)(,|$)/;
+
+	function getTransitionInfo (el, expectedType) {
+	  var styles = window.getComputedStyle(el);
+	  var transitionDelays = styles[transitionProp + 'Delay'].split(', ');
+	  var transitionDurations = styles[transitionProp + 'Duration'].split(', ');
+	  var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+	  var animationDelays = styles[animationProp + 'Delay'].split(', ');
+	  var animationDurations = styles[animationProp + 'Duration'].split(', ');
+	  var animationTimeout = getTimeout(animationDelays, animationDurations);
+
+	  var type;
+	  var timeout = 0;
+	  var propCount = 0;
+	  /* istanbul ignore if */
+	  if (expectedType === TRANSITION) {
+	    if (transitionTimeout > 0) {
+	      type = TRANSITION;
+	      timeout = transitionTimeout;
+	      propCount = transitionDurations.length;
+	    }
+	  } else if (expectedType === ANIMATION) {
+	    if (animationTimeout > 0) {
+	      type = ANIMATION;
+	      timeout = animationTimeout;
+	      propCount = animationDurations.length;
+	    }
+	  } else {
+	    timeout = Math.max(transitionTimeout, animationTimeout);
+	    type = timeout > 0
+	      ? transitionTimeout > animationTimeout
+	        ? TRANSITION
+	        : ANIMATION
+	      : null;
+	    propCount = type
+	      ? type === TRANSITION
+	        ? transitionDurations.length
+	        : animationDurations.length
+	      : 0;
+	  }
+	  var hasTransform =
+	    type === TRANSITION &&
+	    transformRE.test(styles[transitionProp + 'Property']);
+	  return {
+	    type: type,
+	    timeout: timeout,
+	    propCount: propCount,
+	    hasTransform: hasTransform
+	  }
+	}
+
+	function getTimeout (delays, durations) {
+	  /* istanbul ignore next */
+	  while (delays.length < durations.length) {
+	    delays = delays.concat(delays);
+	  }
+
+	  return Math.max.apply(null, durations.map(function (d, i) {
+	    return toMs(d) + toMs(delays[i])
+	  }))
+	}
+
+	function toMs (s) {
+	  return Number(s.slice(0, -1)) * 1000
+	}
+
+	/*  */
+
+	function enter (vnode, toggleDisplay) {
+	  var el = vnode.elm;
+
+	  // call leave callback now
+	  if (isDef(el._leaveCb)) {
+	    el._leaveCb.cancelled = true;
+	    el._leaveCb();
+	  }
+
+	  var data = resolveTransition(vnode.data.transition);
+	  if (isUndef(data)) {
+	    return
+	  }
+
+	  /* istanbul ignore if */
+	  if (isDef(el._enterCb) || el.nodeType !== 1) {
+	    return
+	  }
+
+	  var css = data.css;
+	  var type = data.type;
+	  var enterClass = data.enterClass;
+	  var enterToClass = data.enterToClass;
+	  var enterActiveClass = data.enterActiveClass;
+	  var appearClass = data.appearClass;
+	  var appearToClass = data.appearToClass;
+	  var appearActiveClass = data.appearActiveClass;
+	  var beforeEnter = data.beforeEnter;
+	  var enter = data.enter;
+	  var afterEnter = data.afterEnter;
+	  var enterCancelled = data.enterCancelled;
+	  var beforeAppear = data.beforeAppear;
+	  var appear = data.appear;
+	  var afterAppear = data.afterAppear;
+	  var appearCancelled = data.appearCancelled;
+	  var duration = data.duration;
+
+	  // activeInstance will always be the <transition> component managing this
+	  // transition. One edge case to check is when the <transition> is placed
+	  // as the root node of a child component. In that case we need to check
+	  // <transition>'s parent for appear check.
+	  var context = activeInstance;
+	  var transitionNode = activeInstance.$vnode;
+	  while (transitionNode && transitionNode.parent) {
+	    transitionNode = transitionNode.parent;
+	    context = transitionNode.context;
+	  }
+
+	  var isAppear = !context._isMounted || !vnode.isRootInsert;
+
+	  if (isAppear && !appear && appear !== '') {
+	    return
+	  }
+
+	  var startClass = isAppear && appearClass
+	    ? appearClass
+	    : enterClass;
+	  var activeClass = isAppear && appearActiveClass
+	    ? appearActiveClass
+	    : enterActiveClass;
+	  var toClass = isAppear && appearToClass
+	    ? appearToClass
+	    : enterToClass;
+
+	  var beforeEnterHook = isAppear
+	    ? (beforeAppear || beforeEnter)
+	    : beforeEnter;
+	  var enterHook = isAppear
+	    ? (typeof appear === 'function' ? appear : enter)
+	    : enter;
+	  var afterEnterHook = isAppear
+	    ? (afterAppear || afterEnter)
+	    : afterEnter;
+	  var enterCancelledHook = isAppear
+	    ? (appearCancelled || enterCancelled)
+	    : enterCancelled;
+
+	  var explicitEnterDuration = toNumber(
+	    isObject(duration)
+	      ? duration.enter
+	      : duration
+	  );
+
+	  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+	    checkDuration(explicitEnterDuration, 'enter', vnode);
+	  }
+
+	  var expectsCSS = css !== false && !isIE9;
+	  var userWantsControl = getHookArgumentsLength(enterHook);
+
+	  var cb = el._enterCb = once(function () {
+	    if (expectsCSS) {
+	      removeTransitionClass(el, toClass);
+	      removeTransitionClass(el, activeClass);
+	    }
+	    if (cb.cancelled) {
+	      if (expectsCSS) {
+	        removeTransitionClass(el, startClass);
+	      }
+	      enterCancelledHook && enterCancelledHook(el);
+	    } else {
+	      afterEnterHook && afterEnterHook(el);
+	    }
+	    el._enterCb = null;
+	  });
+
+	  if (!vnode.data.show) {
+	    // remove pending leave element on enter by injecting an insert hook
+	    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {
+	      var parent = el.parentNode;
+	      var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+	      if (pendingNode &&
+	        pendingNode.tag === vnode.tag &&
+	        pendingNode.elm._leaveCb
+	      ) {
+	        pendingNode.elm._leaveCb();
+	      }
+	      enterHook && enterHook(el, cb);
+	    });
+	  }
+
+	  // start enter transition
+	  beforeEnterHook && beforeEnterHook(el);
+	  if (expectsCSS) {
+	    addTransitionClass(el, startClass);
+	    addTransitionClass(el, activeClass);
+	    nextFrame(function () {
+	      addTransitionClass(el, toClass);
+	      removeTransitionClass(el, startClass);
+	      if (!cb.cancelled && !userWantsControl) {
+	        if (isValidDuration(explicitEnterDuration)) {
+	          setTimeout(cb, explicitEnterDuration);
+	        } else {
+	          whenTransitionEnds(el, type, cb);
+	        }
+	      }
+	    });
+	  }
+
+	  if (vnode.data.show) {
+	    toggleDisplay && toggleDisplay();
+	    enterHook && enterHook(el, cb);
+	  }
+
+	  if (!expectsCSS && !userWantsControl) {
+	    cb();
+	  }
+	}
+
+	function leave (vnode, rm) {
+	  var el = vnode.elm;
+
+	  // call enter callback now
+	  if (isDef(el._enterCb)) {
+	    el._enterCb.cancelled = true;
+	    el._enterCb();
+	  }
+
+	  var data = resolveTransition(vnode.data.transition);
+	  if (isUndef(data)) {
+	    return rm()
+	  }
+
+	  /* istanbul ignore if */
+	  if (isDef(el._leaveCb) || el.nodeType !== 1) {
+	    return
+	  }
+
+	  var css = data.css;
+	  var type = data.type;
+	  var leaveClass = data.leaveClass;
+	  var leaveToClass = data.leaveToClass;
+	  var leaveActiveClass = data.leaveActiveClass;
+	  var beforeLeave = data.beforeLeave;
+	  var leave = data.leave;
+	  var afterLeave = data.afterLeave;
+	  var leaveCancelled = data.leaveCancelled;
+	  var delayLeave = data.delayLeave;
+	  var duration = data.duration;
+
+	  var expectsCSS = css !== false && !isIE9;
+	  var userWantsControl = getHookArgumentsLength(leave);
+
+	  var explicitLeaveDuration = toNumber(
+	    isObject(duration)
+	      ? duration.leave
+	      : duration
+	  );
+
+	  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+	    checkDuration(explicitLeaveDuration, 'leave', vnode);
+	  }
+
+	  var cb = el._leaveCb = once(function () {
+	    if (el.parentNode && el.parentNode._pending) {
+	      el.parentNode._pending[vnode.key] = null;
+	    }
+	    if (expectsCSS) {
+	      removeTransitionClass(el, leaveToClass);
+	      removeTransitionClass(el, leaveActiveClass);
+	    }
+	    if (cb.cancelled) {
+	      if (expectsCSS) {
+	        removeTransitionClass(el, leaveClass);
+	      }
+	      leaveCancelled && leaveCancelled(el);
+	    } else {
+	      rm();
+	      afterLeave && afterLeave(el);
+	    }
+	    el._leaveCb = null;
+	  });
+
+	  if (delayLeave) {
+	    delayLeave(performLeave);
+	  } else {
+	    performLeave();
+	  }
+
+	  function performLeave () {
+	    // the delayed leave may have already been cancelled
+	    if (cb.cancelled) {
+	      return
+	    }
+	    // record leaving element
+	    if (!vnode.data.show) {
+	      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
+	    }
+	    beforeLeave && beforeLeave(el);
+	    if (expectsCSS) {
+	      addTransitionClass(el, leaveClass);
+	      addTransitionClass(el, leaveActiveClass);
+	      nextFrame(function () {
+	        addTransitionClass(el, leaveToClass);
+	        removeTransitionClass(el, leaveClass);
+	        if (!cb.cancelled && !userWantsControl) {
+	          if (isValidDuration(explicitLeaveDuration)) {
+	            setTimeout(cb, explicitLeaveDuration);
+	          } else {
+	            whenTransitionEnds(el, type, cb);
+	          }
+	        }
+	      });
+	    }
+	    leave && leave(el, cb);
+	    if (!expectsCSS && !userWantsControl) {
+	      cb();
+	    }
+	  }
+	}
+
+	// only used in dev mode
+	function checkDuration (val, name, vnode) {
+	  if (typeof val !== 'number') {
+	    warn(
+	      "<transition> explicit " + name + " duration is not a valid number - " +
+	      "got " + (JSON.stringify(val)) + ".",
+	      vnode.context
+	    );
+	  } else if (isNaN(val)) {
+	    warn(
+	      "<transition> explicit " + name + " duration is NaN - " +
+	      'the duration expression might be incorrect.',
+	      vnode.context
+	    );
+	  }
+	}
+
+	function isValidDuration (val) {
+	  return typeof val === 'number' && !isNaN(val)
+	}
+
+	/**
+	 * Normalize a transition hook's argument length. The hook may be:
+	 * - a merged hook (invoker) with the original in .fns
+	 * - a wrapped component method (check ._length)
+	 * - a plain function (.length)
+	 */
+	function getHookArgumentsLength (fn) {
+	  if (isUndef(fn)) {
+	    return false
+	  }
+	  var invokerFns = fn.fns;
+	  if (isDef(invokerFns)) {
+	    // invoker
+	    return getHookArgumentsLength(
+	      Array.isArray(invokerFns)
+	        ? invokerFns[0]
+	        : invokerFns
+	    )
+	  } else {
+	    return (fn._length || fn.length) > 1
+	  }
+	}
+
+	function _enter (_, vnode) {
+	  if (vnode.data.show !== true) {
+	    enter(vnode);
+	  }
+	}
+
+	var transition = inBrowser ? {
+	  create: _enter,
+	  activate: _enter,
+	  remove: function remove$$1 (vnode, rm) {
+	    /* istanbul ignore else */
+	    if (vnode.data.show !== true) {
+	      leave(vnode, rm);
+	    } else {
+	      rm();
+	    }
+	  }
+	} : {};
+
+	var platformModules = [
+	  attrs,
+	  klass,
+	  events,
+	  domProps,
+	  style,
+	  transition
+	];
+
+	/*  */
+
+	// the directive module should be applied last, after all
+	// built-in modules have been applied.
+	var modules = platformModules.concat(baseModules);
+
+	var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+
+	/**
+	 * Not type checking this file because flow doesn't like attaching
+	 * properties to Elements.
+	 */
+
+	/* istanbul ignore if */
+	if (isIE9) {
+	  // http://www.matts411.com/post/internet-explorer-9-oninput/
+	  document.addEventListener('selectionchange', function () {
+	    var el = document.activeElement;
+	    if (el && el.vmodel) {
+	      trigger(el, 'input');
+	    }
+	  });
+	}
+
+	var model$1 = {
+	  inserted: function inserted (el, binding, vnode) {
+	    if (vnode.tag === 'select') {
+	      setSelected(el, binding, vnode.context);
+	      el._vOptions = [].map.call(el.options, getValue);
+	    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+	      el._vModifiers = binding.modifiers;
+	      if (!binding.modifiers.lazy) {
+	        // Safari < 10.2 & UIWebView doesn't fire compositionend when
+	        // switching focus before confirming composition choice
+	        // this also fixes the issue where some browsers e.g. iOS Chrome
+	        // fires "change" instead of "input" on autocomplete.
+	        el.addEventListener('change', onCompositionEnd);
+	        if (!isAndroid) {
+	          el.addEventListener('compositionstart', onCompositionStart);
+	          el.addEventListener('compositionend', onCompositionEnd);
+	        }
+	        /* istanbul ignore if */
+	        if (isIE9) {
+	          el.vmodel = true;
+	        }
+	      }
+	    }
+	  },
+	  componentUpdated: function componentUpdated (el, binding, vnode) {
+	    if (vnode.tag === 'select') {
+	      setSelected(el, binding, vnode.context);
+	      // in case the options rendered by v-for have changed,
+	      // it's possible that the value is out-of-sync with the rendered options.
+	      // detect such cases and filter out values that no longer has a matching
+	      // option in the DOM.
+	      var prevOptions = el._vOptions;
+	      var curOptions = el._vOptions = [].map.call(el.options, getValue);
+	      if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+	        // trigger change event if
+	        // no matching option found for at least one value
+	        var needReset = el.multiple
+	          ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+	          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
+	        if (needReset) {
+	          trigger(el, 'change');
+	        }
+	      }
+	    }
+	  }
+	};
+
+	function setSelected (el, binding, vm) {
+	  actuallySetSelected(el, binding, vm);
+	  /* istanbul ignore if */
+	  if (isIE || isEdge) {
+	    setTimeout(function () {
+	      actuallySetSelected(el, binding, vm);
+	    }, 0);
+	  }
+	}
+
+	function actuallySetSelected (el, binding, vm) {
+	  var value = binding.value;
+	  var isMultiple = el.multiple;
+	  if (isMultiple && !Array.isArray(value)) {
+	    process.env.NODE_ENV !== 'production' && warn(
+	      "<select multiple v-model=\"" + (binding.expression) + "\"> " +
+	      "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
+	      vm
+	    );
+	    return
+	  }
+	  var selected, option;
+	  for (var i = 0, l = el.options.length; i < l; i++) {
+	    option = el.options[i];
+	    if (isMultiple) {
+	      selected = looseIndexOf(value, getValue(option)) > -1;
+	      if (option.selected !== selected) {
+	        option.selected = selected;
+	      }
+	    } else {
+	      if (looseEqual(getValue(option), value)) {
+	        if (el.selectedIndex !== i) {
+	          el.selectedIndex = i;
+	        }
+	        return
+	      }
+	    }
+	  }
+	  if (!isMultiple) {
+	    el.selectedIndex = -1;
+	  }
+	}
+
+	function hasNoMatchingOption (value, options) {
+	  return options.every(function (o) { return !looseEqual(o, value); })
+	}
+
+	function getValue (option) {
+	  return '_value' in option
+	    ? option._value
+	    : option.value
+	}
+
+	function onCompositionStart (e) {
+	  e.target.composing = true;
+	}
+
+	function onCompositionEnd (e) {
+	  // prevent triggering an input event for no reason
+	  if (!e.target.composing) { return }
+	  e.target.composing = false;
+	  trigger(e.target, 'input');
+	}
+
+	function trigger (el, type) {
+	  var e = document.createEvent('HTMLEvents');
+	  e.initEvent(type, true, true);
+	  el.dispatchEvent(e);
+	}
+
+	/*  */
+
+	// recursively search for possible transition defined inside the component root
+	function locateNode (vnode) {
+	  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+	    ? locateNode(vnode.componentInstance._vnode)
+	    : vnode
+	}
+
+	var show = {
+	  bind: function bind (el, ref, vnode) {
+	    var value = ref.value;
+
+	    vnode = locateNode(vnode);
+	    var transition$$1 = vnode.data && vnode.data.transition;
+	    var originalDisplay = el.__vOriginalDisplay =
+	      el.style.display === 'none' ? '' : el.style.display;
+	    if (value && transition$$1) {
+	      vnode.data.show = true;
+	      enter(vnode, function () {
+	        el.style.display = originalDisplay;
+	      });
+	    } else {
+	      el.style.display = value ? originalDisplay : 'none';
+	    }
+	  },
+
+	  update: function update (el, ref, vnode) {
+	    var value = ref.value;
+	    var oldValue = ref.oldValue;
+
+	    /* istanbul ignore if */
+	    if (value === oldValue) { return }
+	    vnode = locateNode(vnode);
+	    var transition$$1 = vnode.data && vnode.data.transition;
+	    if (transition$$1) {
+	      vnode.data.show = true;
+	      if (value) {
+	        enter(vnode, function () {
+	          el.style.display = el.__vOriginalDisplay;
+	        });
+	      } else {
+	        leave(vnode, function () {
+	          el.style.display = 'none';
+	        });
+	      }
+	    } else {
+	      el.style.display = value ? el.__vOriginalDisplay : 'none';
+	    }
+	  },
+
+	  unbind: function unbind (
+	    el,
+	    binding,
+	    vnode,
+	    oldVnode,
+	    isDestroy
+	  ) {
+	    if (!isDestroy) {
+	      el.style.display = el.__vOriginalDisplay;
+	    }
+	  }
+	};
+
+	var platformDirectives = {
+	  model: model$1,
+	  show: show
+	};
+
+	/*  */
+
+	// Provides transition support for a single element/component.
+	// supports transition mode (out-in / in-out)
+
+	var transitionProps = {
+	  name: String,
+	  appear: Boolean,
+	  css: Boolean,
+	  mode: String,
+	  type: String,
+	  enterClass: String,
+	  leaveClass: String,
+	  enterToClass: String,
+	  leaveToClass: String,
+	  enterActiveClass: String,
+	  leaveActiveClass: String,
+	  appearClass: String,
+	  appearActiveClass: String,
+	  appearToClass: String,
+	  duration: [Number, String, Object]
+	};
+
+	// in case the child is also an abstract component, e.g. <keep-alive>
+	// we want to recursively retrieve the real component to be rendered
+	function getRealChild (vnode) {
+	  var compOptions = vnode && vnode.componentOptions;
+	  if (compOptions && compOptions.Ctor.options.abstract) {
+	    return getRealChild(getFirstComponentChild(compOptions.children))
+	  } else {
+	    return vnode
+	  }
+	}
+
+	function extractTransitionData (comp) {
+	  var data = {};
+	  var options = comp.$options;
+	  // props
+	  for (var key in options.propsData) {
+	    data[key] = comp[key];
+	  }
+	  // events.
+	  // extract listeners and pass them directly to the transition methods
+	  var listeners = options._parentListeners;
+	  for (var key$1 in listeners) {
+	    data[camelize(key$1)] = listeners[key$1];
+	  }
+	  return data
+	}
+
+	function placeholder (h, rawChild) {
+	  if (/\d-keep-alive$/.test(rawChild.tag)) {
+	    return h('keep-alive', {
+	      props: rawChild.componentOptions.propsData
+	    })
+	  }
+	}
+
+	function hasParentTransition (vnode) {
+	  while ((vnode = vnode.parent)) {
+	    if (vnode.data.transition) {
+	      return true
+	    }
+	  }
+	}
+
+	function isSameChild (child, oldChild) {
+	  return oldChild.key === child.key && oldChild.tag === child.tag
+	}
+
+	var Transition = {
+	  name: 'transition',
+	  props: transitionProps,
+	  abstract: true,
+
+	  render: function render (h) {
+	    var this$1 = this;
+
+	    var children = this.$options._renderChildren;
+	    if (!children) {
+	      return
+	    }
+
+	    // filter out text nodes (possible whitespaces)
+	    children = children.filter(function (c) { return c.tag || isAsyncPlaceholder(c); });
+	    /* istanbul ignore if */
+	    if (!children.length) {
+	      return
+	    }
+
+	    // warn multiple elements
+	    if (process.env.NODE_ENV !== 'production' && children.length > 1) {
+	      warn(
+	        '<transition> can only be used on a single element. Use ' +
+	        '<transition-group> for lists.',
+	        this.$parent
+	      );
+	    }
+
+	    var mode = this.mode;
+
+	    // warn invalid mode
+	    if (process.env.NODE_ENV !== 'production' &&
+	      mode && mode !== 'in-out' && mode !== 'out-in'
+	    ) {
+	      warn(
+	        'invalid <transition> mode: ' + mode,
+	        this.$parent
+	      );
+	    }
+
+	    var rawChild = children[0];
+
+	    // if this is a component root node and the component's
+	    // parent container node also has transition, skip.
+	    if (hasParentTransition(this.$vnode)) {
+	      return rawChild
+	    }
+
+	    // apply transition data to child
+	    // use getRealChild() to ignore abstract components e.g. keep-alive
+	    var child = getRealChild(rawChild);
+	    /* istanbul ignore if */
+	    if (!child) {
+	      return rawChild
+	    }
+
+	    if (this._leaving) {
+	      return placeholder(h, rawChild)
+	    }
+
+	    // ensure a key that is unique to the vnode type and to this transition
+	    // component instance. This key will be used to remove pending leaving nodes
+	    // during entering.
+	    var id = "__transition-" + (this._uid) + "-";
+	    child.key = child.key == null
+	      ? child.isComment
+	        ? id + 'comment'
+	        : id + child.tag
+	      : isPrimitive(child.key)
+	        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
+	        : child.key;
+
+	    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
+	    var oldRawChild = this._vnode;
+	    var oldChild = getRealChild(oldRawChild);
+
+	    // mark v-show
+	    // so that the transition module can hand over the control to the directive
+	    if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {
+	      child.data.show = true;
+	    }
+
+	    if (
+	      oldChild &&
+	      oldChild.data &&
+	      !isSameChild(child, oldChild) &&
+	      !isAsyncPlaceholder(oldChild)
+	    ) {
+	      // replace old child transition data with fresh one
+	      // important for dynamic transitions!
+	      var oldData = oldChild && (oldChild.data.transition = extend({}, data));
+	      // handle transition mode
+	      if (mode === 'out-in') {
+	        // return placeholder node and queue update when leave finishes
+	        this._leaving = true;
+	        mergeVNodeHook(oldData, 'afterLeave', function () {
+	          this$1._leaving = false;
+	          this$1.$forceUpdate();
+	        });
+	        return placeholder(h, rawChild)
+	      } else if (mode === 'in-out') {
+	        if (isAsyncPlaceholder(child)) {
+	          return oldRawChild
+	        }
+	        var delayedLeave;
+	        var performLeave = function () { delayedLeave(); };
+	        mergeVNodeHook(data, 'afterEnter', performLeave);
+	        mergeVNodeHook(data, 'enterCancelled', performLeave);
+	        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
+	      }
+	    }
+
+	    return rawChild
+	  }
+	};
+
+	/*  */
+
+	// Provides transition support for list items.
+	// supports move transitions using the FLIP technique.
+
+	// Because the vdom's children update algorithm is "unstable" - i.e.
+	// it doesn't guarantee the relative positioning of removed elements,
+	// we force transition-group to update its children into two passes:
+	// in the first pass, we remove all nodes that need to be removed,
+	// triggering their leaving transition; in the second pass, we insert/move
+	// into the final desired state. This way in the second pass removed
+	// nodes will remain where they should be.
+
+	var props = extend({
+	  tag: String,
+	  moveClass: String
+	}, transitionProps);
+
+	delete props.mode;
+
+	var TransitionGroup = {
+	  props: props,
+
+	  render: function render (h) {
+	    var tag = this.tag || this.$vnode.data.tag || 'span';
+	    var map = Object.create(null);
+	    var prevChildren = this.prevChildren = this.children;
+	    var rawChildren = this.$slots.default || [];
+	    var children = this.children = [];
+	    var transitionData = extractTransitionData(this);
+
+	    for (var i = 0; i < rawChildren.length; i++) {
+	      var c = rawChildren[i];
+	      if (c.tag) {
+	        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+	          children.push(c);
+	          map[c.key] = c
+	          ;(c.data || (c.data = {})).transition = transitionData;
+	        } else if (process.env.NODE_ENV !== 'production') {
+	          var opts = c.componentOptions;
+	          var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
+	          warn(("<transition-group> children must be keyed: <" + name + ">"));
+	        }
+	      }
+	    }
+
+	    if (prevChildren) {
+	      var kept = [];
+	      var removed = [];
+	      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+	        var c$1 = prevChildren[i$1];
+	        c$1.data.transition = transitionData;
+	        c$1.data.pos = c$1.elm.getBoundingClientRect();
+	        if (map[c$1.key]) {
+	          kept.push(c$1);
+	        } else {
+	          removed.push(c$1);
+	        }
+	      }
+	      this.kept = h(tag, null, kept);
+	      this.removed = removed;
+	    }
+
+	    return h(tag, null, children)
+	  },
+
+	  beforeUpdate: function beforeUpdate () {
+	    // force removing pass
+	    this.__patch__(
+	      this._vnode,
+	      this.kept,
+	      false, // hydrating
+	      true // removeOnly (!important, avoids unnecessary moves)
+	    );
+	    this._vnode = this.kept;
+	  },
+
+	  updated: function updated () {
+	    var children = this.prevChildren;
+	    var moveClass = this.moveClass || ((this.name || 'v') + '-move');
+	    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+	      return
+	    }
+
+	    // we divide the work into three loops to avoid mixing DOM reads and writes
+	    // in each iteration - which helps prevent layout thrashing.
+	    children.forEach(callPendingCbs);
+	    children.forEach(recordPosition);
+	    children.forEach(applyTranslation);
+
+	    // force reflow to put everything in position
+	    var body = document.body;
+	    var f = body.offsetHeight; // eslint-disable-line
+
+	    children.forEach(function (c) {
+	      if (c.data.moved) {
+	        var el = c.elm;
+	        var s = el.style;
+	        addTransitionClass(el, moveClass);
+	        s.transform = s.WebkitTransform = s.transitionDuration = '';
+	        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
+	          if (!e || /transform$/.test(e.propertyName)) {
+	            el.removeEventListener(transitionEndEvent, cb);
+	            el._moveCb = null;
+	            removeTransitionClass(el, moveClass);
+	          }
+	        });
+	      }
+	    });
+	  },
+
+	  methods: {
+	    hasMove: function hasMove (el, moveClass) {
+	      /* istanbul ignore if */
+	      if (!hasTransition) {
+	        return false
+	      }
+	      /* istanbul ignore if */
+	      if (this._hasMove) {
+	        return this._hasMove
+	      }
+	      // Detect whether an element with the move class applied has
+	      // CSS transitions. Since the element may be inside an entering
+	      // transition at this very moment, we make a clone of it and remove
+	      // all other transition classes applied to ensure only the move class
+	      // is applied.
+	      var clone = el.cloneNode();
+	      if (el._transitionClasses) {
+	        el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
+	      }
+	      addClass(clone, moveClass);
+	      clone.style.display = 'none';
+	      this.$el.appendChild(clone);
+	      var info = getTransitionInfo(clone);
+	      this.$el.removeChild(clone);
+	      return (this._hasMove = info.hasTransform)
+	    }
+	  }
+	};
+
+	function callPendingCbs (c) {
+	  /* istanbul ignore if */
+	  if (c.elm._moveCb) {
+	    c.elm._moveCb();
+	  }
+	  /* istanbul ignore if */
+	  if (c.elm._enterCb) {
+	    c.elm._enterCb();
+	  }
+	}
+
+	function recordPosition (c) {
+	  c.data.newPos = c.elm.getBoundingClientRect();
+	}
+
+	function applyTranslation (c) {
+	  var oldPos = c.data.pos;
+	  var newPos = c.data.newPos;
+	  var dx = oldPos.left - newPos.left;
+	  var dy = oldPos.top - newPos.top;
+	  if (dx || dy) {
+	    c.data.moved = true;
+	    var s = c.elm.style;
+	    s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+	    s.transitionDuration = '0s';
+	  }
+	}
+
+	var platformComponents = {
+	  Transition: Transition,
+	  TransitionGroup: TransitionGroup
+	};
+
+	/*  */
+
+	// install platform specific utils
+	Vue$3.config.mustUseProp = mustUseProp;
+	Vue$3.config.isReservedTag = isReservedTag;
+	Vue$3.config.isReservedAttr = isReservedAttr;
+	Vue$3.config.getTagNamespace = getTagNamespace;
+	Vue$3.config.isUnknownElement = isUnknownElement;
+
+	// install platform runtime directives & components
+	extend(Vue$3.options.directives, platformDirectives);
+	extend(Vue$3.options.components, platformComponents);
+
+	// install platform patch function
+	Vue$3.prototype.__patch__ = inBrowser ? patch : noop;
+
+	// public mount method
+	Vue$3.prototype.$mount = function (
+	  el,
+	  hydrating
+	) {
+	  el = el && inBrowser ? query(el) : undefined;
+	  return mountComponent(this, el, hydrating)
+	};
+
+	// devtools global hook
+	/* istanbul ignore next */
+	setTimeout(function () {
+	  if (config.devtools) {
+	    if (devtools) {
+	      devtools.emit('init', Vue$3);
+	    } else if (process.env.NODE_ENV !== 'production' && isChrome) {
+	      console[console.info ? 'info' : 'log'](
+	        'Download the Vue Devtools extension for a better development experience:\n' +
+	        'https://github.com/vuejs/vue-devtools'
+	      );
+	    }
+	  }
+	  if (process.env.NODE_ENV !== 'production' &&
+	    config.productionTip !== false &&
+	    inBrowser && typeof console !== 'undefined'
+	  ) {
+	    console[console.info ? 'info' : 'log'](
+	      "You are running Vue in development mode.\n" +
+	      "Make sure to turn on production mode when deploying for production.\n" +
+	      "See more tips at https://vuejs.org/guide/deployment.html"
+	    );
+	  }
+	}, 0);
+
+	/*  */
+
+	module.exports = Vue$3;
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), (function() { return this; }())))
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	// shim for using process in browser
+	var process = module.exports = {};
+
+	// cached from whatever global is present so that test runners that stub it
+	// don't break things.  But we need to wrap it in a try catch in case it is
+	// wrapped in strict mode code which doesn't define any globals.  It's inside a
+	// function because try/catches deoptimize in certain engines.
+
+	var cachedSetTimeout;
+	var cachedClearTimeout;
+
+	function defaultSetTimout() {
+	    throw new Error('setTimeout has not been defined');
+	}
+	function defaultClearTimeout () {
+	    throw new Error('clearTimeout has not been defined');
+	}
+	(function () {
+	    try {
+	        if (typeof setTimeout === 'function') {
+	            cachedSetTimeout = setTimeout;
+	        } else {
+	            cachedSetTimeout = defaultSetTimout;
+	        }
+	    } catch (e) {
+	        cachedSetTimeout = defaultSetTimout;
+	    }
+	    try {
+	        if (typeof clearTimeout === 'function') {
+	            cachedClearTimeout = clearTimeout;
+	        } else {
+	            cachedClearTimeout = defaultClearTimeout;
+	        }
+	    } catch (e) {
+	        cachedClearTimeout = defaultClearTimeout;
+	    }
+	} ())
+	function runTimeout(fun) {
+	    if (cachedSetTimeout === setTimeout) {
+	        //normal enviroments in sane situations
+	        return setTimeout(fun, 0);
+	    }
+	    // if setTimeout wasn't available but was latter defined
+	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+	        cachedSetTimeout = setTimeout;
+	        return setTimeout(fun, 0);
+	    }
+	    try {
+	        // when when somebody has screwed with setTimeout but no I.E. maddness
+	        return cachedSetTimeout(fun, 0);
+	    } catch(e){
+	        try {
+	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+	            return cachedSetTimeout.call(null, fun, 0);
+	        } catch(e){
+	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+	            return cachedSetTimeout.call(this, fun, 0);
+	        }
+	    }
+
+
+	}
+	function runClearTimeout(marker) {
+	    if (cachedClearTimeout === clearTimeout) {
+	        //normal enviroments in sane situations
+	        return clearTimeout(marker);
+	    }
+	    // if clearTimeout wasn't available but was latter defined
+	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+	        cachedClearTimeout = clearTimeout;
+	        return clearTimeout(marker);
+	    }
+	    try {
+	        // when when somebody has screwed with setTimeout but no I.E. maddness
+	        return cachedClearTimeout(marker);
+	    } catch (e){
+	        try {
+	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+	            return cachedClearTimeout.call(null, marker);
+	        } catch (e){
+	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+	            return cachedClearTimeout.call(this, marker);
+	        }
+	    }
+
+
+
+	}
+	var queue = [];
+	var draining = false;
+	var currentQueue;
+	var queueIndex = -1;
+
+	function cleanUpNextTick() {
+	    if (!draining || !currentQueue) {
+	        return;
+	    }
+	    draining = false;
+	    if (currentQueue.length) {
+	        queue = currentQueue.concat(queue);
+	    } else {
+	        queueIndex = -1;
+	    }
+	    if (queue.length) {
+	        drainQueue();
+	    }
+	}
+
+	function drainQueue() {
+	    if (draining) {
+	        return;
+	    }
+	    var timeout = runTimeout(cleanUpNextTick);
+	    draining = true;
+
+	    var len = queue.length;
+	    while(len) {
+	        currentQueue = queue;
+	        queue = [];
+	        while (++queueIndex < len) {
+	            if (currentQueue) {
+	                currentQueue[queueIndex].run();
+	            }
+	        }
+	        queueIndex = -1;
+	        len = queue.length;
+	    }
+	    currentQueue = null;
+	    draining = false;
+	    runClearTimeout(timeout);
+	}
+
+	process.nextTick = function (fun) {
+	    var args = new Array(arguments.length - 1);
+	    if (arguments.length > 1) {
+	        for (var i = 1; i < arguments.length; i++) {
+	            args[i - 1] = arguments[i];
+	        }
+	    }
+	    queue.push(new Item(fun, args));
+	    if (queue.length === 1 && !draining) {
+	        runTimeout(drainQueue);
+	    }
+	};
+
+	// v8 likes predictible objects
+	function Item(fun, array) {
+	    this.fun = fun;
+	    this.array = array;
+	}
+	Item.prototype.run = function () {
+	    this.fun.apply(null, this.array);
+	};
+	process.title = 'browser';
+	process.browser = true;
+	process.env = {};
+	process.argv = [];
+	process.version = ''; // empty string to avoid regexp issues
+	process.versions = {};
+
+	function noop() {}
+
+	process.on = noop;
+	process.addListener = noop;
+	process.once = noop;
+	process.off = noop;
+	process.removeListener = noop;
+	process.removeAllListeners = noop;
+	process.emit = noop;
+
+	process.binding = function (name) {
+	    throw new Error('process.binding is not supported');
+	};
+
+	process.cwd = function () { return '/' };
+	process.chdir = function (dir) {
+	    throw new Error('process.chdir is not supported');
+	};
+	process.umask = function() { return 0; };
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * @namespace Chart
+	 */
+	var Chart = __webpack_require__(5)();
+
+	Chart.helpers = __webpack_require__(7);
+
+	// @todo dispatch these helpers into appropriated helpers/helpers.* file and write unit tests!
+	__webpack_require__(12)(Chart);
+
+	Chart.defaults = __webpack_require__(6);
+	Chart.Element = __webpack_require__(18);
+	Chart.elements = __webpack_require__(19);
+	Chart.Interaction = __webpack_require__(24);
+	Chart.platform = __webpack_require__(25);
+
+	__webpack_require__(28)(Chart);
+	__webpack_require__(29)(Chart);
+	__webpack_require__(30)(Chart);
+	__webpack_require__(31)(Chart);
+	__webpack_require__(32)(Chart);
+	__webpack_require__(33)(Chart);
+	__webpack_require__(34)(Chart);
+	__webpack_require__(36)(Chart);
+
+	__webpack_require__(37)(Chart);
+	__webpack_require__(38)(Chart);
+	__webpack_require__(39)(Chart);
+	__webpack_require__(40)(Chart);
+	__webpack_require__(41)(Chart);
+	__webpack_require__(42)(Chart);
+
+	// Controllers must be loaded after elements
+	// See Chart.core.datasetController.dataElementType
+	__webpack_require__(161)(Chart);
+	__webpack_require__(162)(Chart);
+	__webpack_require__(163)(Chart);
+	__webpack_require__(164)(Chart);
+	__webpack_require__(165)(Chart);
+	__webpack_require__(166)(Chart);
+	__webpack_require__(167)(Chart);
+
+	__webpack_require__(168)(Chart);
+	__webpack_require__(169)(Chart);
+	__webpack_require__(170)(Chart);
+	__webpack_require__(171)(Chart);
+	__webpack_require__(172)(Chart);
+	__webpack_require__(173)(Chart);
+	__webpack_require__(174)(Chart);
+
+	// Loading built-it plugins
+	var plugins = [];
+
+	plugins.push(
+		__webpack_require__(175)(Chart),
+		__webpack_require__(176)(Chart),
+		__webpack_require__(177)(Chart)
+	);
+
+	Chart.plugins.register(plugins);
+
+	Chart.platform.initialize();
+
+	module.exports = Chart;
+	if (typeof window !== 'undefined') {
+		window.Chart = Chart;
+	}
+
+	// DEPRECATIONS
+
+	/**
+	 * Provided for backward compatibility, use Chart.helpers.canvas instead.
+	 * @namespace Chart.canvasHelpers
+	 * @deprecated since version 2.6.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	Chart.canvasHelpers = Chart.helpers.canvas;
+
+
+/***/ },
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+
+	defaults._set('global', {
+		responsive: true,
+		responsiveAnimationDuration: 0,
+		maintainAspectRatio: true,
+		events: ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove'],
+		hover: {
+			onHover: null,
+			mode: 'nearest',
+			intersect: true,
+			animationDuration: 400
+		},
+		onClick: null,
+		defaultColor: 'rgba(0,0,0,0.1)',
+		defaultFontColor: '#666',
+		defaultFontFamily: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
+		defaultFontSize: 12,
+		defaultFontStyle: 'normal',
+		showLines: true,
+
+		// Element defaults defined in element extensions
+		elements: {},
+
+		// Layout options such as padding
+		layout: {
+			padding: {
+				top: 0,
+				right: 0,
+				bottom: 0,
+				left: 0
+			}
+		}
+	});
+
+	module.exports = function() {
+
+		// Occupy the global variable of Chart, and create a simple base class
+		var Chart = function(item, config) {
+			this.construct(item, config);
+			return this;
+		};
+
+		Chart.Chart = Chart;
+
+		return Chart;
+	};
+
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+
+	module.exports = {
+		/**
+		 * @private
+		 */
+		_set: function(scope, values) {
+			return helpers.merge(this[scope] || (this[scope] = {}), values);
+		}
+	};
+
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(8);
+	module.exports.easing = __webpack_require__(9);
+	module.exports.canvas = __webpack_require__(10);
+	module.exports.options = __webpack_require__(11);
+
+
+/***/ },
+/* 8 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	/**
+	 * @namespace Chart.helpers
+	 */
+	var helpers = {
+		/**
+		 * An empty function that can be used, for example, for optional callback.
+		 */
+		noop: function() {},
+
+		/**
+		 * Returns a unique id, sequentially generated from a global variable.
+		 * @returns {Number}
+		 * @function
+		 */
+		uid: (function() {
+			var id = 0;
+			return function() {
+				return id++;
+			};
+		}()),
+
+		/**
+		 * Returns true if `value` is neither null nor undefined, else returns false.
+		 * @param {*} value - The value to test.
+		 * @returns {Boolean}
+		 * @since 2.7.0
+		 */
+		isNullOrUndef: function(value) {
+			return value === null || typeof value === 'undefined';
+		},
+
+		/**
+		 * Returns true if `value` is an array, else returns false.
+		 * @param {*} value - The value to test.
+		 * @returns {Boolean}
+		 * @function
+		 */
+		isArray: Array.isArray ? Array.isArray : function(value) {
+			return Object.prototype.toString.call(value) === '[object Array]';
+		},
+
+		/**
+		 * Returns true if `value` is an object (excluding null), else returns false.
+		 * @param {*} value - The value to test.
+		 * @returns {Boolean}
+		 * @since 2.7.0
+		 */
+		isObject: function(value) {
+			return value !== null && Object.prototype.toString.call(value) === '[object Object]';
+		},
+
+		/**
+		 * Returns `value` if defined, else returns `defaultValue`.
+		 * @param {*} value - The value to return if defined.
+		 * @param {*} defaultValue - The value to return if `value` is undefined.
+		 * @returns {*}
+		 */
+		valueOrDefault: function(value, defaultValue) {
+			return typeof value === 'undefined' ? defaultValue : value;
+		},
+
+		/**
+		 * Returns value at the given `index` in array if defined, else returns `defaultValue`.
+		 * @param {Array} value - The array to lookup for value at `index`.
+		 * @param {Number} index - The index in `value` to lookup for value.
+		 * @param {*} defaultValue - The value to return if `value[index]` is undefined.
+		 * @returns {*}
+		 */
+		valueAtIndexOrDefault: function(value, index, defaultValue) {
+			return helpers.valueOrDefault(helpers.isArray(value) ? value[index] : value, defaultValue);
+		},
+
+		/**
+		 * Calls `fn` with the given `args` in the scope defined by `thisArg` and returns the
+		 * value returned by `fn`. If `fn` is not a function, this method returns undefined.
+		 * @param {Function} fn - The function to call.
+		 * @param {Array|undefined|null} args - The arguments with which `fn` should be called.
+		 * @param {Object} [thisArg] - The value of `this` provided for the call to `fn`.
+		 * @returns {*}
+		 */
+		callback: function(fn, args, thisArg) {
+			if (fn && typeof fn.call === 'function') {
+				return fn.apply(thisArg, args);
+			}
+		},
+
+		/**
+		 * Note(SB) for performance sake, this method should only be used when loopable type
+		 * is unknown or in none intensive code (not called often and small loopable). Else
+		 * it's preferable to use a regular for() loop and save extra function calls.
+		 * @param {Object|Array} loopable - The object or array to be iterated.
+		 * @param {Function} fn - The function to call for each item.
+		 * @param {Object} [thisArg] - The value of `this` provided for the call to `fn`.
+		 * @param {Boolean} [reverse] - If true, iterates backward on the loopable.
+		 */
+		each: function(loopable, fn, thisArg, reverse) {
+			var i, len, keys;
+			if (helpers.isArray(loopable)) {
+				len = loopable.length;
+				if (reverse) {
+					for (i = len - 1; i >= 0; i--) {
+						fn.call(thisArg, loopable[i], i);
+					}
+				} else {
+					for (i = 0; i < len; i++) {
+						fn.call(thisArg, loopable[i], i);
+					}
+				}
+			} else if (helpers.isObject(loopable)) {
+				keys = Object.keys(loopable);
+				len = keys.length;
+				for (i = 0; i < len; i++) {
+					fn.call(thisArg, loopable[keys[i]], keys[i]);
+				}
+			}
+		},
+
+		/**
+		 * Returns true if the `a0` and `a1` arrays have the same content, else returns false.
+		 * @see http://stackoverflow.com/a/14853974
+		 * @param {Array} a0 - The array to compare
+		 * @param {Array} a1 - The array to compare
+		 * @returns {Boolean}
+		 */
+		arrayEquals: function(a0, a1) {
+			var i, ilen, v0, v1;
+
+			if (!a0 || !a1 || a0.length !== a1.length) {
+				return false;
+			}
+
+			for (i = 0, ilen = a0.length; i < ilen; ++i) {
+				v0 = a0[i];
+				v1 = a1[i];
+
+				if (v0 instanceof Array && v1 instanceof Array) {
+					if (!helpers.arrayEquals(v0, v1)) {
+						return false;
+					}
+				} else if (v0 !== v1) {
+					// NOTE: two different object instances will never be equal: {x:20} != {x:20}
+					return false;
+				}
+			}
+
+			return true;
+		},
+
+		/**
+		 * Returns a deep copy of `source` without keeping references on objects and arrays.
+		 * @param {*} source - The value to clone.
+		 * @returns {*}
+		 */
+		clone: function(source) {
+			if (helpers.isArray(source)) {
+				return source.map(helpers.clone);
+			}
+
+			if (helpers.isObject(source)) {
+				var target = {};
+				var keys = Object.keys(source);
+				var klen = keys.length;
+				var k = 0;
+
+				for (; k < klen; ++k) {
+					target[keys[k]] = helpers.clone(source[keys[k]]);
+				}
+
+				return target;
+			}
+
+			return source;
+		},
+
+		/**
+		 * The default merger when Chart.helpers.merge is called without merger option.
+		 * Note(SB): this method is also used by configMerge and scaleMerge as fallback.
+		 * @private
+		 */
+		_merger: function(key, target, source, options) {
+			var tval = target[key];
+			var sval = source[key];
+
+			if (helpers.isObject(tval) && helpers.isObject(sval)) {
+				helpers.merge(tval, sval, options);
+			} else {
+				target[key] = helpers.clone(sval);
+			}
+		},
+
+		/**
+		 * Merges source[key] in target[key] only if target[key] is undefined.
+		 * @private
+		 */
+		_mergerIf: function(key, target, source) {
+			var tval = target[key];
+			var sval = source[key];
+
+			if (helpers.isObject(tval) && helpers.isObject(sval)) {
+				helpers.mergeIf(tval, sval);
+			} else if (!target.hasOwnProperty(key)) {
+				target[key] = helpers.clone(sval);
+			}
+		},
+
+		/**
+		 * Recursively deep copies `source` properties into `target` with the given `options`.
+		 * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
+		 * @param {Object} target - The target object in which all sources are merged into.
+		 * @param {Object|Array(Object)} source - Object(s) to merge into `target`.
+		 * @param {Object} [options] - Merging options:
+		 * @param {Function} [options.merger] - The merge method (key, target, source, options)
+		 * @returns {Object} The `target` object.
+		 */
+		merge: function(target, source, options) {
+			var sources = helpers.isArray(source) ? source : [source];
+			var ilen = sources.length;
+			var merge, i, keys, klen, k;
+
+			if (!helpers.isObject(target)) {
+				return target;
+			}
+
+			options = options || {};
+			merge = options.merger || helpers._merger;
+
+			for (i = 0; i < ilen; ++i) {
+				source = sources[i];
+				if (!helpers.isObject(source)) {
+					continue;
+				}
+
+				keys = Object.keys(source);
+				for (k = 0, klen = keys.length; k < klen; ++k) {
+					merge(keys[k], target, source, options);
+				}
+			}
+
+			return target;
+		},
+
+		/**
+		 * Recursively deep copies `source` properties into `target` *only* if not defined in target.
+		 * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
+		 * @param {Object} target - The target object in which all sources are merged into.
+		 * @param {Object|Array(Object)} source - Object(s) to merge into `target`.
+		 * @returns {Object} The `target` object.
+		 */
+		mergeIf: function(target, source) {
+			return helpers.merge(target, source, {merger: helpers._mergerIf});
+		}
+	};
+
+	module.exports = helpers;
+
+	// DEPRECATIONS
+
+	/**
+	 * Provided for backward compatibility, use Chart.helpers.callback instead.
+	 * @function Chart.helpers.callCallback
+	 * @deprecated since version 2.6.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.callCallback = helpers.callback;
+
+	/**
+	 * Provided for backward compatibility, use Array.prototype.indexOf instead.
+	 * Array.prototype.indexOf compatibility: Chrome, Opera, Safari, FF1.5+, IE9+
+	 * @function Chart.helpers.indexOf
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.indexOf = function(array, item, fromIndex) {
+		return Array.prototype.indexOf.call(array, item, fromIndex);
+	};
+
+	/**
+	 * Provided for backward compatibility, use Chart.helpers.valueOrDefault instead.
+	 * @function Chart.helpers.getValueOrDefault
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.getValueOrDefault = helpers.valueOrDefault;
+
+	/**
+	 * Provided for backward compatibility, use Chart.helpers.valueAtIndexOrDefault instead.
+	 * @function Chart.helpers.getValueAtIndexOrDefault
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.getValueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
+
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(8);
+
+	/**
+	 * Easing functions adapted from Robert Penner's easing equations.
+	 * @namespace Chart.helpers.easingEffects
+	 * @see http://www.robertpenner.com/easing/
+	 */
+	var effects = {
+		linear: function(t) {
+			return t;
+		},
+
+		easeInQuad: function(t) {
+			return t * t;
+		},
+
+		easeOutQuad: function(t) {
+			return -t * (t - 2);
+		},
+
+		easeInOutQuad: function(t) {
+			if ((t /= 0.5) < 1) {
+				return 0.5 * t * t;
+			}
+			return -0.5 * ((--t) * (t - 2) - 1);
+		},
+
+		easeInCubic: function(t) {
+			return t * t * t;
+		},
+
+		easeOutCubic: function(t) {
+			return (t = t - 1) * t * t + 1;
+		},
+
+		easeInOutCubic: function(t) {
+			if ((t /= 0.5) < 1) {
+				return 0.5 * t * t * t;
+			}
+			return 0.5 * ((t -= 2) * t * t + 2);
+		},
+
+		easeInQuart: function(t) {
+			return t * t * t * t;
+		},
+
+		easeOutQuart: function(t) {
+			return -((t = t - 1) * t * t * t - 1);
+		},
+
+		easeInOutQuart: function(t) {
+			if ((t /= 0.5) < 1) {
+				return 0.5 * t * t * t * t;
+			}
+			return -0.5 * ((t -= 2) * t * t * t - 2);
+		},
+
+		easeInQuint: function(t) {
+			return t * t * t * t * t;
+		},
+
+		easeOutQuint: function(t) {
+			return (t = t - 1) * t * t * t * t + 1;
+		},
+
+		easeInOutQuint: function(t) {
+			if ((t /= 0.5) < 1) {
+				return 0.5 * t * t * t * t * t;
+			}
+			return 0.5 * ((t -= 2) * t * t * t * t + 2);
+		},
+
+		easeInSine: function(t) {
+			return -Math.cos(t * (Math.PI / 2)) + 1;
+		},
+
+		easeOutSine: function(t) {
+			return Math.sin(t * (Math.PI / 2));
+		},
+
+		easeInOutSine: function(t) {
+			return -0.5 * (Math.cos(Math.PI * t) - 1);
+		},
+
+		easeInExpo: function(t) {
+			return (t === 0) ? 0 : Math.pow(2, 10 * (t - 1));
+		},
+
+		easeOutExpo: function(t) {
+			return (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1;
+		},
+
+		easeInOutExpo: function(t) {
+			if (t === 0) {
+				return 0;
+			}
+			if (t === 1) {
+				return 1;
+			}
+			if ((t /= 0.5) < 1) {
+				return 0.5 * Math.pow(2, 10 * (t - 1));
+			}
+			return 0.5 * (-Math.pow(2, -10 * --t) + 2);
+		},
+
+		easeInCirc: function(t) {
+			if (t >= 1) {
+				return t;
+			}
+			return -(Math.sqrt(1 - t * t) - 1);
+		},
+
+		easeOutCirc: function(t) {
+			return Math.sqrt(1 - (t = t - 1) * t);
+		},
+
+		easeInOutCirc: function(t) {
+			if ((t /= 0.5) < 1) {
+				return -0.5 * (Math.sqrt(1 - t * t) - 1);
+			}
+			return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
+		},
+
+		easeInElastic: function(t) {
+			var s = 1.70158;
+			var p = 0;
+			var a = 1;
+			if (t === 0) {
+				return 0;
+			}
+			if (t === 1) {
+				return 1;
+			}
+			if (!p) {
+				p = 0.3;
+			}
+			if (a < 1) {
+				a = 1;
+				s = p / 4;
+			} else {
+				s = p / (2 * Math.PI) * Math.asin(1 / a);
+			}
+			return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p));
+		},
+
+		easeOutElastic: function(t) {
+			var s = 1.70158;
+			var p = 0;
+			var a = 1;
+			if (t === 0) {
+				return 0;
+			}
+			if (t === 1) {
+				return 1;
+			}
+			if (!p) {
+				p = 0.3;
+			}
+			if (a < 1) {
+				a = 1;
+				s = p / 4;
+			} else {
+				s = p / (2 * Math.PI) * Math.asin(1 / a);
+			}
+			return a * Math.pow(2, -10 * t) * Math.sin((t - s) * (2 * Math.PI) / p) + 1;
+		},
+
+		easeInOutElastic: function(t) {
+			var s = 1.70158;
+			var p = 0;
+			var a = 1;
+			if (t === 0) {
+				return 0;
+			}
+			if ((t /= 0.5) === 2) {
+				return 1;
+			}
+			if (!p) {
+				p = 0.45;
+			}
+			if (a < 1) {
+				a = 1;
+				s = p / 4;
+			} else {
+				s = p / (2 * Math.PI) * Math.asin(1 / a);
+			}
+			if (t < 1) {
+				return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p));
+			}
+			return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p) * 0.5 + 1;
+		},
+		easeInBack: function(t) {
+			var s = 1.70158;
+			return t * t * ((s + 1) * t - s);
+		},
+
+		easeOutBack: function(t) {
+			var s = 1.70158;
+			return (t = t - 1) * t * ((s + 1) * t + s) + 1;
+		},
+
+		easeInOutBack: function(t) {
+			var s = 1.70158;
+			if ((t /= 0.5) < 1) {
+				return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s));
+			}
+			return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2);
+		},
+
+		easeInBounce: function(t) {
+			return 1 - effects.easeOutBounce(1 - t);
+		},
+
+		easeOutBounce: function(t) {
+			if (t < (1 / 2.75)) {
+				return 7.5625 * t * t;
+			}
+			if (t < (2 / 2.75)) {
+				return 7.5625 * (t -= (1.5 / 2.75)) * t + 0.75;
+			}
+			if (t < (2.5 / 2.75)) {
+				return 7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375;
+			}
+			return 7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375;
+		},
+
+		easeInOutBounce: function(t) {
+			if (t < 0.5) {
+				return effects.easeInBounce(t * 2) * 0.5;
+			}
+			return effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5;
+		}
+	};
+
+	module.exports = {
+		effects: effects
+	};
+
+	// DEPRECATIONS
+
+	/**
+	 * Provided for backward compatibility, use Chart.helpers.easing.effects instead.
+	 * @function Chart.helpers.easingEffects
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.easingEffects = effects;
+
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(8);
+
+	/**
+	 * @namespace Chart.helpers.canvas
+	 */
+	var exports = module.exports = {
+		/**
+		 * Clears the entire canvas associated to the given `chart`.
+		 * @param {Chart} chart - The chart for which to clear the canvas.
+		 */
+		clear: function(chart) {
+			chart.ctx.clearRect(0, 0, chart.width, chart.height);
+		},
+
+		/**
+		 * Creates a "path" for a rectangle with rounded corners at position (x, y) with a
+		 * given size (width, height) and the same `radius` for all corners.
+		 * @param {CanvasRenderingContext2D} ctx - The canvas 2D Context.
+		 * @param {Number} x - The x axis of the coordinate for the rectangle starting point.
+		 * @param {Number} y - The y axis of the coordinate for the rectangle starting point.
+		 * @param {Number} width - The rectangle's width.
+		 * @param {Number} height - The rectangle's height.
+		 * @param {Number} radius - The rounded amount (in pixels) for the four corners.
+		 * @todo handle `radius` as top-left, top-right, bottom-right, bottom-left array/object?
+		 */
+		roundedRect: function(ctx, x, y, width, height, radius) {
+			if (radius) {
+				var rx = Math.min(radius, width / 2);
+				var ry = Math.min(radius, height / 2);
+
+				ctx.moveTo(x + rx, y);
+				ctx.lineTo(x + width - rx, y);
+				ctx.quadraticCurveTo(x + width, y, x + width, y + ry);
+				ctx.lineTo(x + width, y + height - ry);
+				ctx.quadraticCurveTo(x + width, y + height, x + width - rx, y + height);
+				ctx.lineTo(x + rx, y + height);
+				ctx.quadraticCurveTo(x, y + height, x, y + height - ry);
+				ctx.lineTo(x, y + ry);
+				ctx.quadraticCurveTo(x, y, x + rx, y);
+			} else {
+				ctx.rect(x, y, width, height);
+			}
+		},
+
+		drawPoint: function(ctx, style, radius, x, y) {
+			var type, edgeLength, xOffset, yOffset, height, size;
+
+			if (typeof style === 'object') {
+				type = style.toString();
+				if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {
+					ctx.drawImage(style, x - style.width / 2, y - style.height / 2, style.width, style.height);
+					return;
+				}
+			}
+
+			if (isNaN(radius) || radius <= 0) {
+				return;
+			}
+
+			switch (style) {
+			// Default includes circle
+			default:
+				ctx.beginPath();
+				ctx.arc(x, y, radius, 0, Math.PI * 2);
+				ctx.closePath();
+				ctx.fill();
+				break;
+			case 'triangle':
+				ctx.beginPath();
+				edgeLength = 3 * radius / Math.sqrt(3);
+				height = edgeLength * Math.sqrt(3) / 2;
+				ctx.moveTo(x - edgeLength / 2, y + height / 3);
+				ctx.lineTo(x + edgeLength / 2, y + height / 3);
+				ctx.lineTo(x, y - 2 * height / 3);
+				ctx.closePath();
+				ctx.fill();
+				break;
+			case 'rect':
+				size = 1 / Math.SQRT2 * radius;
+				ctx.beginPath();
+				ctx.fillRect(x - size, y - size, 2 * size, 2 * size);
+				ctx.strokeRect(x - size, y - size, 2 * size, 2 * size);
+				break;
+			case 'rectRounded':
+				var offset = radius / Math.SQRT2;
+				var leftX = x - offset;
+				var topY = y - offset;
+				var sideSize = Math.SQRT2 * radius;
+				ctx.beginPath();
+				this.roundedRect(ctx, leftX, topY, sideSize, sideSize, radius / 2);
+				ctx.closePath();
+				ctx.fill();
+				break;
+			case 'rectRot':
+				size = 1 / Math.SQRT2 * radius;
+				ctx.beginPath();
+				ctx.moveTo(x - size, y);
+				ctx.lineTo(x, y + size);
+				ctx.lineTo(x + size, y);
+				ctx.lineTo(x, y - size);
+				ctx.closePath();
+				ctx.fill();
+				break;
+			case 'cross':
+				ctx.beginPath();
+				ctx.moveTo(x, y + radius);
+				ctx.lineTo(x, y - radius);
+				ctx.moveTo(x - radius, y);
+				ctx.lineTo(x + radius, y);
+				ctx.closePath();
+				break;
+			case 'crossRot':
+				ctx.beginPath();
+				xOffset = Math.cos(Math.PI / 4) * radius;
+				yOffset = Math.sin(Math.PI / 4) * radius;
+				ctx.moveTo(x - xOffset, y - yOffset);
+				ctx.lineTo(x + xOffset, y + yOffset);
+				ctx.moveTo(x - xOffset, y + yOffset);
+				ctx.lineTo(x + xOffset, y - yOffset);
+				ctx.closePath();
+				break;
+			case 'star':
+				ctx.beginPath();
+				ctx.moveTo(x, y + radius);
+				ctx.lineTo(x, y - radius);
+				ctx.moveTo(x - radius, y);
+				ctx.lineTo(x + radius, y);
+				xOffset = Math.cos(Math.PI / 4) * radius;
+				yOffset = Math.sin(Math.PI / 4) * radius;
+				ctx.moveTo(x - xOffset, y - yOffset);
+				ctx.lineTo(x + xOffset, y + yOffset);
+				ctx.moveTo(x - xOffset, y + yOffset);
+				ctx.lineTo(x + xOffset, y - yOffset);
+				ctx.closePath();
+				break;
+			case 'line':
+				ctx.beginPath();
+				ctx.moveTo(x - radius, y);
+				ctx.lineTo(x + radius, y);
+				ctx.closePath();
+				break;
+			case 'dash':
+				ctx.beginPath();
+				ctx.moveTo(x, y);
+				ctx.lineTo(x + radius, y);
+				ctx.closePath();
+				break;
+			}
+
+			ctx.stroke();
+		},
+
+		clipArea: function(ctx, area) {
+			ctx.save();
+			ctx.beginPath();
+			ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
+			ctx.clip();
+		},
+
+		unclipArea: function(ctx) {
+			ctx.restore();
+		},
+
+		lineTo: function(ctx, previous, target, flip) {
+			if (target.steppedLine) {
+				if ((target.steppedLine === 'after' && !flip) || (target.steppedLine !== 'after' && flip)) {
+					ctx.lineTo(previous.x, target.y);
+				} else {
+					ctx.lineTo(target.x, previous.y);
+				}
+				ctx.lineTo(target.x, target.y);
+				return;
+			}
+
+			if (!target.tension) {
+				ctx.lineTo(target.x, target.y);
+				return;
+			}
+
+			ctx.bezierCurveTo(
+				flip ? previous.controlPointPreviousX : previous.controlPointNextX,
+				flip ? previous.controlPointPreviousY : previous.controlPointNextY,
+				flip ? target.controlPointNextX : target.controlPointPreviousX,
+				flip ? target.controlPointNextY : target.controlPointPreviousY,
+				target.x,
+				target.y);
+		}
+	};
+
+	// DEPRECATIONS
+
+	/**
+	 * Provided for backward compatibility, use Chart.helpers.canvas.clear instead.
+	 * @namespace Chart.helpers.clear
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.clear = exports.clear;
+
+	/**
+	 * Provided for backward compatibility, use Chart.helpers.canvas.roundedRect instead.
+	 * @namespace Chart.helpers.drawRoundedRectangle
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.drawRoundedRectangle = function(ctx) {
+		ctx.beginPath();
+		exports.roundedRect.apply(exports, arguments);
+		ctx.closePath();
+	};
+
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(8);
+
+	/**
+	 * @alias Chart.helpers.options
+	 * @namespace
+	 */
+	module.exports = {
+		/**
+		 * Converts the given line height `value` in pixels for a specific font `size`.
+		 * @param {Number|String} value - The lineHeight to parse (eg. 1.6, '14px', '75%', '1.6em').
+		 * @param {Number} size - The font size (in pixels) used to resolve relative `value`.
+		 * @returns {Number} The effective line height in pixels (size * 1.2 if value is invalid).
+		 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-height
+		 * @since 2.7.0
+		 */
+		toLineHeight: function(value, size) {
+			var matches = ('' + value).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);
+			if (!matches || matches[1] === 'normal') {
+				return size * 1.2;
+			}
+
+			value = +matches[2];
+
+			switch (matches[3]) {
+			case 'px':
+				return value;
+			case '%':
+				value /= 100;
+				break;
+			default:
+				break;
+			}
+
+			return size * value;
+		},
+
+		/**
+		 * Converts the given value into a padding object with pre-computed width/height.
+		 * @param {Number|Object} value - If a number, set the value to all TRBL component,
+		 *  else, if and object, use defined properties and sets undefined ones to 0.
+		 * @returns {Object} The padding values (top, right, bottom, left, width, height)
+		 * @since 2.7.0
+		 */
+		toPadding: function(value) {
+			var t, r, b, l;
+
+			if (helpers.isObject(value)) {
+				t = +value.top || 0;
+				r = +value.right || 0;
+				b = +value.bottom || 0;
+				l = +value.left || 0;
+			} else {
+				t = r = b = l = +value || 0;
+			}
+
+			return {
+				top: t,
+				right: r,
+				bottom: b,
+				left: l,
+				height: t + b,
+				width: l + r
+			};
+		},
+
+		/**
+		 * Evaluates the given `inputs` sequentially and returns the first defined value.
+		 * @param {Array[]} inputs - An array of values, falling back to the last value.
+		 * @param {Object} [context] - If defined and the current value is a function, the value
+		 * is called with `context` as first argument and the result becomes the new input.
+		 * @param {Number} [index] - If defined and the current value is an array, the value
+		 * at `index` become the new input.
+		 * @since 2.7.0
+		 */
+		resolve: function(inputs, context, index) {
+			var i, ilen, value;
+
+			for (i = 0, ilen = inputs.length; i < ilen; ++i) {
+				value = inputs[i];
+				if (value === undefined) {
+					continue;
+				}
+				if (context !== undefined && typeof value === 'function') {
+					value = value(context);
+				}
+				if (index !== undefined && helpers.isArray(value)) {
+					value = value[index];
+				}
+				if (value !== undefined) {
+					return value;
+				}
+			}
+		}
+	};
+
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* global window: false */
+	/* global document: false */
+	'use strict';
+
+	var color = __webpack_require__(13);
+	var defaults = __webpack_require__(6);
+	var helpers = __webpack_require__(7);
+
+	module.exports = function(Chart) {
+
+		// -- Basic js utility methods
+
+		helpers.extend = function(base) {
+			var setFn = function(value, key) {
+				base[key] = value;
+			};
+			for (var i = 1, ilen = arguments.length; i < ilen; i++) {
+				helpers.each(arguments[i], setFn);
+			}
+			return base;
+		};
+
+		helpers.configMerge = function(/* objects ... */) {
+			return helpers.merge(helpers.clone(arguments[0]), [].slice.call(arguments, 1), {
+				merger: function(key, target, source, options) {
+					var tval = target[key] || {};
+					var sval = source[key];
+
+					if (key === 'scales') {
+						// scale config merging is complex. Add our own function here for that
+						target[key] = helpers.scaleMerge(tval, sval);
+					} else if (key === 'scale') {
+						// used in polar area & radar charts since there is only one scale
+						target[key] = helpers.merge(tval, [Chart.scaleService.getScaleDefaults(sval.type), sval]);
+					} else {
+						helpers._merger(key, target, source, options);
+					}
+				}
+			});
+		};
+
+		helpers.scaleMerge = function(/* objects ... */) {
+			return helpers.merge(helpers.clone(arguments[0]), [].slice.call(arguments, 1), {
+				merger: function(key, target, source, options) {
+					if (key === 'xAxes' || key === 'yAxes') {
+						var slen = source[key].length;
+						var i, type, scale;
+
+						if (!target[key]) {
+							target[key] = [];
+						}
+
+						for (i = 0; i < slen; ++i) {
+							scale = source[key][i];
+							type = helpers.valueOrDefault(scale.type, key === 'xAxes' ? 'category' : 'linear');
+
+							if (i >= target[key].length) {
+								target[key].push({});
+							}
+
+							if (!target[key][i].type || (scale.type && scale.type !== target[key][i].type)) {
+								// new/untyped scale or type changed: let's apply the new defaults
+								// then merge source scale to correctly overwrite the defaults.
+								helpers.merge(target[key][i], [Chart.scaleService.getScaleDefaults(type), scale]);
+							} else {
+								// scales type are the same
+								helpers.merge(target[key][i], scale);
+							}
+						}
+					} else {
+						helpers._merger(key, target, source, options);
+					}
+				}
+			});
+		};
+
+		helpers.where = function(collection, filterCallback) {
+			if (helpers.isArray(collection) && Array.prototype.filter) {
+				return collection.filter(filterCallback);
+			}
+			var filtered = [];
+
+			helpers.each(collection, function(item) {
+				if (filterCallback(item)) {
+					filtered.push(item);
+				}
+			});
+
+			return filtered;
+		};
+		helpers.findIndex = Array.prototype.findIndex ?
+			function(array, callback, scope) {
+				return array.findIndex(callback, scope);
+			} :
+			function(array, callback, scope) {
+				scope = scope === undefined ? array : scope;
+				for (var i = 0, ilen = array.length; i < ilen; ++i) {
+					if (callback.call(scope, array[i], i, array)) {
+						return i;
+					}
+				}
+				return -1;
+			};
+		helpers.findNextWhere = function(arrayToSearch, filterCallback, startIndex) {
+			// Default to start of the array
+			if (helpers.isNullOrUndef(startIndex)) {
+				startIndex = -1;
+			}
+			for (var i = startIndex + 1; i < arrayToSearch.length; i++) {
+				var currentItem = arrayToSearch[i];
+				if (filterCallback(currentItem)) {
+					return currentItem;
+				}
+			}
+		};
+		helpers.findPreviousWhere = function(arrayToSearch, filterCallback, startIndex) {
+			// Default to end of the array
+			if (helpers.isNullOrUndef(startIndex)) {
+				startIndex = arrayToSearch.length;
+			}
+			for (var i = startIndex - 1; i >= 0; i--) {
+				var currentItem = arrayToSearch[i];
+				if (filterCallback(currentItem)) {
+					return currentItem;
+				}
+			}
+		};
+		helpers.inherits = function(extensions) {
+			// Basic javascript inheritance based on the model created in Backbone.js
+			var me = this;
+			var ChartElement = (extensions && extensions.hasOwnProperty('constructor')) ? extensions.constructor : function() {
+				return me.apply(this, arguments);
+			};
+
+			var Surrogate = function() {
+				this.constructor = ChartElement;
+			};
+			Surrogate.prototype = me.prototype;
+			ChartElement.prototype = new Surrogate();
+
+			ChartElement.extend = helpers.inherits;
+
+			if (extensions) {
+				helpers.extend(ChartElement.prototype, extensions);
+			}
+
+			ChartElement.__super__ = me.prototype;
+
+			return ChartElement;
+		};
+		// -- Math methods
+		helpers.isNumber = function(n) {
+			return !isNaN(parseFloat(n)) && isFinite(n);
+		};
+		helpers.almostEquals = function(x, y, epsilon) {
+			return Math.abs(x - y) < epsilon;
+		};
+		helpers.almostWhole = function(x, epsilon) {
+			var rounded = Math.round(x);
+			return (((rounded - epsilon) < x) && ((rounded + epsilon) > x));
+		};
+		helpers.max = function(array) {
+			return array.reduce(function(max, value) {
+				if (!isNaN(value)) {
+					return Math.max(max, value);
+				}
+				return max;
+			}, Number.NEGATIVE_INFINITY);
+		};
+		helpers.min = function(array) {
+			return array.reduce(function(min, value) {
+				if (!isNaN(value)) {
+					return Math.min(min, value);
+				}
+				return min;
+			}, Number.POSITIVE_INFINITY);
+		};
+		helpers.sign = Math.sign ?
+			function(x) {
+				return Math.sign(x);
+			} :
+			function(x) {
+				x = +x; // convert to a number
+				if (x === 0 || isNaN(x)) {
+					return x;
+				}
+				return x > 0 ? 1 : -1;
+			};
+		helpers.log10 = Math.log10 ?
+			function(x) {
+				return Math.log10(x);
+			} :
+			function(x) {
+				return Math.log(x) / Math.LN10;
+			};
+		helpers.toRadians = function(degrees) {
+			return degrees * (Math.PI / 180);
+		};
+		helpers.toDegrees = function(radians) {
+			return radians * (180 / Math.PI);
+		};
+		// Gets the angle from vertical upright to the point about a centre.
+		helpers.getAngleFromPoint = function(centrePoint, anglePoint) {
+			var distanceFromXCenter = anglePoint.x - centrePoint.x;
+			var distanceFromYCenter = anglePoint.y - centrePoint.y;
+			var radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
+
+			var angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
+
+			if (angle < (-0.5 * Math.PI)) {
+				angle += 2.0 * Math.PI; // make sure the returned angle is in the range of (-PI/2, 3PI/2]
+			}
+
+			return {
+				angle: angle,
+				distance: radialDistanceFromCenter
+			};
+		};
+		helpers.distanceBetweenPoints = function(pt1, pt2) {
+			return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
+		};
+		helpers.aliasPixel = function(pixelWidth) {
+			return (pixelWidth % 2 === 0) ? 0 : 0.5;
+		};
+		helpers.splineCurve = function(firstPoint, middlePoint, afterPoint, t) {
+			// Props to Rob Spencer at scaled innovation for his post on splining between points
+			// http://scaledinnovation.com/analytics/splines/aboutSplines.html
+
+			// This function must also respect "skipped" points
+
+			var previous = firstPoint.skip ? middlePoint : firstPoint;
+			var current = middlePoint;
+			var next = afterPoint.skip ? middlePoint : afterPoint;
+
+			var d01 = Math.sqrt(Math.pow(current.x - previous.x, 2) + Math.pow(current.y - previous.y, 2));
+			var d12 = Math.sqrt(Math.pow(next.x - current.x, 2) + Math.pow(next.y - current.y, 2));
+
+			var s01 = d01 / (d01 + d12);
+			var s12 = d12 / (d01 + d12);
+
+			// If all points are the same, s01 & s02 will be inf
+			s01 = isNaN(s01) ? 0 : s01;
+			s12 = isNaN(s12) ? 0 : s12;
+
+			var fa = t * s01; // scaling factor for triangle Ta
+			var fb = t * s12;
+
+			return {
+				previous: {
+					x: current.x - fa * (next.x - previous.x),
+					y: current.y - fa * (next.y - previous.y)
+				},
+				next: {
+					x: current.x + fb * (next.x - previous.x),
+					y: current.y + fb * (next.y - previous.y)
+				}
+			};
+		};
+		helpers.EPSILON = Number.EPSILON || 1e-14;
+		helpers.splineCurveMonotone = function(points) {
+			// This function calculates Bézier control points in a similar way than |splineCurve|,
+			// but preserves monotonicity of the provided data and ensures no local extremums are added
+			// between the dataset discrete points due to the interpolation.
+			// See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation
+
+			var pointsWithTangents = (points || []).map(function(point) {
+				return {
+					model: point._model,
+					deltaK: 0,
+					mK: 0
+				};
+			});
+
+			// Calculate slopes (deltaK) and initialize tangents (mK)
+			var pointsLen = pointsWithTangents.length;
+			var i, pointBefore, pointCurrent, pointAfter;
+			for (i = 0; i < pointsLen; ++i) {
+				pointCurrent = pointsWithTangents[i];
+				if (pointCurrent.model.skip) {
+					continue;
+				}
+
+				pointBefore = i > 0 ? pointsWithTangents[i - 1] : null;
+				pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null;
+				if (pointAfter && !pointAfter.model.skip) {
+					var slopeDeltaX = (pointAfter.model.x - pointCurrent.model.x);
+
+					// In the case of two points that appear at the same x pixel, slopeDeltaX is 0
+					pointCurrent.deltaK = slopeDeltaX !== 0 ? (pointAfter.model.y - pointCurrent.model.y) / slopeDeltaX : 0;
+				}
+
+				if (!pointBefore || pointBefore.model.skip) {
+					pointCurrent.mK = pointCurrent.deltaK;
+				} else if (!pointAfter || pointAfter.model.skip) {
+					pointCurrent.mK = pointBefore.deltaK;
+				} else if (this.sign(pointBefore.deltaK) !== this.sign(pointCurrent.deltaK)) {
+					pointCurrent.mK = 0;
+				} else {
+					pointCurrent.mK = (pointBefore.deltaK + pointCurrent.deltaK) / 2;
+				}
+			}
+
+			// Adjust tangents to ensure monotonic properties
+			var alphaK, betaK, tauK, squaredMagnitude;
+			for (i = 0; i < pointsLen - 1; ++i) {
+				pointCurrent = pointsWithTangents[i];
+				pointAfter = pointsWithTangents[i + 1];
+				if (pointCurrent.model.skip || pointAfter.model.skip) {
+					continue;
+				}
+
+				if (helpers.almostEquals(pointCurrent.deltaK, 0, this.EPSILON)) {
+					pointCurrent.mK = pointAfter.mK = 0;
+					continue;
+				}
+
+				alphaK = pointCurrent.mK / pointCurrent.deltaK;
+				betaK = pointAfter.mK / pointCurrent.deltaK;
+				squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);
+				if (squaredMagnitude <= 9) {
+					continue;
+				}
+
+				tauK = 3 / Math.sqrt(squaredMagnitude);
+				pointCurrent.mK = alphaK * tauK * pointCurrent.deltaK;
+				pointAfter.mK = betaK * tauK * pointCurrent.deltaK;
+			}
+
+			// Compute control points
+			var deltaX;
+			for (i = 0; i < pointsLen; ++i) {
+				pointCurrent = pointsWithTangents[i];
+				if (pointCurrent.model.skip) {
+					continue;
+				}
+
+				pointBefore = i > 0 ? pointsWithTangents[i - 1] : null;
+				pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null;
+				if (pointBefore && !pointBefore.model.skip) {
+					deltaX = (pointCurrent.model.x - pointBefore.model.x) / 3;
+					pointCurrent.model.controlPointPreviousX = pointCurrent.model.x - deltaX;
+					pointCurrent.model.controlPointPreviousY = pointCurrent.model.y - deltaX * pointCurrent.mK;
+				}
+				if (pointAfter && !pointAfter.model.skip) {
+					deltaX = (pointAfter.model.x - pointCurrent.model.x) / 3;
+					pointCurrent.model.controlPointNextX = pointCurrent.model.x + deltaX;
+					pointCurrent.model.controlPointNextY = pointCurrent.model.y + deltaX * pointCurrent.mK;
+				}
+			}
+		};
+		helpers.nextItem = function(collection, index, loop) {
+			if (loop) {
+				return index >= collection.length - 1 ? collection[0] : collection[index + 1];
+			}
+			return index >= collection.length - 1 ? collection[collection.length - 1] : collection[index + 1];
+		};
+		helpers.previousItem = function(collection, index, loop) {
+			if (loop) {
+				return index <= 0 ? collection[collection.length - 1] : collection[index - 1];
+			}
+			return index <= 0 ? collection[0] : collection[index - 1];
+		};
+		// Implementation of the nice number algorithm used in determining where axis labels will go
+		helpers.niceNum = function(range, round) {
+			var exponent = Math.floor(helpers.log10(range));
+			var fraction = range / Math.pow(10, exponent);
+			var niceFraction;
+
+			if (round) {
+				if (fraction < 1.5) {
+					niceFraction = 1;
+				} else if (fraction < 3) {
+					niceFraction = 2;
+				} else if (fraction < 7) {
+					niceFraction = 5;
+				} else {
+					niceFraction = 10;
+				}
+			} else if (fraction <= 1.0) {
+				niceFraction = 1;
+			} else if (fraction <= 2) {
+				niceFraction = 2;
+			} else if (fraction <= 5) {
+				niceFraction = 5;
+			} else {
+				niceFraction = 10;
+			}
+
+			return niceFraction * Math.pow(10, exponent);
+		};
+		// Request animation polyfill - http://www.paulirish.com/2011/requestanimationframe-for-smart-animating/
+		helpers.requestAnimFrame = (function() {
+			if (typeof window === 'undefined') {
+				return function(callback) {
+					callback();
+				};
+			}
+			return window.requestAnimationFrame ||
+				window.webkitRequestAnimationFrame ||
+				window.mozRequestAnimationFrame ||
+				window.oRequestAnimationFrame ||
+				window.msRequestAnimationFrame ||
+				function(callback) {
+					return window.setTimeout(callback, 1000 / 60);
+				};
+		}());
+		// -- DOM methods
+		helpers.getRelativePosition = function(evt, chart) {
+			var mouseX, mouseY;
+			var e = evt.originalEvent || evt;
+			var canvas = evt.currentTarget || evt.srcElement;
+			var boundingRect = canvas.getBoundingClientRect();
+
+			var touches = e.touches;
+			if (touches && touches.length > 0) {
+				mouseX = touches[0].clientX;
+				mouseY = touches[0].clientY;
+
+			} else {
+				mouseX = e.clientX;
+				mouseY = e.clientY;
+			}
+
+			// Scale mouse coordinates into canvas coordinates
+			// by following the pattern laid out by 'jerryj' in the comments of
+			// http://www.html5canvastutorials.com/advanced/html5-canvas-mouse-coordinates/
+			var paddingLeft = parseFloat(helpers.getStyle(canvas, 'padding-left'));
+			var paddingTop = parseFloat(helpers.getStyle(canvas, 'padding-top'));
+			var paddingRight = parseFloat(helpers.getStyle(canvas, 'padding-right'));
+			var paddingBottom = parseFloat(helpers.getStyle(canvas, 'padding-bottom'));
+			var width = boundingRect.right - boundingRect.left - paddingLeft - paddingRight;
+			var height = boundingRect.bottom - boundingRect.top - paddingTop - paddingBottom;
+
+			// We divide by the current device pixel ratio, because the canvas is scaled up by that amount in each direction. However
+			// the backend model is in unscaled coordinates. Since we are going to deal with our model coordinates, we go back here
+			mouseX = Math.round((mouseX - boundingRect.left - paddingLeft) / (width) * canvas.width / chart.currentDevicePixelRatio);
+			mouseY = Math.round((mouseY - boundingRect.top - paddingTop) / (height) * canvas.height / chart.currentDevicePixelRatio);
+
+			return {
+				x: mouseX,
+				y: mouseY
+			};
+
+		};
+
+		// Private helper function to convert max-width/max-height values that may be percentages into a number
+		function parseMaxStyle(styleValue, node, parentProperty) {
+			var valueInPixels;
+			if (typeof styleValue === 'string') {
+				valueInPixels = parseInt(styleValue, 10);
+
+				if (styleValue.indexOf('%') !== -1) {
+					// percentage * size in dimension
+					valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
+				}
+			} else {
+				valueInPixels = styleValue;
+			}
+
+			return valueInPixels;
+		}
+
+		/**
+		 * Returns if the given value contains an effective constraint.
+		 * @private
+		 */
+		function isConstrainedValue(value) {
+			return value !== undefined && value !== null && value !== 'none';
+		}
+
+		// Private helper to get a constraint dimension
+		// @param domNode : the node to check the constraint on
+		// @param maxStyle : the style that defines the maximum for the direction we are using (maxWidth / maxHeight)
+		// @param percentageProperty : property of parent to use when calculating width as a percentage
+		// @see http://www.nathanaeljones.com/blog/2013/reading-max-width-cross-browser
+		function getConstraintDimension(domNode, maxStyle, percentageProperty) {
+			var view = document.defaultView;
+			var parentNode = domNode.parentNode;
+			var constrainedNode = view.getComputedStyle(domNode)[maxStyle];
+			var constrainedContainer = view.getComputedStyle(parentNode)[maxStyle];
+			var hasCNode = isConstrainedValue(constrainedNode);
+			var hasCContainer = isConstrainedValue(constrainedContainer);
+			var infinity = Number.POSITIVE_INFINITY;
+
+			if (hasCNode || hasCContainer) {
+				return Math.min(
+					hasCNode ? parseMaxStyle(constrainedNode, domNode, percentageProperty) : infinity,
+					hasCContainer ? parseMaxStyle(constrainedContainer, parentNode, percentageProperty) : infinity);
+			}
+
+			return 'none';
+		}
+		// returns Number or undefined if no constraint
+		helpers.getConstraintWidth = function(domNode) {
+			return getConstraintDimension(domNode, 'max-width', 'clientWidth');
+		};
+		// returns Number or undefined if no constraint
+		helpers.getConstraintHeight = function(domNode) {
+			return getConstraintDimension(domNode, 'max-height', 'clientHeight');
+		};
+		helpers.getMaximumWidth = function(domNode) {
+			var container = domNode.parentNode;
+			if (!container) {
+				return domNode.clientWidth;
+			}
+
+			var paddingLeft = parseInt(helpers.getStyle(container, 'padding-left'), 10);
+			var paddingRight = parseInt(helpers.getStyle(container, 'padding-right'), 10);
+			var w = container.clientWidth - paddingLeft - paddingRight;
+			var cw = helpers.getConstraintWidth(domNode);
+			return isNaN(cw) ? w : Math.min(w, cw);
+		};
+		helpers.getMaximumHeight = function(domNode) {
+			var container = domNode.parentNode;
+			if (!container) {
+				return domNode.clientHeight;
+			}
+
+			var paddingTop = parseInt(helpers.getStyle(container, 'padding-top'), 10);
+			var paddingBottom = parseInt(helpers.getStyle(container, 'padding-bottom'), 10);
+			var h = container.clientHeight - paddingTop - paddingBottom;
+			var ch = helpers.getConstraintHeight(domNode);
+			return isNaN(ch) ? h : Math.min(h, ch);
+		};
+		helpers.getStyle = function(el, property) {
+			return el.currentStyle ?
+				el.currentStyle[property] :
+				document.defaultView.getComputedStyle(el, null).getPropertyValue(property);
+		};
+		helpers.retinaScale = function(chart, forceRatio) {
+			var pixelRatio = chart.currentDevicePixelRatio = forceRatio || window.devicePixelRatio || 1;
+			if (pixelRatio === 1) {
+				return;
+			}
+
+			var canvas = chart.canvas;
+			var height = chart.height;
+			var width = chart.width;
+
+			canvas.height = height * pixelRatio;
+			canvas.width = width * pixelRatio;
+			chart.ctx.scale(pixelRatio, pixelRatio);
+
+			// If no style has been set on the canvas, the render size is used as display size,
+			// making the chart visually bigger, so let's enforce it to the "correct" values.
+			// See https://github.com/chartjs/Chart.js/issues/3575
+			canvas.style.height = height + 'px';
+			canvas.style.width = width + 'px';
+		};
+		// -- Canvas methods
+		helpers.fontString = function(pixelSize, fontStyle, fontFamily) {
+			return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;
+		};
+		helpers.longestText = function(ctx, font, arrayOfThings, cache) {
+			cache = cache || {};
+			var data = cache.data = cache.data || {};
+			var gc = cache.garbageCollect = cache.garbageCollect || [];
+
+			if (cache.font !== font) {
+				data = cache.data = {};
+				gc = cache.garbageCollect = [];
+				cache.font = font;
+			}
+
+			ctx.font = font;
+			var longest = 0;
+			helpers.each(arrayOfThings, function(thing) {
+				// Undefined strings and arrays should not be measured
+				if (thing !== undefined && thing !== null && helpers.isArray(thing) !== true) {
+					longest = helpers.measureText(ctx, data, gc, longest, thing);
+				} else if (helpers.isArray(thing)) {
+					// if it is an array lets measure each element
+					// to do maybe simplify this function a bit so we can do this more recursively?
+					helpers.each(thing, function(nestedThing) {
+						// Undefined strings and arrays should not be measured
+						if (nestedThing !== undefined && nestedThing !== null && !helpers.isArray(nestedThing)) {
+							longest = helpers.measureText(ctx, data, gc, longest, nestedThing);
+						}
+					});
+				}
+			});
+
+			var gcLen = gc.length / 2;
+			if (gcLen > arrayOfThings.length) {
+				for (var i = 0; i < gcLen; i++) {
+					delete data[gc[i]];
+				}
+				gc.splice(0, gcLen);
+			}
+			return longest;
+		};
+		helpers.measureText = function(ctx, data, gc, longest, string) {
+			var textWidth = data[string];
+			if (!textWidth) {
+				textWidth = data[string] = ctx.measureText(string).width;
+				gc.push(string);
+			}
+			if (textWidth > longest) {
+				longest = textWidth;
+			}
+			return longest;
+		};
+		helpers.numberOfLabelLines = function(arrayOfThings) {
+			var numberOfLines = 1;
+			helpers.each(arrayOfThings, function(thing) {
+				if (helpers.isArray(thing)) {
+					if (thing.length > numberOfLines) {
+						numberOfLines = thing.length;
+					}
+				}
+			});
+			return numberOfLines;
+		};
+
+		helpers.color = !color ?
+			function(value) {
+				console.error('Color.js not found!');
+				return value;
+			} :
+			function(value) {
+				/* global CanvasGradient */
+				if (value instanceof CanvasGradient) {
+					value = defaults.global.defaultColor;
+				}
+
+				return color(value);
+			};
+
+		helpers.getHoverColor = function(colorValue) {
+			/* global CanvasPattern */
+			return (colorValue instanceof CanvasPattern) ?
+				colorValue :
+				helpers.color(colorValue).saturate(0.5).darken(0.1).rgbString();
+		};
+	};
+
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* MIT license */
+	var convert = __webpack_require__(14);
+	var string = __webpack_require__(16);
+
+	var Color = function (obj) {
+		if (obj instanceof Color) {
+			return obj;
+		}
+		if (!(this instanceof Color)) {
+			return new Color(obj);
+		}
+
+		this.valid = false;
+		this.values = {
+			rgb: [0, 0, 0],
+			hsl: [0, 0, 0],
+			hsv: [0, 0, 0],
+			hwb: [0, 0, 0],
+			cmyk: [0, 0, 0, 0],
+			alpha: 1
+		};
+
+		// parse Color() argument
+		var vals;
+		if (typeof obj === 'string') {
+			vals = string.getRgba(obj);
+			if (vals) {
+				this.setValues('rgb', vals);
+			} else if (vals = string.getHsla(obj)) {
+				this.setValues('hsl', vals);
+			} else if (vals = string.getHwb(obj)) {
+				this.setValues('hwb', vals);
+			}
+		} else if (typeof obj === 'object') {
+			vals = obj;
+			if (vals.r !== undefined || vals.red !== undefined) {
+				this.setValues('rgb', vals);
+			} else if (vals.l !== undefined || vals.lightness !== undefined) {
+				this.setValues('hsl', vals);
+			} else if (vals.v !== undefined || vals.value !== undefined) {
+				this.setValues('hsv', vals);
+			} else if (vals.w !== undefined || vals.whiteness !== undefined) {
+				this.setValues('hwb', vals);
+			} else if (vals.c !== undefined || vals.cyan !== undefined) {
+				this.setValues('cmyk', vals);
+			}
+		}
+	};
+
+	Color.prototype = {
+		isValid: function () {
+			return this.valid;
+		},
+		rgb: function () {
+			return this.setSpace('rgb', arguments);
+		},
+		hsl: function () {
+			return this.setSpace('hsl', arguments);
+		},
+		hsv: function () {
+			return this.setSpace('hsv', arguments);
+		},
+		hwb: function () {
+			return this.setSpace('hwb', arguments);
+		},
+		cmyk: function () {
+			return this.setSpace('cmyk', arguments);
+		},
+
+		rgbArray: function () {
+			return this.values.rgb;
+		},
+		hslArray: function () {
+			return this.values.hsl;
+		},
+		hsvArray: function () {
+			return this.values.hsv;
+		},
+		hwbArray: function () {
+			var values = this.values;
+			if (values.alpha !== 1) {
+				return values.hwb.concat([values.alpha]);
+			}
+			return values.hwb;
+		},
+		cmykArray: function () {
+			return this.values.cmyk;
+		},
+		rgbaArray: function () {
+			var values = this.values;
+			return values.rgb.concat([values.alpha]);
+		},
+		hslaArray: function () {
+			var values = this.values;
+			return values.hsl.concat([values.alpha]);
+		},
+		alpha: function (val) {
+			if (val === undefined) {
+				return this.values.alpha;
+			}
+			this.setValues('alpha', val);
+			return this;
+		},
+
+		red: function (val) {
+			return this.setChannel('rgb', 0, val);
+		},
+		green: function (val) {
+			return this.setChannel('rgb', 1, val);
+		},
+		blue: function (val) {
+			return this.setChannel('rgb', 2, val);
+		},
+		hue: function (val) {
+			if (val) {
+				val %= 360;
+				val = val < 0 ? 360 + val : val;
+			}
+			return this.setChannel('hsl', 0, val);
+		},
+		saturation: function (val) {
+			return this.setChannel('hsl', 1, val);
+		},
+		lightness: function (val) {
+			return this.setChannel('hsl', 2, val);
+		},
+		saturationv: function (val) {
+			return this.setChannel('hsv', 1, val);
+		},
+		whiteness: function (val) {
+			return this.setChannel('hwb', 1, val);
+		},
+		blackness: function (val) {
+			return this.setChannel('hwb', 2, val);
+		},
+		value: function (val) {
+			return this.setChannel('hsv', 2, val);
+		},
+		cyan: function (val) {
+			return this.setChannel('cmyk', 0, val);
+		},
+		magenta: function (val) {
+			return this.setChannel('cmyk', 1, val);
+		},
+		yellow: function (val) {
+			return this.setChannel('cmyk', 2, val);
+		},
+		black: function (val) {
+			return this.setChannel('cmyk', 3, val);
+		},
+
+		hexString: function () {
+			return string.hexString(this.values.rgb);
+		},
+		rgbString: function () {
+			return string.rgbString(this.values.rgb, this.values.alpha);
+		},
+		rgbaString: function () {
+			return string.rgbaString(this.values.rgb, this.values.alpha);
+		},
+		percentString: function () {
+			return string.percentString(this.values.rgb, this.values.alpha);
+		},
+		hslString: function () {
+			return string.hslString(this.values.hsl, this.values.alpha);
+		},
+		hslaString: function () {
+			return string.hslaString(this.values.hsl, this.values.alpha);
+		},
+		hwbString: function () {
+			return string.hwbString(this.values.hwb, this.values.alpha);
+		},
+		keyword: function () {
+			return string.keyword(this.values.rgb, this.values.alpha);
+		},
+
+		rgbNumber: function () {
+			var rgb = this.values.rgb;
+			return (rgb[0] << 16) | (rgb[1] << 8) | rgb[2];
+		},
+
+		luminosity: function () {
+			// http://www.w3.org/TR/WCAG20/#relativeluminancedef
+			var rgb = this.values.rgb;
+			var lum = [];
+			for (var i = 0; i < rgb.length; i++) {
+				var chan = rgb[i] / 255;
+				lum[i] = (chan <= 0.03928) ? chan / 12.92 : Math.pow(((chan + 0.055) / 1.055), 2.4);
+			}
+			return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
+		},
+
+		contrast: function (color2) {
+			// http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+			var lum1 = this.luminosity();
+			var lum2 = color2.luminosity();
+			if (lum1 > lum2) {
+				return (lum1 + 0.05) / (lum2 + 0.05);
+			}
+			return (lum2 + 0.05) / (lum1 + 0.05);
+		},
+
+		level: function (color2) {
+			var contrastRatio = this.contrast(color2);
+			if (contrastRatio >= 7.1) {
+				return 'AAA';
+			}
+
+			return (contrastRatio >= 4.5) ? 'AA' : '';
+		},
+
+		dark: function () {
+			// YIQ equation from http://24ways.org/2010/calculating-color-contrast
+			var rgb = this.values.rgb;
+			var yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000;
+			return yiq < 128;
+		},
+
+		light: function () {
+			return !this.dark();
+		},
+
+		negate: function () {
+			var rgb = [];
+			for (var i = 0; i < 3; i++) {
+				rgb[i] = 255 - this.values.rgb[i];
+			}
+			this.setValues('rgb', rgb);
+			return this;
+		},
+
+		lighten: function (ratio) {
+			var hsl = this.values.hsl;
+			hsl[2] += hsl[2] * ratio;
+			this.setValues('hsl', hsl);
+			return this;
+		},
+
+		darken: function (ratio) {
+			var hsl = this.values.hsl;
+			hsl[2] -= hsl[2] * ratio;
+			this.setValues('hsl', hsl);
+			return this;
+		},
+
+		saturate: function (ratio) {
+			var hsl = this.values.hsl;
+			hsl[1] += hsl[1] * ratio;
+			this.setValues('hsl', hsl);
+			return this;
+		},
+
+		desaturate: function (ratio) {
+			var hsl = this.values.hsl;
+			hsl[1] -= hsl[1] * ratio;
+			this.setValues('hsl', hsl);
+			return this;
+		},
+
+		whiten: function (ratio) {
+			var hwb = this.values.hwb;
+			hwb[1] += hwb[1] * ratio;
+			this.setValues('hwb', hwb);
+			return this;
+		},
+
+		blacken: function (ratio) {
+			var hwb = this.values.hwb;
+			hwb[2] += hwb[2] * ratio;
+			this.setValues('hwb', hwb);
+			return this;
+		},
+
+		greyscale: function () {
+			var rgb = this.values.rgb;
+			// http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale
+			var val = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
+			this.setValues('rgb', [val, val, val]);
+			return this;
+		},
+
+		clearer: function (ratio) {
+			var alpha = this.values.alpha;
+			this.setValues('alpha', alpha - (alpha * ratio));
+			return this;
+		},
+
+		opaquer: function (ratio) {
+			var alpha = this.values.alpha;
+			this.setValues('alpha', alpha + (alpha * ratio));
+			return this;
+		},
+
+		rotate: function (degrees) {
+			var hsl = this.values.hsl;
+			var hue = (hsl[0] + degrees) % 360;
+			hsl[0] = hue < 0 ? 360 + hue : hue;
+			this.setValues('hsl', hsl);
+			return this;
+		},
+
+		/**
+		 * Ported from sass implementation in C
+		 * https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209
+		 */
+		mix: function (mixinColor, weight) {
+			var color1 = this;
+			var color2 = mixinColor;
+			var p = weight === undefined ? 0.5 : weight;
+
+			var w = 2 * p - 1;
+			var a = color1.alpha() - color2.alpha();
+
+			var w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
+			var w2 = 1 - w1;
+
+			return this
+				.rgb(
+					w1 * color1.red() + w2 * color2.red(),
+					w1 * color1.green() + w2 * color2.green(),
+					w1 * color1.blue() + w2 * color2.blue()
+				)
+				.alpha(color1.alpha() * p + color2.alpha() * (1 - p));
+		},
+
+		toJSON: function () {
+			return this.rgb();
+		},
+
+		clone: function () {
+			// NOTE(SB): using node-clone creates a dependency to Buffer when using browserify,
+			// making the final build way to big to embed in Chart.js. So let's do it manually,
+			// assuming that values to clone are 1 dimension arrays containing only numbers,
+			// except 'alpha' which is a number.
+			var result = new Color();
+			var source = this.values;
+			var target = result.values;
+			var value, type;
+
+			for (var prop in source) {
+				if (source.hasOwnProperty(prop)) {
+					value = source[prop];
+					type = ({}).toString.call(value);
+					if (type === '[object Array]') {
+						target[prop] = value.slice(0);
+					} else if (type === '[object Number]') {
+						target[prop] = value;
+					} else {
+						console.error('unexpected color value:', value);
+					}
+				}
+			}
+
+			return result;
+		}
+	};
+
+	Color.prototype.spaces = {
+		rgb: ['red', 'green', 'blue'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		hsv: ['hue', 'saturation', 'value'],
+		hwb: ['hue', 'whiteness', 'blackness'],
+		cmyk: ['cyan', 'magenta', 'yellow', 'black']
+	};
+
+	Color.prototype.maxes = {
+		rgb: [255, 255, 255],
+		hsl: [360, 100, 100],
+		hsv: [360, 100, 100],
+		hwb: [360, 100, 100],
+		cmyk: [100, 100, 100, 100]
+	};
+
+	Color.prototype.getValues = function (space) {
+		var values = this.values;
+		var vals = {};
+
+		for (var i = 0; i < space.length; i++) {
+			vals[space.charAt(i)] = values[space][i];
+		}
+
+		if (values.alpha !== 1) {
+			vals.a = values.alpha;
+		}
+
+		// {r: 255, g: 255, b: 255, a: 0.4}
+		return vals;
+	};
+
+	Color.prototype.setValues = function (space, vals) {
+		var values = this.values;
+		var spaces = this.spaces;
+		var maxes = this.maxes;
+		var alpha = 1;
+		var i;
+
+		this.valid = true;
+
+		if (space === 'alpha') {
+			alpha = vals;
+		} else if (vals.length) {
+			// [10, 10, 10]
+			values[space] = vals.slice(0, space.length);
+			alpha = vals[space.length];
+		} else if (vals[space.charAt(0)] !== undefined) {
+			// {r: 10, g: 10, b: 10}
+			for (i = 0; i < space.length; i++) {
+				values[space][i] = vals[space.charAt(i)];
+			}
+
+			alpha = vals.a;
+		} else if (vals[spaces[space][0]] !== undefined) {
+			// {red: 10, green: 10, blue: 10}
+			var chans = spaces[space];
+
+			for (i = 0; i < space.length; i++) {
+				values[space][i] = vals[chans[i]];
+			}
+
+			alpha = vals.alpha;
+		}
+
+		values.alpha = Math.max(0, Math.min(1, (alpha === undefined ? values.alpha : alpha)));
+
+		if (space === 'alpha') {
+			return false;
+		}
+
+		var capped;
+
+		// cap values of the space prior converting all values
+		for (i = 0; i < space.length; i++) {
+			capped = Math.max(0, Math.min(maxes[space][i], values[space][i]));
+			values[space][i] = Math.round(capped);
+		}
+
+		// convert to all the other color spaces
+		for (var sname in spaces) {
+			if (sname !== space) {
+				values[sname] = convert[space][sname](values[space]);
+			}
+		}
+
+		return true;
+	};
+
+	Color.prototype.setSpace = function (space, args) {
+		var vals = args[0];
+
+		if (vals === undefined) {
+			// color.rgb()
+			return this.getValues(space);
+		}
+
+		// color.rgb(10, 10, 10)
+		if (typeof vals === 'number') {
+			vals = Array.prototype.slice.call(args);
+		}
+
+		this.setValues(space, vals);
+		return this;
+	};
+
+	Color.prototype.setChannel = function (space, index, val) {
+		var svalues = this.values[space];
+		if (val === undefined) {
+			// color.red()
+			return svalues[index];
+		} else if (val === svalues[index]) {
+			// color.red(color.red())
+			return this;
+		}
+
+		// color.red(100)
+		svalues[index] = val;
+		this.setValues(space, svalues);
+
+		return this;
+	};
+
+	if (typeof window !== 'undefined') {
+		window.Color = Color;
+	}
+
+	module.exports = Color;
+
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var conversions = __webpack_require__(15);
+
+	var convert = function() {
+	   return new Converter();
+	}
+
+	for (var func in conversions) {
+	  // export Raw versions
+	  convert[func + "Raw"] =  (function(func) {
+	    // accept array or plain args
+	    return function(arg) {
+	      if (typeof arg == "number")
+	        arg = Array.prototype.slice.call(arguments);
+	      return conversions[func](arg);
+	    }
+	  })(func);
+
+	  var pair = /(\w+)2(\w+)/.exec(func),
+	      from = pair[1],
+	      to = pair[2];
+
+	  // export rgb2hsl and ["rgb"]["hsl"]
+	  convert[from] = convert[from] || {};
+
+	  convert[from][to] = convert[func] = (function(func) { 
+	    return function(arg) {
+	      if (typeof arg == "number")
+	        arg = Array.prototype.slice.call(arguments);
+	      
+	      var val = conversions[func](arg);
+	      if (typeof val == "string" || val === undefined)
+	        return val; // keyword
+
+	      for (var i = 0; i < val.length; i++)
+	        val[i] = Math.round(val[i]);
+	      return val;
+	    }
+	  })(func);
+	}
+
+
+	/* Converter does lazy conversion and caching */
+	var Converter = function() {
+	   this.convs = {};
+	};
+
+	/* Either get the values for a space or
+	  set the values for a space, depending on args */
+	Converter.prototype.routeSpace = function(space, args) {
+	   var values = args[0];
+	   if (values === undefined) {
+	      // color.rgb()
+	      return this.getValues(space);
+	   }
+	   // color.rgb(10, 10, 10)
+	   if (typeof values == "number") {
+	      values = Array.prototype.slice.call(args);        
+	   }
+
+	   return this.setValues(space, values);
+	};
+	  
+	/* Set the values for a space, invalidating cache */
+	Converter.prototype.setValues = function(space, values) {
+	   this.space = space;
+	   this.convs = {};
+	   this.convs[space] = values;
+	   return this;
+	};
+
+	/* Get the values for a space. If there's already
+	  a conversion for the space, fetch it, otherwise
+	  compute it */
+	Converter.prototype.getValues = function(space) {
+	   var vals = this.convs[space];
+	   if (!vals) {
+	      var fspace = this.space,
+	          from = this.convs[fspace];
+	      vals = convert[fspace][space](from);
+
+	      this.convs[space] = vals;
+	   }
+	  return vals;
+	};
+
+	["rgb", "hsl", "hsv", "cmyk", "keyword"].forEach(function(space) {
+	   Converter.prototype[space] = function(vals) {
+	      return this.routeSpace(space, arguments);
+	   }
+	});
+
+	module.exports = convert;
+
+/***/ },
+/* 15 */
+/***/ function(module, exports) {
+
+	/* MIT license */
+
+	module.exports = {
+	  rgb2hsl: rgb2hsl,
+	  rgb2hsv: rgb2hsv,
+	  rgb2hwb: rgb2hwb,
+	  rgb2cmyk: rgb2cmyk,
+	  rgb2keyword: rgb2keyword,
+	  rgb2xyz: rgb2xyz,
+	  rgb2lab: rgb2lab,
+	  rgb2lch: rgb2lch,
+
+	  hsl2rgb: hsl2rgb,
+	  hsl2hsv: hsl2hsv,
+	  hsl2hwb: hsl2hwb,
+	  hsl2cmyk: hsl2cmyk,
+	  hsl2keyword: hsl2keyword,
+
+	  hsv2rgb: hsv2rgb,
+	  hsv2hsl: hsv2hsl,
+	  hsv2hwb: hsv2hwb,
+	  hsv2cmyk: hsv2cmyk,
+	  hsv2keyword: hsv2keyword,
+
+	  hwb2rgb: hwb2rgb,
+	  hwb2hsl: hwb2hsl,
+	  hwb2hsv: hwb2hsv,
+	  hwb2cmyk: hwb2cmyk,
+	  hwb2keyword: hwb2keyword,
+
+	  cmyk2rgb: cmyk2rgb,
+	  cmyk2hsl: cmyk2hsl,
+	  cmyk2hsv: cmyk2hsv,
+	  cmyk2hwb: cmyk2hwb,
+	  cmyk2keyword: cmyk2keyword,
+
+	  keyword2rgb: keyword2rgb,
+	  keyword2hsl: keyword2hsl,
+	  keyword2hsv: keyword2hsv,
+	  keyword2hwb: keyword2hwb,
+	  keyword2cmyk: keyword2cmyk,
+	  keyword2lab: keyword2lab,
+	  keyword2xyz: keyword2xyz,
+
+	  xyz2rgb: xyz2rgb,
+	  xyz2lab: xyz2lab,
+	  xyz2lch: xyz2lch,
+
+	  lab2xyz: lab2xyz,
+	  lab2rgb: lab2rgb,
+	  lab2lch: lab2lch,
+
+	  lch2lab: lch2lab,
+	  lch2xyz: lch2xyz,
+	  lch2rgb: lch2rgb
+	}
+
+
+	function rgb2hsl(rgb) {
+	  var r = rgb[0]/255,
+	      g = rgb[1]/255,
+	      b = rgb[2]/255,
+	      min = Math.min(r, g, b),
+	      max = Math.max(r, g, b),
+	      delta = max - min,
+	      h, s, l;
+
+	  if (max == min)
+	    h = 0;
+	  else if (r == max)
+	    h = (g - b) / delta;
+	  else if (g == max)
+	    h = 2 + (b - r) / delta;
+	  else if (b == max)
+	    h = 4 + (r - g)/ delta;
+
+	  h = Math.min(h * 60, 360);
+
+	  if (h < 0)
+	    h += 360;
+
+	  l = (min + max) / 2;
+
+	  if (max == min)
+	    s = 0;
+	  else if (l <= 0.5)
+	    s = delta / (max + min);
+	  else
+	    s = delta / (2 - max - min);
+
+	  return [h, s * 100, l * 100];
+	}
+
+	function rgb2hsv(rgb) {
+	  var r = rgb[0],
+	      g = rgb[1],
+	      b = rgb[2],
+	      min = Math.min(r, g, b),
+	      max = Math.max(r, g, b),
+	      delta = max - min,
+	      h, s, v;
+
+	  if (max == 0)
+	    s = 0;
+	  else
+	    s = (delta/max * 1000)/10;
+
+	  if (max == min)
+	    h = 0;
+	  else if (r == max)
+	    h = (g - b) / delta;
+	  else if (g == max)
+	    h = 2 + (b - r) / delta;
+	  else if (b == max)
+	    h = 4 + (r - g) / delta;
+
+	  h = Math.min(h * 60, 360);
+
+	  if (h < 0)
+	    h += 360;
+
+	  v = ((max / 255) * 1000) / 10;
+
+	  return [h, s, v];
+	}
+
+	function rgb2hwb(rgb) {
+	  var r = rgb[0],
+	      g = rgb[1],
+	      b = rgb[2],
+	      h = rgb2hsl(rgb)[0],
+	      w = 1/255 * Math.min(r, Math.min(g, b)),
+	      b = 1 - 1/255 * Math.max(r, Math.max(g, b));
+
+	  return [h, w * 100, b * 100];
+	}
+
+	function rgb2cmyk(rgb) {
+	  var r = rgb[0] / 255,
+	      g = rgb[1] / 255,
+	      b = rgb[2] / 255,
+	      c, m, y, k;
+
+	  k = Math.min(1 - r, 1 - g, 1 - b);
+	  c = (1 - r - k) / (1 - k) || 0;
+	  m = (1 - g - k) / (1 - k) || 0;
+	  y = (1 - b - k) / (1 - k) || 0;
+	  return [c * 100, m * 100, y * 100, k * 100];
+	}
+
+	function rgb2keyword(rgb) {
+	  return reverseKeywords[JSON.stringify(rgb)];
+	}
+
+	function rgb2xyz(rgb) {
+	  var r = rgb[0] / 255,
+	      g = rgb[1] / 255,
+	      b = rgb[2] / 255;
+
+	  // assume sRGB
+	  r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
+	  g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
+	  b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
+
+	  var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+	  var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+	  var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+
+	  return [x * 100, y *100, z * 100];
+	}
+
+	function rgb2lab(rgb) {
+	  var xyz = rgb2xyz(rgb),
+	        x = xyz[0],
+	        y = xyz[1],
+	        z = xyz[2],
+	        l, a, b;
+
+	  x /= 95.047;
+	  y /= 100;
+	  z /= 108.883;
+
+	  x = x > 0.008856 ? Math.pow(x, 1/3) : (7.787 * x) + (16 / 116);
+	  y = y > 0.008856 ? Math.pow(y, 1/3) : (7.787 * y) + (16 / 116);
+	  z = z > 0.008856 ? Math.pow(z, 1/3) : (7.787 * z) + (16 / 116);
+
+	  l = (116 * y) - 16;
+	  a = 500 * (x - y);
+	  b = 200 * (y - z);
+
+	  return [l, a, b];
+	}
+
+	function rgb2lch(args) {
+	  return lab2lch(rgb2lab(args));
+	}
+
+	function hsl2rgb(hsl) {
+	  var h = hsl[0] / 360,
+	      s = hsl[1] / 100,
+	      l = hsl[2] / 100,
+	      t1, t2, t3, rgb, val;
+
+	  if (s == 0) {
+	    val = l * 255;
+	    return [val, val, val];
+	  }
+
+	  if (l < 0.5)
+	    t2 = l * (1 + s);
+	  else
+	    t2 = l + s - l * s;
+	  t1 = 2 * l - t2;
+
+	  rgb = [0, 0, 0];
+	  for (var i = 0; i < 3; i++) {
+	    t3 = h + 1 / 3 * - (i - 1);
+	    t3 < 0 && t3++;
+	    t3 > 1 && t3--;
+
+	    if (6 * t3 < 1)
+	      val = t1 + (t2 - t1) * 6 * t3;
+	    else if (2 * t3 < 1)
+	      val = t2;
+	    else if (3 * t3 < 2)
+	      val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+	    else
+	      val = t1;
+
+	    rgb[i] = val * 255;
+	  }
+
+	  return rgb;
+	}
+
+	function hsl2hsv(hsl) {
+	  var h = hsl[0],
+	      s = hsl[1] / 100,
+	      l = hsl[2] / 100,
+	      sv, v;
+
+	  if(l === 0) {
+	      // no need to do calc on black
+	      // also avoids divide by 0 error
+	      return [0, 0, 0];
+	  }
+
+	  l *= 2;
+	  s *= (l <= 1) ? l : 2 - l;
+	  v = (l + s) / 2;
+	  sv = (2 * s) / (l + s);
+	  return [h, sv * 100, v * 100];
+	}
+
+	function hsl2hwb(args) {
+	  return rgb2hwb(hsl2rgb(args));
+	}
+
+	function hsl2cmyk(args) {
+	  return rgb2cmyk(hsl2rgb(args));
+	}
+
+	function hsl2keyword(args) {
+	  return rgb2keyword(hsl2rgb(args));
+	}
+
+
+	function hsv2rgb(hsv) {
+	  var h = hsv[0] / 60,
+	      s = hsv[1] / 100,
+	      v = hsv[2] / 100,
+	      hi = Math.floor(h) % 6;
+
+	  var f = h - Math.floor(h),
+	      p = 255 * v * (1 - s),
+	      q = 255 * v * (1 - (s * f)),
+	      t = 255 * v * (1 - (s * (1 - f))),
+	      v = 255 * v;
+
+	  switch(hi) {
+	    case 0:
+	      return [v, t, p];
+	    case 1:
+	      return [q, v, p];
+	    case 2:
+	      return [p, v, t];
+	    case 3:
+	      return [p, q, v];
+	    case 4:
+	      return [t, p, v];
+	    case 5:
+	      return [v, p, q];
+	  }
+	}
+
+	function hsv2hsl(hsv) {
+	  var h = hsv[0],
+	      s = hsv[1] / 100,
+	      v = hsv[2] / 100,
+	      sl, l;
+
+	  l = (2 - s) * v;
+	  sl = s * v;
+	  sl /= (l <= 1) ? l : 2 - l;
+	  sl = sl || 0;
+	  l /= 2;
+	  return [h, sl * 100, l * 100];
+	}
+
+	function hsv2hwb(args) {
+	  return rgb2hwb(hsv2rgb(args))
+	}
+
+	function hsv2cmyk(args) {
+	  return rgb2cmyk(hsv2rgb(args));
+	}
+
+	function hsv2keyword(args) {
+	  return rgb2keyword(hsv2rgb(args));
+	}
+
+	// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+	function hwb2rgb(hwb) {
+	  var h = hwb[0] / 360,
+	      wh = hwb[1] / 100,
+	      bl = hwb[2] / 100,
+	      ratio = wh + bl,
+	      i, v, f, n;
+
+	  // wh + bl cant be > 1
+	  if (ratio > 1) {
+	    wh /= ratio;
+	    bl /= ratio;
+	  }
+
+	  i = Math.floor(6 * h);
+	  v = 1 - bl;
+	  f = 6 * h - i;
+	  if ((i & 0x01) != 0) {
+	    f = 1 - f;
+	  }
+	  n = wh + f * (v - wh);  // linear interpolation
+
+	  switch (i) {
+	    default:
+	    case 6:
+	    case 0: r = v; g = n; b = wh; break;
+	    case 1: r = n; g = v; b = wh; break;
+	    case 2: r = wh; g = v; b = n; break;
+	    case 3: r = wh; g = n; b = v; break;
+	    case 4: r = n; g = wh; b = v; break;
+	    case 5: r = v; g = wh; b = n; break;
+	  }
+
+	  return [r * 255, g * 255, b * 255];
+	}
+
+	function hwb2hsl(args) {
+	  return rgb2hsl(hwb2rgb(args));
+	}
+
+	function hwb2hsv(args) {
+	  return rgb2hsv(hwb2rgb(args));
+	}
+
+	function hwb2cmyk(args) {
+	  return rgb2cmyk(hwb2rgb(args));
+	}
+
+	function hwb2keyword(args) {
+	  return rgb2keyword(hwb2rgb(args));
+	}
+
+	function cmyk2rgb(cmyk) {
+	  var c = cmyk[0] / 100,
+	      m = cmyk[1] / 100,
+	      y = cmyk[2] / 100,
+	      k = cmyk[3] / 100,
+	      r, g, b;
+
+	  r = 1 - Math.min(1, c * (1 - k) + k);
+	  g = 1 - Math.min(1, m * (1 - k) + k);
+	  b = 1 - Math.min(1, y * (1 - k) + k);
+	  return [r * 255, g * 255, b * 255];
+	}
+
+	function cmyk2hsl(args) {
+	  return rgb2hsl(cmyk2rgb(args));
+	}
+
+	function cmyk2hsv(args) {
+	  return rgb2hsv(cmyk2rgb(args));
+	}
+
+	function cmyk2hwb(args) {
+	  return rgb2hwb(cmyk2rgb(args));
+	}
+
+	function cmyk2keyword(args) {
+	  return rgb2keyword(cmyk2rgb(args));
+	}
+
+
+	function xyz2rgb(xyz) {
+	  var x = xyz[0] / 100,
+	      y = xyz[1] / 100,
+	      z = xyz[2] / 100,
+	      r, g, b;
+
+	  r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+	  g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+	  b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+
+	  // assume sRGB
+	  r = r > 0.0031308 ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
+	    : r = (r * 12.92);
+
+	  g = g > 0.0031308 ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
+	    : g = (g * 12.92);
+
+	  b = b > 0.0031308 ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
+	    : b = (b * 12.92);
+
+	  r = Math.min(Math.max(0, r), 1);
+	  g = Math.min(Math.max(0, g), 1);
+	  b = Math.min(Math.max(0, b), 1);
+
+	  return [r * 255, g * 255, b * 255];
+	}
+
+	function xyz2lab(xyz) {
+	  var x = xyz[0],
+	      y = xyz[1],
+	      z = xyz[2],
+	      l, a, b;
+
+	  x /= 95.047;
+	  y /= 100;
+	  z /= 108.883;
+
+	  x = x > 0.008856 ? Math.pow(x, 1/3) : (7.787 * x) + (16 / 116);
+	  y = y > 0.008856 ? Math.pow(y, 1/3) : (7.787 * y) + (16 / 116);
+	  z = z > 0.008856 ? Math.pow(z, 1/3) : (7.787 * z) + (16 / 116);
+
+	  l = (116 * y) - 16;
+	  a = 500 * (x - y);
+	  b = 200 * (y - z);
+
+	  return [l, a, b];
+	}
+
+	function xyz2lch(args) {
+	  return lab2lch(xyz2lab(args));
+	}
+
+	function lab2xyz(lab) {
+	  var l = lab[0],
+	      a = lab[1],
+	      b = lab[2],
+	      x, y, z, y2;
+
+	  if (l <= 8) {
+	    y = (l * 100) / 903.3;
+	    y2 = (7.787 * (y / 100)) + (16 / 116);
+	  } else {
+	    y = 100 * Math.pow((l + 16) / 116, 3);
+	    y2 = Math.pow(y / 100, 1/3);
+	  }
+
+	  x = x / 95.047 <= 0.008856 ? x = (95.047 * ((a / 500) + y2 - (16 / 116))) / 7.787 : 95.047 * Math.pow((a / 500) + y2, 3);
+
+	  z = z / 108.883 <= 0.008859 ? z = (108.883 * (y2 - (b / 200) - (16 / 116))) / 7.787 : 108.883 * Math.pow(y2 - (b / 200), 3);
+
+	  return [x, y, z];
+	}
+
+	function lab2lch(lab) {
+	  var l = lab[0],
+	      a = lab[1],
+	      b = lab[2],
+	      hr, h, c;
+
+	  hr = Math.atan2(b, a);
+	  h = hr * 360 / 2 / Math.PI;
+	  if (h < 0) {
+	    h += 360;
+	  }
+	  c = Math.sqrt(a * a + b * b);
+	  return [l, c, h];
+	}
+
+	function lab2rgb(args) {
+	  return xyz2rgb(lab2xyz(args));
+	}
+
+	function lch2lab(lch) {
+	  var l = lch[0],
+	      c = lch[1],
+	      h = lch[2],
+	      a, b, hr;
+
+	  hr = h / 360 * 2 * Math.PI;
+	  a = c * Math.cos(hr);
+	  b = c * Math.sin(hr);
+	  return [l, a, b];
+	}
+
+	function lch2xyz(args) {
+	  return lab2xyz(lch2lab(args));
+	}
+
+	function lch2rgb(args) {
+	  return lab2rgb(lch2lab(args));
+	}
+
+	function keyword2rgb(keyword) {
+	  return cssKeywords[keyword];
+	}
+
+	function keyword2hsl(args) {
+	  return rgb2hsl(keyword2rgb(args));
+	}
+
+	function keyword2hsv(args) {
+	  return rgb2hsv(keyword2rgb(args));
+	}
+
+	function keyword2hwb(args) {
+	  return rgb2hwb(keyword2rgb(args));
+	}
+
+	function keyword2cmyk(args) {
+	  return rgb2cmyk(keyword2rgb(args));
+	}
+
+	function keyword2lab(args) {
+	  return rgb2lab(keyword2rgb(args));
+	}
+
+	function keyword2xyz(args) {
+	  return rgb2xyz(keyword2rgb(args));
+	}
+
+	var cssKeywords = {
+	  aliceblue:  [240,248,255],
+	  antiquewhite: [250,235,215],
+	  aqua: [0,255,255],
+	  aquamarine: [127,255,212],
+	  azure:  [240,255,255],
+	  beige:  [245,245,220],
+	  bisque: [255,228,196],
+	  black:  [0,0,0],
+	  blanchedalmond: [255,235,205],
+	  blue: [0,0,255],
+	  blueviolet: [138,43,226],
+	  brown:  [165,42,42],
+	  burlywood:  [222,184,135],
+	  cadetblue:  [95,158,160],
+	  chartreuse: [127,255,0],
+	  chocolate:  [210,105,30],
+	  coral:  [255,127,80],
+	  cornflowerblue: [100,149,237],
+	  cornsilk: [255,248,220],
+	  crimson:  [220,20,60],
+	  cyan: [0,255,255],
+	  darkblue: [0,0,139],
+	  darkcyan: [0,139,139],
+	  darkgoldenrod:  [184,134,11],
+	  darkgray: [169,169,169],
+	  darkgreen:  [0,100,0],
+	  darkgrey: [169,169,169],
+	  darkkhaki:  [189,183,107],
+	  darkmagenta:  [139,0,139],
+	  darkolivegreen: [85,107,47],
+	  darkorange: [255,140,0],
+	  darkorchid: [153,50,204],
+	  darkred:  [139,0,0],
+	  darksalmon: [233,150,122],
+	  darkseagreen: [143,188,143],
+	  darkslateblue:  [72,61,139],
+	  darkslategray:  [47,79,79],
+	  darkslategrey:  [47,79,79],
+	  darkturquoise:  [0,206,209],
+	  darkviolet: [148,0,211],
+	  deeppink: [255,20,147],
+	  deepskyblue:  [0,191,255],
+	  dimgray:  [105,105,105],
+	  dimgrey:  [105,105,105],
+	  dodgerblue: [30,144,255],
+	  firebrick:  [178,34,34],
+	  floralwhite:  [255,250,240],
+	  forestgreen:  [34,139,34],
+	  fuchsia:  [255,0,255],
+	  gainsboro:  [220,220,220],
+	  ghostwhite: [248,248,255],
+	  gold: [255,215,0],
+	  goldenrod:  [218,165,32],
+	  gray: [128,128,128],
+	  green:  [0,128,0],
+	  greenyellow:  [173,255,47],
+	  grey: [128,128,128],
+	  honeydew: [240,255,240],
+	  hotpink:  [255,105,180],
+	  indianred:  [205,92,92],
+	  indigo: [75,0,130],
+	  ivory:  [255,255,240],
+	  khaki:  [240,230,140],
+	  lavender: [230,230,250],
+	  lavenderblush:  [255,240,245],
+	  lawngreen:  [124,252,0],
+	  lemonchiffon: [255,250,205],
+	  lightblue:  [173,216,230],
+	  lightcoral: [240,128,128],
+	  lightcyan:  [224,255,255],
+	  lightgoldenrodyellow: [250,250,210],
+	  lightgray:  [211,211,211],
+	  lightgreen: [144,238,144],
+	  lightgrey:  [211,211,211],
+	  lightpink:  [255,182,193],
+	  lightsalmon:  [255,160,122],
+	  lightseagreen:  [32,178,170],
+	  lightskyblue: [135,206,250],
+	  lightslategray: [119,136,153],
+	  lightslategrey: [119,136,153],
+	  lightsteelblue: [176,196,222],
+	  lightyellow:  [255,255,224],
+	  lime: [0,255,0],
+	  limegreen:  [50,205,50],
+	  linen:  [250,240,230],
+	  magenta:  [255,0,255],
+	  maroon: [128,0,0],
+	  mediumaquamarine: [102,205,170],
+	  mediumblue: [0,0,205],
+	  mediumorchid: [186,85,211],
+	  mediumpurple: [147,112,219],
+	  mediumseagreen: [60,179,113],
+	  mediumslateblue:  [123,104,238],
+	  mediumspringgreen:  [0,250,154],
+	  mediumturquoise:  [72,209,204],
+	  mediumvioletred:  [199,21,133],
+	  midnightblue: [25,25,112],
+	  mintcream:  [245,255,250],
+	  mistyrose:  [255,228,225],
+	  moccasin: [255,228,181],
+	  navajowhite:  [255,222,173],
+	  navy: [0,0,128],
+	  oldlace:  [253,245,230],
+	  olive:  [128,128,0],
+	  olivedrab:  [107,142,35],
+	  orange: [255,165,0],
+	  orangered:  [255,69,0],
+	  orchid: [218,112,214],
+	  palegoldenrod:  [238,232,170],
+	  palegreen:  [152,251,152],
+	  paleturquoise:  [175,238,238],
+	  palevioletred:  [219,112,147],
+	  papayawhip: [255,239,213],
+	  peachpuff:  [255,218,185],
+	  peru: [205,133,63],
+	  pink: [255,192,203],
+	  plum: [221,160,221],
+	  powderblue: [176,224,230],
+	  purple: [128,0,128],
+	  rebeccapurple: [102, 51, 153],
+	  red:  [255,0,0],
+	  rosybrown:  [188,143,143],
+	  royalblue:  [65,105,225],
+	  saddlebrown:  [139,69,19],
+	  salmon: [250,128,114],
+	  sandybrown: [244,164,96],
+	  seagreen: [46,139,87],
+	  seashell: [255,245,238],
+	  sienna: [160,82,45],
+	  silver: [192,192,192],
+	  skyblue:  [135,206,235],
+	  slateblue:  [106,90,205],
+	  slategray:  [112,128,144],
+	  slategrey:  [112,128,144],
+	  snow: [255,250,250],
+	  springgreen:  [0,255,127],
+	  steelblue:  [70,130,180],
+	  tan:  [210,180,140],
+	  teal: [0,128,128],
+	  thistle:  [216,191,216],
+	  tomato: [255,99,71],
+	  turquoise:  [64,224,208],
+	  violet: [238,130,238],
+	  wheat:  [245,222,179],
+	  white:  [255,255,255],
+	  whitesmoke: [245,245,245],
+	  yellow: [255,255,0],
+	  yellowgreen:  [154,205,50]
+	};
+
+	var reverseKeywords = {};
+	for (var key in cssKeywords) {
+	  reverseKeywords[JSON.stringify(cssKeywords[key])] = key;
+	}
+
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* MIT license */
+	var colorNames = __webpack_require__(17);
+
+	module.exports = {
+	   getRgba: getRgba,
+	   getHsla: getHsla,
+	   getRgb: getRgb,
+	   getHsl: getHsl,
+	   getHwb: getHwb,
+	   getAlpha: getAlpha,
+
+	   hexString: hexString,
+	   rgbString: rgbString,
+	   rgbaString: rgbaString,
+	   percentString: percentString,
+	   percentaString: percentaString,
+	   hslString: hslString,
+	   hslaString: hslaString,
+	   hwbString: hwbString,
+	   keyword: keyword
+	}
+
+	function getRgba(string) {
+	   if (!string) {
+	      return;
+	   }
+	   var abbr =  /^#([a-fA-F0-9]{3})$/i,
+	       hex =  /^#([a-fA-F0-9]{6})$/i,
+	       rgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
+	       per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
+	       keyword = /(\w+)/;
+
+	   var rgb = [0, 0, 0],
+	       a = 1,
+	       match = string.match(abbr);
+	   if (match) {
+	      match = match[1];
+	      for (var i = 0; i < rgb.length; i++) {
+	         rgb[i] = parseInt(match[i] + match[i], 16);
+	      }
+	   }
+	   else if (match = string.match(hex)) {
+	      match = match[1];
+	      for (var i = 0; i < rgb.length; i++) {
+	         rgb[i] = parseInt(match.slice(i * 2, i * 2 + 2), 16);
+	      }
+	   }
+	   else if (match = string.match(rgba)) {
+	      for (var i = 0; i < rgb.length; i++) {
+	         rgb[i] = parseInt(match[i + 1]);
+	      }
+	      a = parseFloat(match[4]);
+	   }
+	   else if (match = string.match(per)) {
+	      for (var i = 0; i < rgb.length; i++) {
+	         rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
+	      }
+	      a = parseFloat(match[4]);
+	   }
+	   else if (match = string.match(keyword)) {
+	      if (match[1] == "transparent") {
+	         return [0, 0, 0, 0];
+	      }
+	      rgb = colorNames[match[1]];
+	      if (!rgb) {
+	         return;
+	      }
+	   }
+
+	   for (var i = 0; i < rgb.length; i++) {
+	      rgb[i] = scale(rgb[i], 0, 255);
+	   }
+	   if (!a && a != 0) {
+	      a = 1;
+	   }
+	   else {
+	      a = scale(a, 0, 1);
+	   }
+	   rgb[3] = a;
+	   return rgb;
+	}
+
+	function getHsla(string) {
+	   if (!string) {
+	      return;
+	   }
+	   var hsl = /^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
+	   var match = string.match(hsl);
+	   if (match) {
+	      var alpha = parseFloat(match[4]);
+	      var h = scale(parseInt(match[1]), 0, 360),
+	          s = scale(parseFloat(match[2]), 0, 100),
+	          l = scale(parseFloat(match[3]), 0, 100),
+	          a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
+	      return [h, s, l, a];
+	   }
+	}
+
+	function getHwb(string) {
+	   if (!string) {
+	      return;
+	   }
+	   var hwb = /^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
+	   var match = string.match(hwb);
+	   if (match) {
+	    var alpha = parseFloat(match[4]);
+	      var h = scale(parseInt(match[1]), 0, 360),
+	          w = scale(parseFloat(match[2]), 0, 100),
+	          b = scale(parseFloat(match[3]), 0, 100),
+	          a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
+	      return [h, w, b, a];
+	   }
+	}
+
+	function getRgb(string) {
+	   var rgba = getRgba(string);
+	   return rgba && rgba.slice(0, 3);
+	}
+
+	function getHsl(string) {
+	  var hsla = getHsla(string);
+	  return hsla && hsla.slice(0, 3);
+	}
+
+	function getAlpha(string) {
+	   var vals = getRgba(string);
+	   if (vals) {
+	      return vals[3];
+	   }
+	   else if (vals = getHsla(string)) {
+	      return vals[3];
+	   }
+	   else if (vals = getHwb(string)) {
+	      return vals[3];
+	   }
+	}
+
+	// generators
+	function hexString(rgb) {
+	   return "#" + hexDouble(rgb[0]) + hexDouble(rgb[1])
+	              + hexDouble(rgb[2]);
+	}
+
+	function rgbString(rgba, alpha) {
+	   if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
+	      return rgbaString(rgba, alpha);
+	   }
+	   return "rgb(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2] + ")";
+	}
+
+	function rgbaString(rgba, alpha) {
+	   if (alpha === undefined) {
+	      alpha = (rgba[3] !== undefined ? rgba[3] : 1);
+	   }
+	   return "rgba(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2]
+	           + ", " + alpha + ")";
+	}
+
+	function percentString(rgba, alpha) {
+	   if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
+	      return percentaString(rgba, alpha);
+	   }
+	   var r = Math.round(rgba[0]/255 * 100),
+	       g = Math.round(rgba[1]/255 * 100),
+	       b = Math.round(rgba[2]/255 * 100);
+
+	   return "rgb(" + r + "%, " + g + "%, " + b + "%)";
+	}
+
+	function percentaString(rgba, alpha) {
+	   var r = Math.round(rgba[0]/255 * 100),
+	       g = Math.round(rgba[1]/255 * 100),
+	       b = Math.round(rgba[2]/255 * 100);
+	   return "rgba(" + r + "%, " + g + "%, " + b + "%, " + (alpha || rgba[3] || 1) + ")";
+	}
+
+	function hslString(hsla, alpha) {
+	   if (alpha < 1 || (hsla[3] && hsla[3] < 1)) {
+	      return hslaString(hsla, alpha);
+	   }
+	   return "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)";
+	}
+
+	function hslaString(hsla, alpha) {
+	   if (alpha === undefined) {
+	      alpha = (hsla[3] !== undefined ? hsla[3] : 1);
+	   }
+	   return "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, "
+	           + alpha + ")";
+	}
+
+	// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax
+	// (hwb have alpha optional & 1 is default value)
+	function hwbString(hwb, alpha) {
+	   if (alpha === undefined) {
+	      alpha = (hwb[3] !== undefined ? hwb[3] : 1);
+	   }
+	   return "hwb(" + hwb[0] + ", " + hwb[1] + "%, " + hwb[2] + "%"
+	           + (alpha !== undefined && alpha !== 1 ? ", " + alpha : "") + ")";
+	}
+
+	function keyword(rgb) {
+	  return reverseNames[rgb.slice(0, 3)];
+	}
+
+	// helpers
+	function scale(num, min, max) {
+	   return Math.min(Math.max(min, num), max);
+	}
+
+	function hexDouble(num) {
+	  var str = num.toString(16).toUpperCase();
+	  return (str.length < 2) ? "0" + str : str;
+	}
+
+
+	//create a list of reverse color names
+	var reverseNames = {};
+	for (var name in colorNames) {
+	   reverseNames[colorNames[name]] = name;
+	}
+
+
+/***/ },
+/* 17 */
+/***/ function(module, exports) {
+
+	module.exports = {
+		"aliceblue": [240, 248, 255],
+		"antiquewhite": [250, 235, 215],
+		"aqua": [0, 255, 255],
+		"aquamarine": [127, 255, 212],
+		"azure": [240, 255, 255],
+		"beige": [245, 245, 220],
+		"bisque": [255, 228, 196],
+		"black": [0, 0, 0],
+		"blanchedalmond": [255, 235, 205],
+		"blue": [0, 0, 255],
+		"blueviolet": [138, 43, 226],
+		"brown": [165, 42, 42],
+		"burlywood": [222, 184, 135],
+		"cadetblue": [95, 158, 160],
+		"chartreuse": [127, 255, 0],
+		"chocolate": [210, 105, 30],
+		"coral": [255, 127, 80],
+		"cornflowerblue": [100, 149, 237],
+		"cornsilk": [255, 248, 220],
+		"crimson": [220, 20, 60],
+		"cyan": [0, 255, 255],
+		"darkblue": [0, 0, 139],
+		"darkcyan": [0, 139, 139],
+		"darkgoldenrod": [184, 134, 11],
+		"darkgray": [169, 169, 169],
+		"darkgreen": [0, 100, 0],
+		"darkgrey": [169, 169, 169],
+		"darkkhaki": [189, 183, 107],
+		"darkmagenta": [139, 0, 139],
+		"darkolivegreen": [85, 107, 47],
+		"darkorange": [255, 140, 0],
+		"darkorchid": [153, 50, 204],
+		"darkred": [139, 0, 0],
+		"darksalmon": [233, 150, 122],
+		"darkseagreen": [143, 188, 143],
+		"darkslateblue": [72, 61, 139],
+		"darkslategray": [47, 79, 79],
+		"darkslategrey": [47, 79, 79],
+		"darkturquoise": [0, 206, 209],
+		"darkviolet": [148, 0, 211],
+		"deeppink": [255, 20, 147],
+		"deepskyblue": [0, 191, 255],
+		"dimgray": [105, 105, 105],
+		"dimgrey": [105, 105, 105],
+		"dodgerblue": [30, 144, 255],
+		"firebrick": [178, 34, 34],
+		"floralwhite": [255, 250, 240],
+		"forestgreen": [34, 139, 34],
+		"fuchsia": [255, 0, 255],
+		"gainsboro": [220, 220, 220],
+		"ghostwhite": [248, 248, 255],
+		"gold": [255, 215, 0],
+		"goldenrod": [218, 165, 32],
+		"gray": [128, 128, 128],
+		"green": [0, 128, 0],
+		"greenyellow": [173, 255, 47],
+		"grey": [128, 128, 128],
+		"honeydew": [240, 255, 240],
+		"hotpink": [255, 105, 180],
+		"indianred": [205, 92, 92],
+		"indigo": [75, 0, 130],
+		"ivory": [255, 255, 240],
+		"khaki": [240, 230, 140],
+		"lavender": [230, 230, 250],
+		"lavenderblush": [255, 240, 245],
+		"lawngreen": [124, 252, 0],
+		"lemonchiffon": [255, 250, 205],
+		"lightblue": [173, 216, 230],
+		"lightcoral": [240, 128, 128],
+		"lightcyan": [224, 255, 255],
+		"lightgoldenrodyellow": [250, 250, 210],
+		"lightgray": [211, 211, 211],
+		"lightgreen": [144, 238, 144],
+		"lightgrey": [211, 211, 211],
+		"lightpink": [255, 182, 193],
+		"lightsalmon": [255, 160, 122],
+		"lightseagreen": [32, 178, 170],
+		"lightskyblue": [135, 206, 250],
+		"lightslategray": [119, 136, 153],
+		"lightslategrey": [119, 136, 153],
+		"lightsteelblue": [176, 196, 222],
+		"lightyellow": [255, 255, 224],
+		"lime": [0, 255, 0],
+		"limegreen": [50, 205, 50],
+		"linen": [250, 240, 230],
+		"magenta": [255, 0, 255],
+		"maroon": [128, 0, 0],
+		"mediumaquamarine": [102, 205, 170],
+		"mediumblue": [0, 0, 205],
+		"mediumorchid": [186, 85, 211],
+		"mediumpurple": [147, 112, 219],
+		"mediumseagreen": [60, 179, 113],
+		"mediumslateblue": [123, 104, 238],
+		"mediumspringgreen": [0, 250, 154],
+		"mediumturquoise": [72, 209, 204],
+		"mediumvioletred": [199, 21, 133],
+		"midnightblue": [25, 25, 112],
+		"mintcream": [245, 255, 250],
+		"mistyrose": [255, 228, 225],
+		"moccasin": [255, 228, 181],
+		"navajowhite": [255, 222, 173],
+		"navy": [0, 0, 128],
+		"oldlace": [253, 245, 230],
+		"olive": [128, 128, 0],
+		"olivedrab": [107, 142, 35],
+		"orange": [255, 165, 0],
+		"orangered": [255, 69, 0],
+		"orchid": [218, 112, 214],
+		"palegoldenrod": [238, 232, 170],
+		"palegreen": [152, 251, 152],
+		"paleturquoise": [175, 238, 238],
+		"palevioletred": [219, 112, 147],
+		"papayawhip": [255, 239, 213],
+		"peachpuff": [255, 218, 185],
+		"peru": [205, 133, 63],
+		"pink": [255, 192, 203],
+		"plum": [221, 160, 221],
+		"powderblue": [176, 224, 230],
+		"purple": [128, 0, 128],
+		"rebeccapurple": [102, 51, 153],
+		"red": [255, 0, 0],
+		"rosybrown": [188, 143, 143],
+		"royalblue": [65, 105, 225],
+		"saddlebrown": [139, 69, 19],
+		"salmon": [250, 128, 114],
+		"sandybrown": [244, 164, 96],
+		"seagreen": [46, 139, 87],
+		"seashell": [255, 245, 238],
+		"sienna": [160, 82, 45],
+		"silver": [192, 192, 192],
+		"skyblue": [135, 206, 235],
+		"slateblue": [106, 90, 205],
+		"slategray": [112, 128, 144],
+		"slategrey": [112, 128, 144],
+		"snow": [255, 250, 250],
+		"springgreen": [0, 255, 127],
+		"steelblue": [70, 130, 180],
+		"tan": [210, 180, 140],
+		"teal": [0, 128, 128],
+		"thistle": [216, 191, 216],
+		"tomato": [255, 99, 71],
+		"turquoise": [64, 224, 208],
+		"violet": [238, 130, 238],
+		"wheat": [245, 222, 179],
+		"white": [255, 255, 255],
+		"whitesmoke": [245, 245, 245],
+		"yellow": [255, 255, 0],
+		"yellowgreen": [154, 205, 50]
+	};
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var color = __webpack_require__(13);
+	var helpers = __webpack_require__(7);
+
+	function interpolate(start, view, model, ease) {
+		var keys = Object.keys(model);
+		var i, ilen, key, actual, origin, target, type, c0, c1;
+
+		for (i = 0, ilen = keys.length; i < ilen; ++i) {
+			key = keys[i];
+
+			target = model[key];
+
+			// if a value is added to the model after pivot() has been called, the view
+			// doesn't contain it, so let's initialize the view to the target value.
+			if (!view.hasOwnProperty(key)) {
+				view[key] = target;
+			}
+
+			actual = view[key];
+
+			if (actual === target || key[0] === '_') {
+				continue;
+			}
+
+			if (!start.hasOwnProperty(key)) {
+				start[key] = actual;
+			}
+
+			origin = start[key];
+
+			type = typeof target;
+
+			if (type === typeof origin) {
+				if (type === 'string') {
+					c0 = color(origin);
+					if (c0.valid) {
+						c1 = color(target);
+						if (c1.valid) {
+							view[key] = c1.mix(c0, ease).rgbString();
+							continue;
+						}
+					}
+				} else if (type === 'number' && isFinite(origin) && isFinite(target)) {
+					view[key] = origin + (target - origin) * ease;
+					continue;
+				}
+			}
+
+			view[key] = target;
+		}
+	}
+
+	var Element = function(configuration) {
+		helpers.extend(this, configuration);
+		this.initialize.apply(this, arguments);
+	};
+
+	helpers.extend(Element.prototype, {
+
+		initialize: function() {
+			this.hidden = false;
+		},
+
+		pivot: function() {
+			var me = this;
+			if (!me._view) {
+				me._view = helpers.clone(me._model);
+			}
+			me._start = {};
+			return me;
+		},
+
+		transition: function(ease) {
+			var me = this;
+			var model = me._model;
+			var start = me._start;
+			var view = me._view;
+
+			// No animation -> No Transition
+			if (!model || ease === 1) {
+				me._view = model;
+				me._start = null;
+				return me;
+			}
+
+			if (!view) {
+				view = me._view = {};
+			}
+
+			if (!start) {
+				start = me._start = {};
+			}
+
+			interpolate(start, view, model, ease);
+
+			return me;
+		},
+
+		tooltipPosition: function() {
+			return {
+				x: this._model.x,
+				y: this._model.y
+			};
+		},
+
+		hasValue: function() {
+			return helpers.isNumber(this._model.x) && helpers.isNumber(this._model.y);
+		}
+	});
+
+	Element.extend = helpers.inherits;
+
+	module.exports = Element;
+
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = {};
+	module.exports.Arc = __webpack_require__(20);
+	module.exports.Line = __webpack_require__(21);
+	module.exports.Point = __webpack_require__(22);
+	module.exports.Rectangle = __webpack_require__(23);
+
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('global', {
+		elements: {
+			arc: {
+				backgroundColor: defaults.global.defaultColor,
+				borderColor: '#fff',
+				borderWidth: 2
+			}
+		}
+	});
+
+	module.exports = Element.extend({
+		inLabelRange: function(mouseX) {
+			var vm = this._view;
+
+			if (vm) {
+				return (Math.pow(mouseX - vm.x, 2) < Math.pow(vm.radius + vm.hoverRadius, 2));
+			}
+			return false;
+		},
+
+		inRange: function(chartX, chartY) {
+			var vm = this._view;
+
+			if (vm) {
+				var pointRelativePosition = helpers.getAngleFromPoint(vm, {x: chartX, y: chartY});
+				var	angle = pointRelativePosition.angle;
+				var distance = pointRelativePosition.distance;
+
+				// Sanitise angle range
+				var startAngle = vm.startAngle;
+				var endAngle = vm.endAngle;
+				while (endAngle < startAngle) {
+					endAngle += 2.0 * Math.PI;
+				}
+				while (angle > endAngle) {
+					angle -= 2.0 * Math.PI;
+				}
+				while (angle < startAngle) {
+					angle += 2.0 * Math.PI;
+				}
+
+				// Check if within the range of the open/close angle
+				var betweenAngles = (angle >= startAngle && angle <= endAngle);
+				var withinRadius = (distance >= vm.innerRadius && distance <= vm.outerRadius);
+
+				return (betweenAngles && withinRadius);
+			}
+			return false;
+		},
+
+		getCenterPoint: function() {
+			var vm = this._view;
+			var halfAngle = (vm.startAngle + vm.endAngle) / 2;
+			var halfRadius = (vm.innerRadius + vm.outerRadius) / 2;
+			return {
+				x: vm.x + Math.cos(halfAngle) * halfRadius,
+				y: vm.y + Math.sin(halfAngle) * halfRadius
+			};
+		},
+
+		getArea: function() {
+			var vm = this._view;
+			return Math.PI * ((vm.endAngle - vm.startAngle) / (2 * Math.PI)) * (Math.pow(vm.outerRadius, 2) - Math.pow(vm.innerRadius, 2));
+		},
+
+		tooltipPosition: function() {
+			var vm = this._view;
+			var centreAngle = vm.startAngle + ((vm.endAngle - vm.startAngle) / 2);
+			var rangeFromCentre = (vm.outerRadius - vm.innerRadius) / 2 + vm.innerRadius;
+
+			return {
+				x: vm.x + (Math.cos(centreAngle) * rangeFromCentre),
+				y: vm.y + (Math.sin(centreAngle) * rangeFromCentre)
+			};
+		},
+
+		draw: function() {
+			var ctx = this._chart.ctx;
+			var vm = this._view;
+			var sA = vm.startAngle;
+			var eA = vm.endAngle;
+
+			ctx.beginPath();
+
+			ctx.arc(vm.x, vm.y, vm.outerRadius, sA, eA);
+			ctx.arc(vm.x, vm.y, vm.innerRadius, eA, sA, true);
+
+			ctx.closePath();
+			ctx.strokeStyle = vm.borderColor;
+			ctx.lineWidth = vm.borderWidth;
+
+			ctx.fillStyle = vm.backgroundColor;
+
+			ctx.fill();
+			ctx.lineJoin = 'bevel';
+
+			if (vm.borderWidth) {
+				ctx.stroke();
+			}
+		}
+	});
+
+
+/***/ },
+/* 21 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	var globalDefaults = defaults.global;
+
+	defaults._set('global', {
+		elements: {
+			line: {
+				tension: 0.4,
+				backgroundColor: globalDefaults.defaultColor,
+				borderWidth: 3,
+				borderColor: globalDefaults.defaultColor,
+				borderCapStyle: 'butt',
+				borderDash: [],
+				borderDashOffset: 0.0,
+				borderJoinStyle: 'miter',
+				capBezierPoints: true,
+				fill: true, // do we fill in the area between the line and its base axis
+			}
+		}
+	});
+
+	module.exports = Element.extend({
+		draw: function() {
+			var me = this;
+			var vm = me._view;
+			var ctx = me._chart.ctx;
+			var spanGaps = vm.spanGaps;
+			var points = me._children.slice(); // clone array
+			var globalOptionLineElements = globalDefaults.elements.line;
+			var lastDrawnIndex = -1;
+			var index, current, previous, currentVM;
+
+			// If we are looping, adding the first point again
+			if (me._loop && points.length) {
+				points.push(points[0]);
+			}
+
+			ctx.save();
+
+			// Stroke Line Options
+			ctx.lineCap = vm.borderCapStyle || globalOptionLineElements.borderCapStyle;
+
+			// IE 9 and 10 do not support line dash
+			if (ctx.setLineDash) {
+				ctx.setLineDash(vm.borderDash || globalOptionLineElements.borderDash);
+			}
+
+			ctx.lineDashOffset = vm.borderDashOffset || globalOptionLineElements.borderDashOffset;
+			ctx.lineJoin = vm.borderJoinStyle || globalOptionLineElements.borderJoinStyle;
+			ctx.lineWidth = vm.borderWidth || globalOptionLineElements.borderWidth;
+			ctx.strokeStyle = vm.borderColor || globalDefaults.defaultColor;
+
+			// Stroke Line
+			ctx.beginPath();
+			lastDrawnIndex = -1;
+
+			for (index = 0; index < points.length; ++index) {
+				current = points[index];
+				previous = helpers.previousItem(points, index);
+				currentVM = current._view;
+
+				// First point moves to it's starting position no matter what
+				if (index === 0) {
+					if (!currentVM.skip) {
+						ctx.moveTo(currentVM.x, currentVM.y);
+						lastDrawnIndex = index;
+					}
+				} else {
+					previous = lastDrawnIndex === -1 ? previous : points[lastDrawnIndex];
+
+					if (!currentVM.skip) {
+						if ((lastDrawnIndex !== (index - 1) && !spanGaps) || lastDrawnIndex === -1) {
+							// There was a gap and this is the first point after the gap
+							ctx.moveTo(currentVM.x, currentVM.y);
+						} else {
+							// Line to next point
+							helpers.canvas.lineTo(ctx, previous._view, current._view);
+						}
+						lastDrawnIndex = index;
+					}
+				}
+			}
+
+			ctx.stroke();
+			ctx.restore();
+		}
+	});
+
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	var defaultColor = defaults.global.defaultColor;
+
+	defaults._set('global', {
+		elements: {
+			point: {
+				radius: 3,
+				pointStyle: 'circle',
+				backgroundColor: defaultColor,
+				borderColor: defaultColor,
+				borderWidth: 1,
+				// Hover
+				hitRadius: 1,
+				hoverRadius: 4,
+				hoverBorderWidth: 1
+			}
+		}
+	});
+
+	function xRange(mouseX) {
+		var vm = this._view;
+		return vm ? (Math.pow(mouseX - vm.x, 2) < Math.pow(vm.radius + vm.hitRadius, 2)) : false;
+	}
+
+	function yRange(mouseY) {
+		var vm = this._view;
+		return vm ? (Math.pow(mouseY - vm.y, 2) < Math.pow(vm.radius + vm.hitRadius, 2)) : false;
+	}
+
+	module.exports = Element.extend({
+		inRange: function(mouseX, mouseY) {
+			var vm = this._view;
+			return vm ? ((Math.pow(mouseX - vm.x, 2) + Math.pow(mouseY - vm.y, 2)) < Math.pow(vm.hitRadius + vm.radius, 2)) : false;
+		},
+
+		inLabelRange: xRange,
+		inXRange: xRange,
+		inYRange: yRange,
+
+		getCenterPoint: function() {
+			var vm = this._view;
+			return {
+				x: vm.x,
+				y: vm.y
+			};
+		},
+
+		getArea: function() {
+			return Math.PI * Math.pow(this._view.radius, 2);
+		},
+
+		tooltipPosition: function() {
+			var vm = this._view;
+			return {
+				x: vm.x,
+				y: vm.y,
+				padding: vm.radius + vm.borderWidth
+			};
+		},
+
+		draw: function(chartArea) {
+			var vm = this._view;
+			var model = this._model;
+			var ctx = this._chart.ctx;
+			var pointStyle = vm.pointStyle;
+			var radius = vm.radius;
+			var x = vm.x;
+			var y = vm.y;
+			var color = helpers.color;
+			var errMargin = 1.01; // 1.01 is margin for Accumulated error. (Especially Edge, IE.)
+			var ratio = 0;
+
+			if (vm.skip) {
+				return;
+			}
+
+			ctx.strokeStyle = vm.borderColor || defaultColor;
+			ctx.lineWidth = helpers.valueOrDefault(vm.borderWidth, defaults.global.elements.point.borderWidth);
+			ctx.fillStyle = vm.backgroundColor || defaultColor;
+
+			// Cliping for Points.
+			// going out from inner charArea?
+			if ((chartArea !== undefined) && ((model.x < chartArea.left) || (chartArea.right * errMargin < model.x) || (model.y < chartArea.top) || (chartArea.bottom * errMargin < model.y))) {
+				// Point fade out
+				if (model.x < chartArea.left) {
+					ratio = (x - model.x) / (chartArea.left - model.x);
+				} else if (chartArea.right * errMargin < model.x) {
+					ratio = (model.x - x) / (model.x - chartArea.right);
+				} else if (model.y < chartArea.top) {
+					ratio = (y - model.y) / (chartArea.top - model.y);
+				} else if (chartArea.bottom * errMargin < model.y) {
+					ratio = (model.y - y) / (model.y - chartArea.bottom);
+				}
+				ratio = Math.round(ratio * 100) / 100;
+				ctx.strokeStyle = color(ctx.strokeStyle).alpha(ratio).rgbString();
+				ctx.fillStyle = color(ctx.fillStyle).alpha(ratio).rgbString();
+			}
+
+			helpers.canvas.drawPoint(ctx, pointStyle, radius, x, y);
+		}
+	});
+
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+
+	defaults._set('global', {
+		elements: {
+			rectangle: {
+				backgroundColor: defaults.global.defaultColor,
+				borderColor: defaults.global.defaultColor,
+				borderSkipped: 'bottom',
+				borderWidth: 0
+			}
+		}
+	});
+
+	function isVertical(bar) {
+		return bar._view.width !== undefined;
+	}
+
+	/**
+	 * Helper function to get the bounds of the bar regardless of the orientation
+	 * @param bar {Chart.Element.Rectangle} the bar
+	 * @return {Bounds} bounds of the bar
+	 * @private
+	 */
+	function getBarBounds(bar) {
+		var vm = bar._view;
+		var x1, x2, y1, y2;
+
+		if (isVertical(bar)) {
+			// vertical
+			var halfWidth = vm.width / 2;
+			x1 = vm.x - halfWidth;
+			x2 = vm.x + halfWidth;
+			y1 = Math.min(vm.y, vm.base);
+			y2 = Math.max(vm.y, vm.base);
+		} else {
+			// horizontal bar
+			var halfHeight = vm.height / 2;
+			x1 = Math.min(vm.x, vm.base);
+			x2 = Math.max(vm.x, vm.base);
+			y1 = vm.y - halfHeight;
+			y2 = vm.y + halfHeight;
+		}
+
+		return {
+			left: x1,
+			top: y1,
+			right: x2,
+			bottom: y2
+		};
+	}
+
+	module.exports = Element.extend({
+		draw: function() {
+			var ctx = this._chart.ctx;
+			var vm = this._view;
+			var left, right, top, bottom, signX, signY, borderSkipped;
+			var borderWidth = vm.borderWidth;
+
+			if (!vm.horizontal) {
+				// bar
+				left = vm.x - vm.width / 2;
+				right = vm.x + vm.width / 2;
+				top = vm.y;
+				bottom = vm.base;
+				signX = 1;
+				signY = bottom > top ? 1 : -1;
+				borderSkipped = vm.borderSkipped || 'bottom';
+			} else {
+				// horizontal bar
+				left = vm.base;
+				right = vm.x;
+				top = vm.y - vm.height / 2;
+				bottom = vm.y + vm.height / 2;
+				signX = right > left ? 1 : -1;
+				signY = 1;
+				borderSkipped = vm.borderSkipped || 'left';
+			}
+
+			// Canvas doesn't allow us to stroke inside the width so we can
+			// adjust the sizes to fit if we're setting a stroke on the line
+			if (borderWidth) {
+				// borderWidth shold be less than bar width and bar height.
+				var barSize = Math.min(Math.abs(left - right), Math.abs(top - bottom));
+				borderWidth = borderWidth > barSize ? barSize : borderWidth;
+				var halfStroke = borderWidth / 2;
+				// Adjust borderWidth when bar top position is near vm.base(zero).
+				var borderLeft = left + (borderSkipped !== 'left' ? halfStroke * signX : 0);
+				var borderRight = right + (borderSkipped !== 'right' ? -halfStroke * signX : 0);
+				var borderTop = top + (borderSkipped !== 'top' ? halfStroke * signY : 0);
+				var borderBottom = bottom + (borderSkipped !== 'bottom' ? -halfStroke * signY : 0);
+				// not become a vertical line?
+				if (borderLeft !== borderRight) {
+					top = borderTop;
+					bottom = borderBottom;
+				}
+				// not become a horizontal line?
+				if (borderTop !== borderBottom) {
+					left = borderLeft;
+					right = borderRight;
+				}
+			}
+
+			ctx.beginPath();
+			ctx.fillStyle = vm.backgroundColor;
+			ctx.strokeStyle = vm.borderColor;
+			ctx.lineWidth = borderWidth;
+
+			// Corner points, from bottom-left to bottom-right clockwise
+			// | 1 2 |
+			// | 0 3 |
+			var corners = [
+				[left, bottom],
+				[left, top],
+				[right, top],
+				[right, bottom]
+			];
+
+			// Find first (starting) corner with fallback to 'bottom'
+			var borders = ['bottom', 'left', 'top', 'right'];
+			var startCorner = borders.indexOf(borderSkipped, 0);
+			if (startCorner === -1) {
+				startCorner = 0;
+			}
+
+			function cornerAt(index) {
+				return corners[(startCorner + index) % 4];
+			}
+
+			// Draw rectangle from 'startCorner'
+			var corner = cornerAt(0);
+			ctx.moveTo(corner[0], corner[1]);
+
+			for (var i = 1; i < 4; i++) {
+				corner = cornerAt(i);
+				ctx.lineTo(corner[0], corner[1]);
+			}
+
+			ctx.fill();
+			if (borderWidth) {
+				ctx.stroke();
+			}
+		},
+
+		height: function() {
+			var vm = this._view;
+			return vm.base - vm.y;
+		},
+
+		inRange: function(mouseX, mouseY) {
+			var inRange = false;
+
+			if (this._view) {
+				var bounds = getBarBounds(this);
+				inRange = mouseX >= bounds.left && mouseX <= bounds.right && mouseY >= bounds.top && mouseY <= bounds.bottom;
+			}
+
+			return inRange;
+		},
+
+		inLabelRange: function(mouseX, mouseY) {
+			var me = this;
+			if (!me._view) {
+				return false;
+			}
+
+			var inRange = false;
+			var bounds = getBarBounds(me);
+
+			if (isVertical(me)) {
+				inRange = mouseX >= bounds.left && mouseX <= bounds.right;
+			} else {
+				inRange = mouseY >= bounds.top && mouseY <= bounds.bottom;
+			}
+
+			return inRange;
+		},
+
+		inXRange: function(mouseX) {
+			var bounds = getBarBounds(this);
+			return mouseX >= bounds.left && mouseX <= bounds.right;
+		},
+
+		inYRange: function(mouseY) {
+			var bounds = getBarBounds(this);
+			return mouseY >= bounds.top && mouseY <= bounds.bottom;
+		},
+
+		getCenterPoint: function() {
+			var vm = this._view;
+			var x, y;
+			if (isVertical(this)) {
+				x = vm.x;
+				y = (vm.y + vm.base) / 2;
+			} else {
+				x = (vm.x + vm.base) / 2;
+				y = vm.y;
+			}
+
+			return {x: x, y: y};
+		},
+
+		getArea: function() {
+			var vm = this._view;
+			return vm.width * Math.abs(vm.y - vm.base);
+		},
+
+		tooltipPosition: function() {
+			var vm = this._view;
+			return {
+				x: vm.x,
+				y: vm.y
+			};
+		}
+	});
+
+
+/***/ },
+/* 24 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+
+	/**
+	 * Helper function to get relative position for an event
+	 * @param {Event|IEvent} event - The event to get the position for
+	 * @param {Chart} chart - The chart
+	 * @returns {Point} the event position
+	 */
+	function getRelativePosition(e, chart) {
+		if (e.native) {
+			return {
+				x: e.x,
+				y: e.y
+			};
+		}
+
+		return helpers.getRelativePosition(e, chart);
+	}
+
+	/**
+	 * Helper function to traverse all of the visible elements in the chart
+	 * @param chart {chart} the chart
+	 * @param handler {Function} the callback to execute for each visible item
+	 */
+	function parseVisibleItems(chart, handler) {
+		var datasets = chart.data.datasets;
+		var meta, i, j, ilen, jlen;
+
+		for (i = 0, ilen = datasets.length; i < ilen; ++i) {
+			if (!chart.isDatasetVisible(i)) {
+				continue;
+			}
+
+			meta = chart.getDatasetMeta(i);
+			for (j = 0, jlen = meta.data.length; j < jlen; ++j) {
+				var element = meta.data[j];
+				if (!element._view.skip) {
+					handler(element);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Helper function to get the items that intersect the event position
+	 * @param items {ChartElement[]} elements to filter
+	 * @param position {Point} the point to be nearest to
+	 * @return {ChartElement[]} the nearest items
+	 */
+	function getIntersectItems(chart, position) {
+		var elements = [];
+
+		parseVisibleItems(chart, function(element) {
+			if (element.inRange(position.x, position.y)) {
+				elements.push(element);
+			}
+		});
+
+		return elements;
+	}
+
+	/**
+	 * Helper function to get the items nearest to the event position considering all visible items in teh chart
+	 * @param chart {Chart} the chart to look at elements from
+	 * @param position {Point} the point to be nearest to
+	 * @param intersect {Boolean} if true, only consider items that intersect the position
+	 * @param distanceMetric {Function} function to provide the distance between points
+	 * @return {ChartElement[]} the nearest items
+	 */
+	function getNearestItems(chart, position, intersect, distanceMetric) {
+		var minDistance = Number.POSITIVE_INFINITY;
+		var nearestItems = [];
+
+		parseVisibleItems(chart, function(element) {
+			if (intersect && !element.inRange(position.x, position.y)) {
+				return;
+			}
+
+			var center = element.getCenterPoint();
+			var distance = distanceMetric(position, center);
+
+			if (distance < minDistance) {
+				nearestItems = [element];
+				minDistance = distance;
+			} else if (distance === minDistance) {
+				// Can have multiple items at the same distance in which case we sort by size
+				nearestItems.push(element);
+			}
+		});
+
+		return nearestItems;
+	}
+
+	/**
+	 * Get a distance metric function for two points based on the
+	 * axis mode setting
+	 * @param {String} axis the axis mode. x|y|xy
+	 */
+	function getDistanceMetricForAxis(axis) {
+		var useX = axis.indexOf('x') !== -1;
+		var useY = axis.indexOf('y') !== -1;
+
+		return function(pt1, pt2) {
+			var deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;
+			var deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;
+			return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
+		};
+	}
+
+	function indexMode(chart, e, options) {
+		var position = getRelativePosition(e, chart);
+		// Default axis for index mode is 'x' to match old behaviour
+		options.axis = options.axis || 'x';
+		var distanceMetric = getDistanceMetricForAxis(options.axis);
+		var items = options.intersect ? getIntersectItems(chart, position) : getNearestItems(chart, position, false, distanceMetric);
+		var elements = [];
+
+		if (!items.length) {
+			return [];
+		}
+
+		chart.data.datasets.forEach(function(dataset, datasetIndex) {
+			if (chart.isDatasetVisible(datasetIndex)) {
+				var meta = chart.getDatasetMeta(datasetIndex);
+				var element = meta.data[items[0]._index];
+
+				// don't count items that are skipped (null data)
+				if (element && !element._view.skip) {
+					elements.push(element);
+				}
+			}
+		});
+
+		return elements;
+	}
+
+	/**
+	 * @interface IInteractionOptions
+	 */
+	/**
+	 * If true, only consider items that intersect the point
+	 * @name IInterfaceOptions#boolean
+	 * @type Boolean
+	 */
+
+	/**
+	 * Contains interaction related functions
+	 * @namespace Chart.Interaction
+	 */
+	module.exports = {
+		// Helper function for different modes
+		modes: {
+			single: function(chart, e) {
+				var position = getRelativePosition(e, chart);
+				var elements = [];
+
+				parseVisibleItems(chart, function(element) {
+					if (element.inRange(position.x, position.y)) {
+						elements.push(element);
+						return elements;
+					}
+				});
+
+				return elements.slice(0, 1);
+			},
+
+			/**
+			 * @function Chart.Interaction.modes.label
+			 * @deprecated since version 2.4.0
+			 * @todo remove at version 3
+			 * @private
+			 */
+			label: indexMode,
+
+			/**
+			 * Returns items at the same index. If the options.intersect parameter is true, we only return items if we intersect something
+			 * If the options.intersect mode is false, we find the nearest item and return the items at the same index as that item
+			 * @function Chart.Interaction.modes.index
+			 * @since v2.4.0
+			 * @param chart {chart} the chart we are returning items from
+			 * @param e {Event} the event we are find things at
+			 * @param options {IInteractionOptions} options to use during interaction
+			 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+			 */
+			index: indexMode,
+
+			/**
+			 * Returns items in the same dataset. If the options.intersect parameter is true, we only return items if we intersect something
+			 * If the options.intersect is false, we find the nearest item and return the items in that dataset
+			 * @function Chart.Interaction.modes.dataset
+			 * @param chart {chart} the chart we are returning items from
+			 * @param e {Event} the event we are find things at
+			 * @param options {IInteractionOptions} options to use during interaction
+			 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+			 */
+			dataset: function(chart, e, options) {
+				var position = getRelativePosition(e, chart);
+				options.axis = options.axis || 'xy';
+				var distanceMetric = getDistanceMetricForAxis(options.axis);
+				var items = options.intersect ? getIntersectItems(chart, position) : getNearestItems(chart, position, false, distanceMetric);
+
+				if (items.length > 0) {
+					items = chart.getDatasetMeta(items[0]._datasetIndex).data;
+				}
+
+				return items;
+			},
+
+			/**
+			 * @function Chart.Interaction.modes.x-axis
+			 * @deprecated since version 2.4.0. Use index mode and intersect == true
+			 * @todo remove at version 3
+			 * @private
+			 */
+			'x-axis': function(chart, e) {
+				return indexMode(chart, e, {intersect: true});
+			},
+
+			/**
+			 * Point mode returns all elements that hit test based on the event position
+			 * of the event
+			 * @function Chart.Interaction.modes.intersect
+			 * @param chart {chart} the chart we are returning items from
+			 * @param e {Event} the event we are find things at
+			 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+			 */
+			point: function(chart, e) {
+				var position = getRelativePosition(e, chart);
+				return getIntersectItems(chart, position);
+			},
+
+			/**
+			 * nearest mode returns the element closest to the point
+			 * @function Chart.Interaction.modes.intersect
+			 * @param chart {chart} the chart we are returning items from
+			 * @param e {Event} the event we are find things at
+			 * @param options {IInteractionOptions} options to use
+			 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+			 */
+			nearest: function(chart, e, options) {
+				var position = getRelativePosition(e, chart);
+				options.axis = options.axis || 'xy';
+				var distanceMetric = getDistanceMetricForAxis(options.axis);
+				var nearestItems = getNearestItems(chart, position, options.intersect, distanceMetric);
+
+				// We have multiple items at the same distance from the event. Now sort by smallest
+				if (nearestItems.length > 1) {
+					nearestItems.sort(function(a, b) {
+						var sizeA = a.getArea();
+						var sizeB = b.getArea();
+						var ret = sizeA - sizeB;
+
+						if (ret === 0) {
+							// if equal sort by dataset index
+							ret = a._datasetIndex - b._datasetIndex;
+						}
+
+						return ret;
+					});
+				}
+
+				// Return only 1 item
+				return nearestItems.slice(0, 1);
+			},
+
+			/**
+			 * x mode returns the elements that hit-test at the current x coordinate
+			 * @function Chart.Interaction.modes.x
+			 * @param chart {chart} the chart we are returning items from
+			 * @param e {Event} the event we are find things at
+			 * @param options {IInteractionOptions} options to use
+			 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+			 */
+			x: function(chart, e, options) {
+				var position = getRelativePosition(e, chart);
+				var items = [];
+				var intersectsItem = false;
+
+				parseVisibleItems(chart, function(element) {
+					if (element.inXRange(position.x)) {
+						items.push(element);
+					}
+
+					if (element.inRange(position.x, position.y)) {
+						intersectsItem = true;
+					}
+				});
+
+				// If we want to trigger on an intersect and we don't have any items
+				// that intersect the position, return nothing
+				if (options.intersect && !intersectsItem) {
+					items = [];
+				}
+				return items;
+			},
+
+			/**
+			 * y mode returns the elements that hit-test at the current y coordinate
+			 * @function Chart.Interaction.modes.y
+			 * @param chart {chart} the chart we are returning items from
+			 * @param e {Event} the event we are find things at
+			 * @param options {IInteractionOptions} options to use
+			 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+			 */
+			y: function(chart, e, options) {
+				var position = getRelativePosition(e, chart);
+				var items = [];
+				var intersectsItem = false;
+
+				parseVisibleItems(chart, function(element) {
+					if (element.inYRange(position.y)) {
+						items.push(element);
+					}
+
+					if (element.inRange(position.x, position.y)) {
+						intersectsItem = true;
+					}
+				});
+
+				// If we want to trigger on an intersect and we don't have any items
+				// that intersect the position, return nothing
+				if (options.intersect && !intersectsItem) {
+					items = [];
+				}
+				return items;
+			}
+		}
+	};
+
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+	var basic = __webpack_require__(26);
+	var dom = __webpack_require__(27);
+
+	// @TODO Make possible to select another platform at build time.
+	var implementation = dom._enabled ? dom : basic;
+
+	/**
+	 * @namespace Chart.platform
+	 * @see https://chartjs.gitbooks.io/proposals/content/Platform.html
+	 * @since 2.4.0
+	 */
+	module.exports = helpers.extend({
+		/**
+		 * @since 2.7.0
+		 */
+		initialize: function() {},
+
+		/**
+		 * Called at chart construction time, returns a context2d instance implementing
+		 * the [W3C Canvas 2D Context API standard]{@link https://www.w3.org/TR/2dcontext/}.
+		 * @param {*} item - The native item from which to acquire context (platform specific)
+		 * @param {Object} options - The chart options
+		 * @returns {CanvasRenderingContext2D} context2d instance
+		 */
+		acquireContext: function() {},
+
+		/**
+		 * Called at chart destruction time, releases any resources associated to the context
+		 * previously returned by the acquireContext() method.
+		 * @param {CanvasRenderingContext2D} context - The context2d instance
+		 * @returns {Boolean} true if the method succeeded, else false
+		 */
+		releaseContext: function() {},
+
+		/**
+		 * Registers the specified listener on the given chart.
+		 * @param {Chart} chart - Chart from which to listen for event
+		 * @param {String} type - The ({@link IEvent}) type to listen for
+		 * @param {Function} listener - Receives a notification (an object that implements
+		 * the {@link IEvent} interface) when an event of the specified type occurs.
+		 */
+		addEventListener: function() {},
+
+		/**
+		 * Removes the specified listener previously registered with addEventListener.
+		 * @param {Chart} chart -Chart from which to remove the listener
+		 * @param {String} type - The ({@link IEvent}) type to remove
+		 * @param {Function} listener - The listener function to remove from the event target.
+		 */
+		removeEventListener: function() {}
+
+	}, implementation);
+
+	/**
+	 * @interface IPlatform
+	 * Allows abstracting platform dependencies away from the chart
+	 * @borrows Chart.platform.acquireContext as acquireContext
+	 * @borrows Chart.platform.releaseContext as releaseContext
+	 * @borrows Chart.platform.addEventListener as addEventListener
+	 * @borrows Chart.platform.removeEventListener as removeEventListener
+	 */
+
+	/**
+	 * @interface IEvent
+	 * @prop {String} type - The event type name, possible values are:
+	 * 'contextmenu', 'mouseenter', 'mousedown', 'mousemove', 'mouseup', 'mouseout',
+	 * 'click', 'dblclick', 'keydown', 'keypress', 'keyup' and 'resize'
+	 * @prop {*} native - The original native event (null for emulated events, e.g. 'resize')
+	 * @prop {Number} x - The mouse x position, relative to the canvas (null for incompatible events)
+	 * @prop {Number} y - The mouse y position, relative to the canvas (null for incompatible events)
+	 */
+
+
+/***/ },
+/* 26 */
+/***/ function(module, exports) {
+
+	/**
+	 * Platform fallback implementation (minimal).
+	 * @see https://github.com/chartjs/Chart.js/pull/4591#issuecomment-319575939
+	 */
+
+	module.exports = {
+		acquireContext: function(item) {
+			if (item && item.canvas) {
+				// Support for any object associated to a canvas (including a context2d)
+				item = item.canvas;
+			}
+
+			return item && item.getContext('2d') || null;
+		}
+	};
+
+
+/***/ },
+/* 27 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Chart.Platform implementation for targeting a web browser
+	 */
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+
+	var EXPANDO_KEY = '$chartjs';
+	var CSS_PREFIX = 'chartjs-';
+	var CSS_RENDER_MONITOR = CSS_PREFIX + 'render-monitor';
+	var CSS_RENDER_ANIMATION = CSS_PREFIX + 'render-animation';
+	var ANIMATION_START_EVENTS = ['animationstart', 'webkitAnimationStart'];
+
+	/**
+	 * DOM event types -> Chart.js event types.
+	 * Note: only events with different types are mapped.
+	 * @see https://developer.mozilla.org/en-US/docs/Web/Events
+	 */
+	var EVENT_TYPES = {
+		touchstart: 'mousedown',
+		touchmove: 'mousemove',
+		touchend: 'mouseup',
+		pointerenter: 'mouseenter',
+		pointerdown: 'mousedown',
+		pointermove: 'mousemove',
+		pointerup: 'mouseup',
+		pointerleave: 'mouseout',
+		pointerout: 'mouseout'
+	};
+
+	/**
+	 * The "used" size is the final value of a dimension property after all calculations have
+	 * been performed. This method uses the computed style of `element` but returns undefined
+	 * if the computed style is not expressed in pixels. That can happen in some cases where
+	 * `element` has a size relative to its parent and this last one is not yet displayed,
+	 * for example because of `display: none` on a parent node.
+	 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
+	 * @returns {Number} Size in pixels or undefined if unknown.
+	 */
+	function readUsedSize(element, property) {
+		var value = helpers.getStyle(element, property);
+		var matches = value && value.match(/^(\d+)(\.\d+)?px$/);
+		return matches ? Number(matches[1]) : undefined;
+	}
+
+	/**
+	 * Initializes the canvas style and render size without modifying the canvas display size,
+	 * since responsiveness is handled by the controller.resize() method. The config is used
+	 * to determine the aspect ratio to apply in case no explicit height has been specified.
+	 */
+	function initCanvas(canvas, config) {
+		var style = canvas.style;
+
+		// NOTE(SB) canvas.getAttribute('width') !== canvas.width: in the first case it
+		// returns null or '' if no explicit value has been set to the canvas attribute.
+		var renderHeight = canvas.getAttribute('height');
+		var renderWidth = canvas.getAttribute('width');
+
+		// Chart.js modifies some canvas values that we want to restore on destroy
+		canvas[EXPANDO_KEY] = {
+			initial: {
+				height: renderHeight,
+				width: renderWidth,
+				style: {
+					display: style.display,
+					height: style.height,
+					width: style.width
+				}
+			}
+		};
+
+		// Force canvas to display as block to avoid extra space caused by inline
+		// elements, which would interfere with the responsive resize process.
+		// https://github.com/chartjs/Chart.js/issues/2538
+		style.display = style.display || 'block';
+
+		if (renderWidth === null || renderWidth === '') {
+			var displayWidth = readUsedSize(canvas, 'width');
+			if (displayWidth !== undefined) {
+				canvas.width = displayWidth;
+			}
+		}
+
+		if (renderHeight === null || renderHeight === '') {
+			if (canvas.style.height === '') {
+				// If no explicit render height and style height, let's apply the aspect ratio,
+				// which one can be specified by the user but also by charts as default option
+				// (i.e. options.aspectRatio). If not specified, use canvas aspect ratio of 2.
+				canvas.height = canvas.width / (config.options.aspectRatio || 2);
+			} else {
+				var displayHeight = readUsedSize(canvas, 'height');
+				if (displayWidth !== undefined) {
+					canvas.height = displayHeight;
+				}
+			}
+		}
+
+		return canvas;
+	}
+
+	/**
+	 * Detects support for options object argument in addEventListener.
+	 * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+	 * @private
+	 */
+	var supportsEventListenerOptions = (function() {
+		var supports = false;
+		try {
+			var options = Object.defineProperty({}, 'passive', {
+				get: function() {
+					supports = true;
+				}
+			});
+			window.addEventListener('e', null, options);
+		} catch (e) {
+			// continue regardless of error
+		}
+		return supports;
+	}());
+
+	// Default passive to true as expected by Chrome for 'touchstart' and 'touchend' events.
+	// https://github.com/chartjs/Chart.js/issues/4287
+	var eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false;
+
+	function addEventListener(node, type, listener) {
+		node.addEventListener(type, listener, eventListenerOptions);
+	}
+
+	function removeEventListener(node, type, listener) {
+		node.removeEventListener(type, listener, eventListenerOptions);
+	}
+
+	function createEvent(type, chart, x, y, nativeEvent) {
+		return {
+			type: type,
+			chart: chart,
+			native: nativeEvent || null,
+			x: x !== undefined ? x : null,
+			y: y !== undefined ? y : null,
+		};
+	}
+
+	function fromNativeEvent(event, chart) {
+		var type = EVENT_TYPES[event.type] || event.type;
+		var pos = helpers.getRelativePosition(event, chart);
+		return createEvent(type, chart, pos.x, pos.y, event);
+	}
+
+	function throttled(fn, thisArg) {
+		var ticking = false;
+		var args = [];
+
+		return function() {
+			args = Array.prototype.slice.call(arguments);
+			thisArg = thisArg || this;
+
+			if (!ticking) {
+				ticking = true;
+				helpers.requestAnimFrame.call(window, function() {
+					ticking = false;
+					fn.apply(thisArg, args);
+				});
+			}
+		};
+	}
+
+	// Implementation based on https://github.com/marcj/css-element-queries
+	function createResizer(handler) {
+		var resizer = document.createElement('div');
+		var cls = CSS_PREFIX + 'size-monitor';
+		var maxSize = 1000000;
+		var style =
+			'position:absolute;' +
+			'left:0;' +
+			'top:0;' +
+			'right:0;' +
+			'bottom:0;' +
+			'overflow:hidden;' +
+			'pointer-events:none;' +
+			'visibility:hidden;' +
+			'z-index:-1;';
+
+		resizer.style.cssText = style;
+		resizer.className = cls;
+		resizer.innerHTML =
+			'<div class="' + cls + '-expand" style="' + style + '">' +
+				'<div style="' +
+					'position:absolute;' +
+					'width:' + maxSize + 'px;' +
+					'height:' + maxSize + 'px;' +
+					'left:0;' +
+					'top:0">' +
+				'</div>' +
+			'</div>' +
+			'<div class="' + cls + '-shrink" style="' + style + '">' +
+				'<div style="' +
+					'position:absolute;' +
+					'width:200%;' +
+					'height:200%;' +
+					'left:0; ' +
+					'top:0">' +
+				'</div>' +
+			'</div>';
+
+		var expand = resizer.childNodes[0];
+		var shrink = resizer.childNodes[1];
+
+		resizer._reset = function() {
+			expand.scrollLeft = maxSize;
+			expand.scrollTop = maxSize;
+			shrink.scrollLeft = maxSize;
+			shrink.scrollTop = maxSize;
+		};
+		var onScroll = function() {
+			resizer._reset();
+			handler();
+		};
+
+		addEventListener(expand, 'scroll', onScroll.bind(expand, 'expand'));
+		addEventListener(shrink, 'scroll', onScroll.bind(shrink, 'shrink'));
+
+		return resizer;
+	}
+
+	// https://davidwalsh.name/detect-node-insertion
+	function watchForRender(node, handler) {
+		var expando = node[EXPANDO_KEY] || (node[EXPANDO_KEY] = {});
+		var proxy = expando.renderProxy = function(e) {
+			if (e.animationName === CSS_RENDER_ANIMATION) {
+				handler();
+			}
+		};
+
+		helpers.each(ANIMATION_START_EVENTS, function(type) {
+			addEventListener(node, type, proxy);
+		});
+
+		node.classList.add(CSS_RENDER_MONITOR);
+	}
+
+	function unwatchForRender(node) {
+		var expando = node[EXPANDO_KEY] || {};
+		var proxy = expando.renderProxy;
+
+		if (proxy) {
+			helpers.each(ANIMATION_START_EVENTS, function(type) {
+				removeEventListener(node, type, proxy);
+			});
+
+			delete expando.renderProxy;
+		}
+
+		node.classList.remove(CSS_RENDER_MONITOR);
+	}
+
+	function addResizeListener(node, listener, chart) {
+		var expando = node[EXPANDO_KEY] || (node[EXPANDO_KEY] = {});
+
+		// Let's keep track of this added resizer and thus avoid DOM query when removing it.
+		var resizer = expando.resizer = createResizer(throttled(function() {
+			if (expando.resizer) {
+				return listener(createEvent('resize', chart));
+			}
+		}));
+
+		// The resizer needs to be attached to the node parent, so we first need to be
+		// sure that `node` is attached to the DOM before injecting the resizer element.
+		watchForRender(node, function() {
+			if (expando.resizer) {
+				var container = node.parentNode;
+				if (container && container !== resizer.parentNode) {
+					container.insertBefore(resizer, container.firstChild);
+				}
+
+				// The container size might have changed, let's reset the resizer state.
+				resizer._reset();
+			}
+		});
+	}
+
+	function removeResizeListener(node) {
+		var expando = node[EXPANDO_KEY] || {};
+		var resizer = expando.resizer;
+
+		delete expando.resizer;
+		unwatchForRender(node);
+
+		if (resizer && resizer.parentNode) {
+			resizer.parentNode.removeChild(resizer);
+		}
+	}
+
+	function injectCSS(platform, css) {
+		// http://stackoverflow.com/q/3922139
+		var style = platform._style || document.createElement('style');
+		if (!platform._style) {
+			platform._style = style;
+			css = '/* Chart.js */\n' + css;
+			style.setAttribute('type', 'text/css');
+			document.getElementsByTagName('head')[0].appendChild(style);
+		}
+
+		style.appendChild(document.createTextNode(css));
+	}
+
+	module.exports = {
+		/**
+		 * This property holds whether this platform is enabled for the current environment.
+		 * Currently used by platform.js to select the proper implementation.
+		 * @private
+		 */
+		_enabled: typeof window !== 'undefined' && typeof document !== 'undefined',
+
+		initialize: function() {
+			var keyframes = 'from{opacity:0.99}to{opacity:1}';
+
+			injectCSS(this,
+				// DOM rendering detection
+				// https://davidwalsh.name/detect-node-insertion
+				'@-webkit-keyframes ' + CSS_RENDER_ANIMATION + '{' + keyframes + '}' +
+				'@keyframes ' + CSS_RENDER_ANIMATION + '{' + keyframes + '}' +
+				'.' + CSS_RENDER_MONITOR + '{' +
+					'-webkit-animation:' + CSS_RENDER_ANIMATION + ' 0.001s;' +
+					'animation:' + CSS_RENDER_ANIMATION + ' 0.001s;' +
+				'}'
+			);
+		},
+
+		acquireContext: function(item, config) {
+			if (typeof item === 'string') {
+				item = document.getElementById(item);
+			} else if (item.length) {
+				// Support for array based queries (such as jQuery)
+				item = item[0];
+			}
+
+			if (item && item.canvas) {
+				// Support for any object associated to a canvas (including a context2d)
+				item = item.canvas;
+			}
+
+			// To prevent canvas fingerprinting, some add-ons undefine the getContext
+			// method, for example: https://github.com/kkapsner/CanvasBlocker
+			// https://github.com/chartjs/Chart.js/issues/2807
+			var context = item && item.getContext && item.getContext('2d');
+
+			// `instanceof HTMLCanvasElement/CanvasRenderingContext2D` fails when the item is
+			// inside an iframe or when running in a protected environment. We could guess the
+			// types from their toString() value but let's keep things flexible and assume it's
+			// a sufficient condition if the item has a context2D which has item as `canvas`.
+			// https://github.com/chartjs/Chart.js/issues/3887
+			// https://github.com/chartjs/Chart.js/issues/4102
+			// https://github.com/chartjs/Chart.js/issues/4152
+			if (context && context.canvas === item) {
+				initCanvas(item, config);
+				return context;
+			}
+
+			return null;
+		},
+
+		releaseContext: function(context) {
+			var canvas = context.canvas;
+			if (!canvas[EXPANDO_KEY]) {
+				return;
+			}
+
+			var initial = canvas[EXPANDO_KEY].initial;
+			['height', 'width'].forEach(function(prop) {
+				var value = initial[prop];
+				if (helpers.isNullOrUndef(value)) {
+					canvas.removeAttribute(prop);
+				} else {
+					canvas.setAttribute(prop, value);
+				}
+			});
+
+			helpers.each(initial.style || {}, function(value, key) {
+				canvas.style[key] = value;
+			});
+
+			// The canvas render size might have been changed (and thus the state stack discarded),
+			// we can't use save() and restore() to restore the initial state. So make sure that at
+			// least the canvas context is reset to the default state by setting the canvas width.
+			// https://www.w3.org/TR/2011/WD-html5-20110525/the-canvas-element.html
+			canvas.width = canvas.width;
+
+			delete canvas[EXPANDO_KEY];
+		},
+
+		addEventListener: function(chart, type, listener) {
+			var canvas = chart.canvas;
+			if (type === 'resize') {
+				// Note: the resize event is not supported on all browsers.
+				addResizeListener(canvas, listener, chart);
+				return;
+			}
+
+			var expando = listener[EXPANDO_KEY] || (listener[EXPANDO_KEY] = {});
+			var proxies = expando.proxies || (expando.proxies = {});
+			var proxy = proxies[chart.id + '_' + type] = function(event) {
+				listener(fromNativeEvent(event, chart));
+			};
+
+			addEventListener(canvas, type, proxy);
+		},
+
+		removeEventListener: function(chart, type, listener) {
+			var canvas = chart.canvas;
+			if (type === 'resize') {
+				// Note: the resize event is not supported on all browsers.
+				removeResizeListener(canvas, listener);
+				return;
+			}
+
+			var expando = listener[EXPANDO_KEY] || {};
+			var proxies = expando.proxies || {};
+			var proxy = proxies[chart.id + '_' + type];
+			if (!proxy) {
+				return;
+			}
+
+			removeEventListener(canvas, type, proxy);
+		}
+	};
+
+	// DEPRECATIONS
+
+	/**
+	 * Provided for backward compatibility, use EventTarget.addEventListener instead.
+	 * EventTarget.addEventListener compatibility: Chrome, Opera 7, Safari, FF1.5+, IE9+
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+	 * @function Chart.helpers.addEvent
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.addEvent = addEventListener;
+
+	/**
+	 * Provided for backward compatibility, use EventTarget.removeEventListener instead.
+	 * EventTarget.removeEventListener compatibility: Chrome, Opera 7, Safari, FF1.5+, IE9+
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener
+	 * @function Chart.helpers.removeEvent
+	 * @deprecated since version 2.7.0
+	 * @todo remove at version 3
+	 * @private
+	 */
+	helpers.removeEvent = removeEventListener;
+
+
+/***/ },
+/* 28 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('global', {
+		plugins: {}
+	});
+
+	module.exports = function(Chart) {
+
+		/**
+		 * The plugin service singleton
+		 * @namespace Chart.plugins
+		 * @since 2.1.0
+		 */
+		Chart.plugins = {
+			/**
+			 * Globally registered plugins.
+			 * @private
+			 */
+			_plugins: [],
+
+			/**
+			 * This identifier is used to invalidate the descriptors cache attached to each chart
+			 * when a global plugin is registered or unregistered. In this case, the cache ID is
+			 * incremented and descriptors are regenerated during following API calls.
+			 * @private
+			 */
+			_cacheId: 0,
+
+			/**
+			 * Registers the given plugin(s) if not already registered.
+			 * @param {Array|Object} plugins plugin instance(s).
+			 */
+			register: function(plugins) {
+				var p = this._plugins;
+				([]).concat(plugins).forEach(function(plugin) {
+					if (p.indexOf(plugin) === -1) {
+						p.push(plugin);
+					}
+				});
+
+				this._cacheId++;
+			},
+
+			/**
+			 * Unregisters the given plugin(s) only if registered.
+			 * @param {Array|Object} plugins plugin instance(s).
+			 */
+			unregister: function(plugins) {
+				var p = this._plugins;
+				([]).concat(plugins).forEach(function(plugin) {
+					var idx = p.indexOf(plugin);
+					if (idx !== -1) {
+						p.splice(idx, 1);
+					}
+				});
+
+				this._cacheId++;
+			},
+
+			/**
+			 * Remove all registered plugins.
+			 * @since 2.1.5
+			 */
+			clear: function() {
+				this._plugins = [];
+				this._cacheId++;
+			},
+
+			/**
+			 * Returns the number of registered plugins?
+			 * @returns {Number}
+			 * @since 2.1.5
+			 */
+			count: function() {
+				return this._plugins.length;
+			},
+
+			/**
+			 * Returns all registered plugin instances.
+			 * @returns {Array} array of plugin objects.
+			 * @since 2.1.5
+			 */
+			getAll: function() {
+				return this._plugins;
+			},
+
+			/**
+			 * Calls enabled plugins for `chart` on the specified hook and with the given args.
+			 * This method immediately returns as soon as a plugin explicitly returns false. The
+			 * returned value can be used, for instance, to interrupt the current action.
+			 * @param {Object} chart - The chart instance for which plugins should be called.
+			 * @param {String} hook - The name of the plugin method to call (e.g. 'beforeUpdate').
+			 * @param {Array} [args] - Extra arguments to apply to the hook call.
+			 * @returns {Boolean} false if any of the plugins return false, else returns true.
+			 */
+			notify: function(chart, hook, args) {
+				var descriptors = this.descriptors(chart);
+				var ilen = descriptors.length;
+				var i, descriptor, plugin, params, method;
+
+				for (i = 0; i < ilen; ++i) {
+					descriptor = descriptors[i];
+					plugin = descriptor.plugin;
+					method = plugin[hook];
+					if (typeof method === 'function') {
+						params = [chart].concat(args || []);
+						params.push(descriptor.options);
+						if (method.apply(plugin, params) === false) {
+							return false;
+						}
+					}
+				}
+
+				return true;
+			},
+
+			/**
+			 * Returns descriptors of enabled plugins for the given chart.
+			 * @returns {Array} [{ plugin, options }]
+			 * @private
+			 */
+			descriptors: function(chart) {
+				var cache = chart._plugins || (chart._plugins = {});
+				if (cache.id === this._cacheId) {
+					return cache.descriptors;
+				}
+
+				var plugins = [];
+				var descriptors = [];
+				var config = (chart && chart.config) || {};
+				var options = (config.options && config.options.plugins) || {};
+
+				this._plugins.concat(config.plugins || []).forEach(function(plugin) {
+					var idx = plugins.indexOf(plugin);
+					if (idx !== -1) {
+						return;
+					}
+
+					var id = plugin.id;
+					var opts = options[id];
+					if (opts === false) {
+						return;
+					}
+
+					if (opts === true) {
+						opts = helpers.clone(defaults.global.plugins[id]);
+					}
+
+					plugins.push(plugin);
+					descriptors.push({
+						plugin: plugin,
+						options: opts || {}
+					});
+				});
+
+				cache.descriptors = descriptors;
+				cache.id = this._cacheId;
+				return descriptors;
+			}
+		};
+
+		/**
+		 * Plugin extension hooks.
+		 * @interface IPlugin
+		 * @since 2.1.0
+		 */
+		/**
+		 * @method IPlugin#beforeInit
+		 * @desc Called before initializing `chart`.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#afterInit
+		 * @desc Called after `chart` has been initialized and before the first update.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeUpdate
+		 * @desc Called before updating `chart`. If any plugin returns `false`, the update
+		 * is cancelled (and thus subsequent render(s)) until another `update` is triggered.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} `false` to cancel the chart update.
+		 */
+		/**
+		 * @method IPlugin#afterUpdate
+		 * @desc Called after `chart` has been updated and before rendering. Note that this
+		 * hook will not be called if the chart update has been previously cancelled.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeDatasetsUpdate
+	 	 * @desc Called before updating the `chart` datasets. If any plugin returns `false`,
+		 * the datasets update is cancelled until another `update` is triggered.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} false to cancel the datasets update.
+		 * @since version 2.1.5
+		 */
+		/**
+		 * @method IPlugin#afterDatasetsUpdate
+		 * @desc Called after the `chart` datasets have been updated. Note that this hook
+		 * will not be called if the datasets update has been previously cancelled.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 * @since version 2.1.5
+		 */
+		/**
+		 * @method IPlugin#beforeDatasetUpdate
+	 	 * @desc Called before updating the `chart` dataset at the given `args.index`. If any plugin
+		 * returns `false`, the datasets update is cancelled until another `update` is triggered.
+		 * @param {Chart} chart - The chart instance.
+		 * @param {Object} args - The call arguments.
+		 * @param {Number} args.index - The dataset index.
+		 * @param {Object} args.meta - The dataset metadata.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} `false` to cancel the chart datasets drawing.
+		 */
+		/**
+		 * @method IPlugin#afterDatasetUpdate
+	 	 * @desc Called after the `chart` datasets at the given `args.index` has been updated. Note
+		 * that this hook will not be called if the datasets update has been previously cancelled.
+		 * @param {Chart} chart - The chart instance.
+		 * @param {Object} args - The call arguments.
+		 * @param {Number} args.index - The dataset index.
+		 * @param {Object} args.meta - The dataset metadata.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeLayout
+		 * @desc Called before laying out `chart`. If any plugin returns `false`,
+		 * the layout update is cancelled until another `update` is triggered.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} `false` to cancel the chart layout.
+		 */
+		/**
+		 * @method IPlugin#afterLayout
+		 * @desc Called after the `chart` has been layed out. Note that this hook will not
+		 * be called if the layout update has been previously cancelled.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeRender
+		 * @desc Called before rendering `chart`. If any plugin returns `false`,
+		 * the rendering is cancelled until another `render` is triggered.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} `false` to cancel the chart rendering.
+		 */
+		/**
+		 * @method IPlugin#afterRender
+		 * @desc Called after the `chart` has been fully rendered (and animation completed). Note
+		 * that this hook will not be called if the rendering has been previously cancelled.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeDraw
+		 * @desc Called before drawing `chart` at every animation frame specified by the given
+		 * easing value. If any plugin returns `false`, the frame drawing is cancelled until
+		 * another `render` is triggered.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} `false` to cancel the chart drawing.
+		 */
+		/**
+		 * @method IPlugin#afterDraw
+		 * @desc Called after the `chart` has been drawn for the specific easing value. Note
+		 * that this hook will not be called if the drawing has been previously cancelled.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeDatasetsDraw
+	 	 * @desc Called before drawing the `chart` datasets. If any plugin returns `false`,
+		 * the datasets drawing is cancelled until another `render` is triggered.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} `false` to cancel the chart datasets drawing.
+		 */
+		/**
+		 * @method IPlugin#afterDatasetsDraw
+		 * @desc Called after the `chart` datasets have been drawn. Note that this hook
+		 * will not be called if the datasets drawing has been previously cancelled.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeDatasetDraw
+	 	 * @desc Called before drawing the `chart` dataset at the given `args.index` (datasets
+		 * are drawn in the reverse order). If any plugin returns `false`, the datasets drawing
+		 * is cancelled until another `render` is triggered.
+		 * @param {Chart} chart - The chart instance.
+		 * @param {Object} args - The call arguments.
+		 * @param {Number} args.index - The dataset index.
+		 * @param {Object} args.meta - The dataset metadata.
+		 * @param {Number} args.easingValue - The current animation value, between 0.0 and 1.0.
+		 * @param {Object} options - The plugin options.
+		 * @returns {Boolean} `false` to cancel the chart datasets drawing.
+		 */
+		/**
+		 * @method IPlugin#afterDatasetDraw
+	 	 * @desc Called after the `chart` datasets at the given `args.index` have been drawn
+		 * (datasets are drawn in the reverse order). Note that this hook will not be called
+		 * if the datasets drawing has been previously cancelled.
+		 * @param {Chart} chart - The chart instance.
+		 * @param {Object} args - The call arguments.
+		 * @param {Number} args.index - The dataset index.
+		 * @param {Object} args.meta - The dataset metadata.
+		 * @param {Number} args.easingValue - The current animation value, between 0.0 and 1.0.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#beforeEvent
+	 	 * @desc Called before processing the specified `event`. If any plugin returns `false`,
+		 * the event will be discarded.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {IEvent} event - The event object.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#afterEvent
+		 * @desc Called after the `event` has been consumed. Note that this hook
+		 * will not be called if the `event` has been previously discarded.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {IEvent} event - The event object.
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#resize
+		 * @desc Called after the chart as been resized.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Number} size - The new canvas display size (eq. canvas.style width & height).
+		 * @param {Object} options - The plugin options.
+		 */
+		/**
+		 * @method IPlugin#destroy
+		 * @desc Called after the chart as been destroyed.
+		 * @param {Chart.Controller} chart - The chart instance.
+		 * @param {Object} options - The plugin options.
+		 */
+
+		/**
+		 * Provided for backward compatibility, use Chart.plugins instead
+		 * @namespace Chart.pluginService
+		 * @deprecated since version 2.1.5
+		 * @todo remove at version 3
+		 * @private
+		 */
+		Chart.pluginService = Chart.plugins;
+
+		/**
+		 * Provided for backward compatibility, inheriting from Chart.PlugingBase has no
+		 * effect, instead simply create/register plugins via plain JavaScript objects.
+		 * @interface Chart.PluginBase
+		 * @deprecated since version 2.5.0
+		 * @todo remove at version 3
+		 * @private
+		 */
+		Chart.PluginBase = Element.extend({});
+	};
+
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* global window: false */
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('global', {
+		animation: {
+			duration: 1000,
+			easing: 'easeOutQuart',
+			onProgress: helpers.noop,
+			onComplete: helpers.noop
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		Chart.Animation = Element.extend({
+			chart: null, // the animation associated chart instance
+			currentStep: 0, // the current animation step
+			numSteps: 60, // default number of steps
+			easing: '', // the easing to use for this animation
+			render: null, // render function used by the animation service
+
+			onAnimationProgress: null, // user specified callback to fire on each step of the animation
+			onAnimationComplete: null, // user specified callback to fire when the animation finishes
+		});
+
+		Chart.animationService = {
+			frameDuration: 17,
+			animations: [],
+			dropFrames: 0,
+			request: null,
+
+			/**
+			 * @param {Chart} chart - The chart to animate.
+			 * @param {Chart.Animation} animation - The animation that we will animate.
+			 * @param {Number} duration - The animation duration in ms.
+			 * @param {Boolean} lazy - if true, the chart is not marked as animating to enable more responsive interactions
+			 */
+			addAnimation: function(chart, animation, duration, lazy) {
+				var animations = this.animations;
+				var i, ilen;
+
+				animation.chart = chart;
+
+				if (!lazy) {
+					chart.animating = true;
+				}
+
+				for (i = 0, ilen = animations.length; i < ilen; ++i) {
+					if (animations[i].chart === chart) {
+						animations[i] = animation;
+						return;
+					}
+				}
+
+				animations.push(animation);
+
+				// If there are no animations queued, manually kickstart a digest, for lack of a better word
+				if (animations.length === 1) {
+					this.requestAnimationFrame();
+				}
+			},
+
+			cancelAnimation: function(chart) {
+				var index = helpers.findIndex(this.animations, function(animation) {
+					return animation.chart === chart;
+				});
+
+				if (index !== -1) {
+					this.animations.splice(index, 1);
+					chart.animating = false;
+				}
+			},
+
+			requestAnimationFrame: function() {
+				var me = this;
+				if (me.request === null) {
+					// Skip animation frame requests until the active one is executed.
+					// This can happen when processing mouse events, e.g. 'mousemove'
+					// and 'mouseout' events will trigger multiple renders.
+					me.request = helpers.requestAnimFrame.call(window, function() {
+						me.request = null;
+						me.startDigest();
+					});
+				}
+			},
+
+			/**
+			 * @private
+			 */
+			startDigest: function() {
+				var me = this;
+				var startTime = Date.now();
+				var framesToDrop = 0;
+
+				if (me.dropFrames > 1) {
+					framesToDrop = Math.floor(me.dropFrames);
+					me.dropFrames = me.dropFrames % 1;
+				}
+
+				me.advance(1 + framesToDrop);
+
+				var endTime = Date.now();
+
+				me.dropFrames += (endTime - startTime) / me.frameDuration;
+
+				// Do we have more stuff to animate?
+				if (me.animations.length > 0) {
+					me.requestAnimationFrame();
+				}
+			},
+
+			/**
+			 * @private
+			 */
+			advance: function(count) {
+				var animations = this.animations;
+				var animation, chart;
+				var i = 0;
+
+				while (i < animations.length) {
+					animation = animations[i];
+					chart = animation.chart;
+
+					animation.currentStep = (animation.currentStep || 0) + count;
+					animation.currentStep = Math.min(animation.currentStep, animation.numSteps);
+
+					helpers.callback(animation.render, [chart, animation], chart);
+					helpers.callback(animation.onAnimationProgress, [animation], chart);
+
+					if (animation.currentStep >= animation.numSteps) {
+						helpers.callback(animation.onAnimationComplete, [animation], chart);
+						chart.animating = false;
+						animations.splice(i, 1);
+					} else {
+						++i;
+					}
+				}
+			}
+		};
+
+		/**
+		 * Provided for backward compatibility, use Chart.Animation instead
+		 * @prop Chart.Animation#animationObject
+		 * @deprecated since version 2.6.0
+		 * @todo remove at version 3
+		 */
+		Object.defineProperty(Chart.Animation.prototype, 'animationObject', {
+			get: function() {
+				return this;
+			}
+		});
+
+		/**
+		 * Provided for backward compatibility, use Chart.Animation#chart instead
+		 * @prop Chart.Animation#chartInstance
+		 * @deprecated since version 2.6.0
+		 * @todo remove at version 3
+		 */
+		Object.defineProperty(Chart.Animation.prototype, 'chartInstance', {
+			get: function() {
+				return this.chart;
+			},
+			set: function(value) {
+				this.chart = value;
+			}
+		});
+
+	};
+
+
+/***/ },
+/* 30 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var helpers = __webpack_require__(7);
+	var Interaction = __webpack_require__(24);
+	var platform = __webpack_require__(25);
+
+	module.exports = function(Chart) {
+		var plugins = Chart.plugins;
+
+		// Create a dictionary of chart types, to allow for extension of existing types
+		Chart.types = {};
+
+		// Store a reference to each instance - allowing us to globally resize chart instances on window resize.
+		// Destroy method on the chart will remove the instance of the chart from this reference.
+		Chart.instances = {};
+
+		// Controllers available for dataset visualization eg. bar, line, slice, etc.
+		Chart.controllers = {};
+
+		/**
+		 * Initializes the given config with global and chart default values.
+		 */
+		function initConfig(config) {
+			config = config || {};
+
+			// Do NOT use configMerge() for the data object because this method merges arrays
+			// and so would change references to labels and datasets, preventing data updates.
+			var data = config.data = config.data || {};
+			data.datasets = data.datasets || [];
+			data.labels = data.labels || [];
+
+			config.options = helpers.configMerge(
+				defaults.global,
+				defaults[config.type],
+				config.options || {});
+
+			return config;
+		}
+
+		/**
+		 * Updates the config of the chart
+		 * @param chart {Chart} chart to update the options for
+		 */
+		function updateConfig(chart) {
+			var newOptions = chart.options;
+
+			// Update Scale(s) with options
+			if (newOptions.scale) {
+				chart.scale.options = newOptions.scale;
+			} else if (newOptions.scales) {
+				newOptions.scales.xAxes.concat(newOptions.scales.yAxes).forEach(function(scaleOptions) {
+					chart.scales[scaleOptions.id].options = scaleOptions;
+				});
+			}
+
+			// Tooltip
+			chart.tooltip._options = newOptions.tooltips;
+		}
+
+		function positionIsHorizontal(position) {
+			return position === 'top' || position === 'bottom';
+		}
+
+		helpers.extend(Chart.prototype, /** @lends Chart */ {
+			/**
+			 * @private
+			 */
+			construct: function(item, config) {
+				var me = this;
+
+				config = initConfig(config);
+
+				var context = platform.acquireContext(item, config);
+				var canvas = context && context.canvas;
+				var height = canvas && canvas.height;
+				var width = canvas && canvas.width;
+
+				me.id = helpers.uid();
+				me.ctx = context;
+				me.canvas = canvas;
+				me.config = config;
+				me.width = width;
+				me.height = height;
+				me.aspectRatio = height ? width / height : null;
+				me.options = config.options;
+				me._bufferedRender = false;
+
+				/**
+				 * Provided for backward compatibility, Chart and Chart.Controller have been merged,
+				 * the "instance" still need to be defined since it might be called from plugins.
+				 * @prop Chart#chart
+				 * @deprecated since version 2.6.0
+				 * @todo remove at version 3
+				 * @private
+				 */
+				me.chart = me;
+				me.controller = me; // chart.chart.controller #inception
+
+				// Add the chart instance to the global namespace
+				Chart.instances[me.id] = me;
+
+				// Define alias to the config data: `chart.data === chart.config.data`
+				Object.defineProperty(me, 'data', {
+					get: function() {
+						return me.config.data;
+					},
+					set: function(value) {
+						me.config.data = value;
+					}
+				});
+
+				if (!context || !canvas) {
+					// The given item is not a compatible context2d element, let's return before finalizing
+					// the chart initialization but after setting basic chart / controller properties that
+					// can help to figure out that the chart is not valid (e.g chart.canvas !== null);
+					// https://github.com/chartjs/Chart.js/issues/2807
+					console.error("Failed to create chart: can't acquire context from the given item");
+					return;
+				}
+
+				me.initialize();
+				me.update();
+			},
+
+			/**
+			 * @private
+			 */
+			initialize: function() {
+				var me = this;
+
+				// Before init plugin notification
+				plugins.notify(me, 'beforeInit');
+
+				helpers.retinaScale(me, me.options.devicePixelRatio);
+
+				me.bindEvents();
+
+				if (me.options.responsive) {
+					// Initial resize before chart draws (must be silent to preserve initial animations).
+					me.resize(true);
+				}
+
+				// Make sure scales have IDs and are built before we build any controllers.
+				me.ensureScalesHaveIDs();
+				me.buildScales();
+				me.initToolTip();
+
+				// After init plugin notification
+				plugins.notify(me, 'afterInit');
+
+				return me;
+			},
+
+			clear: function() {
+				helpers.canvas.clear(this);
+				return this;
+			},
+
+			stop: function() {
+				// Stops any current animation loop occurring
+				Chart.animationService.cancelAnimation(this);
+				return this;
+			},
+
+			resize: function(silent) {
+				var me = this;
+				var options = me.options;
+				var canvas = me.canvas;
+				var aspectRatio = (options.maintainAspectRatio && me.aspectRatio) || null;
+
+				// the canvas render width and height will be casted to integers so make sure that
+				// the canvas display style uses the same integer values to avoid blurring effect.
+
+				// Set to 0 instead of canvas.size because the size defaults to 300x150 if the element is collased
+				var newWidth = Math.max(0, Math.floor(helpers.getMaximumWidth(canvas)));
+				var newHeight = Math.max(0, Math.floor(aspectRatio ? newWidth / aspectRatio : helpers.getMaximumHeight(canvas)));
+
+				if (me.width === newWidth && me.height === newHeight) {
+					return;
+				}
+
+				canvas.width = me.width = newWidth;
+				canvas.height = me.height = newHeight;
+				canvas.style.width = newWidth + 'px';
+				canvas.style.height = newHeight + 'px';
+
+				helpers.retinaScale(me, options.devicePixelRatio);
+
+				if (!silent) {
+					// Notify any plugins about the resize
+					var newSize = {width: newWidth, height: newHeight};
+					plugins.notify(me, 'resize', [newSize]);
+
+					// Notify of resize
+					if (me.options.onResize) {
+						me.options.onResize(me, newSize);
+					}
+
+					me.stop();
+					me.update(me.options.responsiveAnimationDuration);
+				}
+			},
+
+			ensureScalesHaveIDs: function() {
+				var options = this.options;
+				var scalesOptions = options.scales || {};
+				var scaleOptions = options.scale;
+
+				helpers.each(scalesOptions.xAxes, function(xAxisOptions, index) {
+					xAxisOptions.id = xAxisOptions.id || ('x-axis-' + index);
+				});
+
+				helpers.each(scalesOptions.yAxes, function(yAxisOptions, index) {
+					yAxisOptions.id = yAxisOptions.id || ('y-axis-' + index);
+				});
+
+				if (scaleOptions) {
+					scaleOptions.id = scaleOptions.id || 'scale';
+				}
+			},
+
+			/**
+			 * Builds a map of scale ID to scale object for future lookup.
+			 */
+			buildScales: function() {
+				var me = this;
+				var options = me.options;
+				var scales = me.scales = {};
+				var items = [];
+
+				if (options.scales) {
+					items = items.concat(
+						(options.scales.xAxes || []).map(function(xAxisOptions) {
+							return {options: xAxisOptions, dtype: 'category', dposition: 'bottom'};
+						}),
+						(options.scales.yAxes || []).map(function(yAxisOptions) {
+							return {options: yAxisOptions, dtype: 'linear', dposition: 'left'};
+						})
+					);
+				}
+
+				if (options.scale) {
+					items.push({
+						options: options.scale,
+						dtype: 'radialLinear',
+						isDefault: true,
+						dposition: 'chartArea'
+					});
+				}
+
+				helpers.each(items, function(item) {
+					var scaleOptions = item.options;
+					var scaleType = helpers.valueOrDefault(scaleOptions.type, item.dtype);
+					var scaleClass = Chart.scaleService.getScaleConstructor(scaleType);
+					if (!scaleClass) {
+						return;
+					}
+
+					if (positionIsHorizontal(scaleOptions.position) !== positionIsHorizontal(item.dposition)) {
+						scaleOptions.position = item.dposition;
+					}
+
+					var scale = new scaleClass({
+						id: scaleOptions.id,
+						options: scaleOptions,
+						ctx: me.ctx,
+						chart: me
+					});
+
+					scales[scale.id] = scale;
+					scale.mergeTicksOptions();
+
+					// TODO(SB): I think we should be able to remove this custom case (options.scale)
+					// and consider it as a regular scale part of the "scales"" map only! This would
+					// make the logic easier and remove some useless? custom code.
+					if (item.isDefault) {
+						me.scale = scale;
+					}
+				});
+
+				Chart.scaleService.addScalesToLayout(this);
+			},
+
+			buildOrUpdateControllers: function() {
+				var me = this;
+				var types = [];
+				var newControllers = [];
+
+				helpers.each(me.data.datasets, function(dataset, datasetIndex) {
+					var meta = me.getDatasetMeta(datasetIndex);
+					var type = dataset.type || me.config.type;
+
+					if (meta.type && meta.type !== type) {
+						me.destroyDatasetMeta(datasetIndex);
+						meta = me.getDatasetMeta(datasetIndex);
+					}
+					meta.type = type;
+
+					types.push(meta.type);
+
+					if (meta.controller) {
+						meta.controller.updateIndex(datasetIndex);
+					} else {
+						var ControllerClass = Chart.controllers[meta.type];
+						if (ControllerClass === undefined) {
+							throw new Error('"' + meta.type + '" is not a chart type.');
+						}
+
+						meta.controller = new ControllerClass(me, datasetIndex);
+						newControllers.push(meta.controller);
+					}
+				}, me);
+
+				return newControllers;
+			},
+
+			/**
+			 * Reset the elements of all datasets
+			 * @private
+			 */
+			resetElements: function() {
+				var me = this;
+				helpers.each(me.data.datasets, function(dataset, datasetIndex) {
+					me.getDatasetMeta(datasetIndex).controller.reset();
+				}, me);
+			},
+
+			/**
+			* Resets the chart back to it's state before the initial animation
+			*/
+			reset: function() {
+				this.resetElements();
+				this.tooltip.initialize();
+			},
+
+			update: function(config) {
+				var me = this;
+
+				if (!config || typeof config !== 'object') {
+					// backwards compatibility
+					config = {
+						duration: config,
+						lazy: arguments[1]
+					};
+				}
+
+				updateConfig(me);
+
+				if (plugins.notify(me, 'beforeUpdate') === false) {
+					return;
+				}
+
+				// In case the entire data object changed
+				me.tooltip._data = me.data;
+
+				// Make sure dataset controllers are updated and new controllers are reset
+				var newControllers = me.buildOrUpdateControllers();
+
+				// Make sure all dataset controllers have correct meta data counts
+				helpers.each(me.data.datasets, function(dataset, datasetIndex) {
+					me.getDatasetMeta(datasetIndex).controller.buildOrUpdateElements();
+				}, me);
+
+				me.updateLayout();
+
+				// Can only reset the new controllers after the scales have been updated
+				helpers.each(newControllers, function(controller) {
+					controller.reset();
+				});
+
+				me.updateDatasets();
+
+				// Do this before render so that any plugins that need final scale updates can use it
+				plugins.notify(me, 'afterUpdate');
+
+				if (me._bufferedRender) {
+					me._bufferedRequest = {
+						duration: config.duration,
+						easing: config.easing,
+						lazy: config.lazy
+					};
+				} else {
+					me.render(config);
+				}
+			},
+
+			/**
+			 * Updates the chart layout unless a plugin returns `false` to the `beforeLayout`
+			 * hook, in which case, plugins will not be called on `afterLayout`.
+			 * @private
+			 */
+			updateLayout: function() {
+				var me = this;
+
+				if (plugins.notify(me, 'beforeLayout') === false) {
+					return;
+				}
+
+				Chart.layoutService.update(this, this.width, this.height);
+
+				/**
+				 * Provided for backward compatibility, use `afterLayout` instead.
+				 * @method IPlugin#afterScaleUpdate
+				 * @deprecated since version 2.5.0
+				 * @todo remove at version 3
+				 * @private
+				 */
+				plugins.notify(me, 'afterScaleUpdate');
+				plugins.notify(me, 'afterLayout');
+			},
+
+			/**
+			 * Updates all datasets unless a plugin returns `false` to the `beforeDatasetsUpdate`
+			 * hook, in which case, plugins will not be called on `afterDatasetsUpdate`.
+			 * @private
+			 */
+			updateDatasets: function() {
+				var me = this;
+
+				if (plugins.notify(me, 'beforeDatasetsUpdate') === false) {
+					return;
+				}
+
+				for (var i = 0, ilen = me.data.datasets.length; i < ilen; ++i) {
+					me.updateDataset(i);
+				}
+
+				plugins.notify(me, 'afterDatasetsUpdate');
+			},
+
+			/**
+			 * Updates dataset at index unless a plugin returns `false` to the `beforeDatasetUpdate`
+			 * hook, in which case, plugins will not be called on `afterDatasetUpdate`.
+			 * @private
+			 */
+			updateDataset: function(index) {
+				var me = this;
+				var meta = me.getDatasetMeta(index);
+				var args = {
+					meta: meta,
+					index: index
+				};
+
+				if (plugins.notify(me, 'beforeDatasetUpdate', [args]) === false) {
+					return;
+				}
+
+				meta.controller.update();
+
+				plugins.notify(me, 'afterDatasetUpdate', [args]);
+			},
+
+			render: function(config) {
+				var me = this;
+
+				if (!config || typeof config !== 'object') {
+					// backwards compatibility
+					config = {
+						duration: config,
+						lazy: arguments[1]
+					};
+				}
+
+				var duration = config.duration;
+				var lazy = config.lazy;
+
+				if (plugins.notify(me, 'beforeRender') === false) {
+					return;
+				}
+
+				var animationOptions = me.options.animation;
+				var onComplete = function(animation) {
+					plugins.notify(me, 'afterRender');
+					helpers.callback(animationOptions && animationOptions.onComplete, [animation], me);
+				};
+
+				if (animationOptions && ((typeof duration !== 'undefined' && duration !== 0) || (typeof duration === 'undefined' && animationOptions.duration !== 0))) {
+					var animation = new Chart.Animation({
+						numSteps: (duration || animationOptions.duration) / 16.66, // 60 fps
+						easing: config.easing || animationOptions.easing,
+
+						render: function(chart, animationObject) {
+							var easingFunction = helpers.easing.effects[animationObject.easing];
+							var currentStep = animationObject.currentStep;
+							var stepDecimal = currentStep / animationObject.numSteps;
+
+							chart.draw(easingFunction(stepDecimal), stepDecimal, currentStep);
+						},
+
+						onAnimationProgress: animationOptions.onProgress,
+						onAnimationComplete: onComplete
+					});
+
+					Chart.animationService.addAnimation(me, animation, duration, lazy);
+				} else {
+					me.draw();
+
+					// See https://github.com/chartjs/Chart.js/issues/3781
+					onComplete(new Chart.Animation({numSteps: 0, chart: me}));
+				}
+
+				return me;
+			},
+
+			draw: function(easingValue) {
+				var me = this;
+
+				me.clear();
+
+				if (helpers.isNullOrUndef(easingValue)) {
+					easingValue = 1;
+				}
+
+				me.transition(easingValue);
+
+				if (plugins.notify(me, 'beforeDraw', [easingValue]) === false) {
+					return;
+				}
+
+				// Draw all the scales
+				helpers.each(me.boxes, function(box) {
+					box.draw(me.chartArea);
+				}, me);
+
+				if (me.scale) {
+					me.scale.draw();
+				}
+
+				me.drawDatasets(easingValue);
+
+				// Finally draw the tooltip
+				me.tooltip.draw();
+
+				plugins.notify(me, 'afterDraw', [easingValue]);
+			},
+
+			/**
+			 * @private
+			 */
+			transition: function(easingValue) {
+				var me = this;
+
+				for (var i = 0, ilen = (me.data.datasets || []).length; i < ilen; ++i) {
+					if (me.isDatasetVisible(i)) {
+						me.getDatasetMeta(i).controller.transition(easingValue);
+					}
+				}
+
+				me.tooltip.transition(easingValue);
+			},
+
+			/**
+			 * Draws all datasets unless a plugin returns `false` to the `beforeDatasetsDraw`
+			 * hook, in which case, plugins will not be called on `afterDatasetsDraw`.
+			 * @private
+			 */
+			drawDatasets: function(easingValue) {
+				var me = this;
+
+				if (plugins.notify(me, 'beforeDatasetsDraw', [easingValue]) === false) {
+					return;
+				}
+
+				// Draw datasets reversed to support proper line stacking
+				for (var i = (me.data.datasets || []).length - 1; i >= 0; --i) {
+					if (me.isDatasetVisible(i)) {
+						me.drawDataset(i, easingValue);
+					}
+				}
+
+				plugins.notify(me, 'afterDatasetsDraw', [easingValue]);
+			},
+
+			/**
+			 * Draws dataset at index unless a plugin returns `false` to the `beforeDatasetDraw`
+			 * hook, in which case, plugins will not be called on `afterDatasetDraw`.
+			 * @private
+			 */
+			drawDataset: function(index, easingValue) {
+				var me = this;
+				var meta = me.getDatasetMeta(index);
+				var args = {
+					meta: meta,
+					index: index,
+					easingValue: easingValue
+				};
+
+				if (plugins.notify(me, 'beforeDatasetDraw', [args]) === false) {
+					return;
+				}
+
+				meta.controller.draw(easingValue);
+
+				plugins.notify(me, 'afterDatasetDraw', [args]);
+			},
+
+			// Get the single element that was clicked on
+			// @return : An object containing the dataset index and element index of the matching element. Also contains the rectangle that was draw
+			getElementAtEvent: function(e) {
+				return Interaction.modes.single(this, e);
+			},
+
+			getElementsAtEvent: function(e) {
+				return Interaction.modes.label(this, e, {intersect: true});
+			},
+
+			getElementsAtXAxis: function(e) {
+				return Interaction.modes['x-axis'](this, e, {intersect: true});
+			},
+
+			getElementsAtEventForMode: function(e, mode, options) {
+				var method = Interaction.modes[mode];
+				if (typeof method === 'function') {
+					return method(this, e, options);
+				}
+
+				return [];
+			},
+
+			getDatasetAtEvent: function(e) {
+				return Interaction.modes.dataset(this, e, {intersect: true});
+			},
+
+			getDatasetMeta: function(datasetIndex) {
+				var me = this;
+				var dataset = me.data.datasets[datasetIndex];
+				if (!dataset._meta) {
+					dataset._meta = {};
+				}
+
+				var meta = dataset._meta[me.id];
+				if (!meta) {
+					meta = dataset._meta[me.id] = {
+						type: null,
+						data: [],
+						dataset: null,
+						controller: null,
+						hidden: null,			// See isDatasetVisible() comment
+						xAxisID: null,
+						yAxisID: null
+					};
+				}
+
+				return meta;
+			},
+
+			getVisibleDatasetCount: function() {
+				var count = 0;
+				for (var i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
+					if (this.isDatasetVisible(i)) {
+						count++;
+					}
+				}
+				return count;
+			},
+
+			isDatasetVisible: function(datasetIndex) {
+				var meta = this.getDatasetMeta(datasetIndex);
+
+				// meta.hidden is a per chart dataset hidden flag override with 3 states: if true or false,
+				// the dataset.hidden value is ignored, else if null, the dataset hidden state is returned.
+				return typeof meta.hidden === 'boolean' ? !meta.hidden : !this.data.datasets[datasetIndex].hidden;
+			},
+
+			generateLegend: function() {
+				return this.options.legendCallback(this);
+			},
+
+			/**
+			 * @private
+			 */
+			destroyDatasetMeta: function(datasetIndex) {
+				var id = this.id;
+				var dataset = this.data.datasets[datasetIndex];
+				var meta = dataset._meta && dataset._meta[id];
+
+				if (meta) {
+					meta.controller.destroy();
+					delete dataset._meta[id];
+				}
+			},
+
+			destroy: function() {
+				var me = this;
+				var canvas = me.canvas;
+				var i, ilen;
+
+				me.stop();
+
+				// dataset controllers need to cleanup associated data
+				for (i = 0, ilen = me.data.datasets.length; i < ilen; ++i) {
+					me.destroyDatasetMeta(i);
+				}
+
+				if (canvas) {
+					me.unbindEvents();
+					helpers.canvas.clear(me);
+					platform.releaseContext(me.ctx);
+					me.canvas = null;
+					me.ctx = null;
+				}
+
+				plugins.notify(me, 'destroy');
+
+				delete Chart.instances[me.id];
+			},
+
+			toBase64Image: function() {
+				return this.canvas.toDataURL.apply(this.canvas, arguments);
+			},
+
+			initToolTip: function() {
+				var me = this;
+				me.tooltip = new Chart.Tooltip({
+					_chart: me,
+					_chartInstance: me, // deprecated, backward compatibility
+					_data: me.data,
+					_options: me.options.tooltips
+				}, me);
+			},
+
+			/**
+			 * @private
+			 */
+			bindEvents: function() {
+				var me = this;
+				var listeners = me._listeners = {};
+				var listener = function() {
+					me.eventHandler.apply(me, arguments);
+				};
+
+				helpers.each(me.options.events, function(type) {
+					platform.addEventListener(me, type, listener);
+					listeners[type] = listener;
+				});
+
+				// Elements used to detect size change should not be injected for non responsive charts.
+				// See https://github.com/chartjs/Chart.js/issues/2210
+				if (me.options.responsive) {
+					listener = function() {
+						me.resize();
+					};
+
+					platform.addEventListener(me, 'resize', listener);
+					listeners.resize = listener;
+				}
+			},
+
+			/**
+			 * @private
+			 */
+			unbindEvents: function() {
+				var me = this;
+				var listeners = me._listeners;
+				if (!listeners) {
+					return;
+				}
+
+				delete me._listeners;
+				helpers.each(listeners, function(listener, type) {
+					platform.removeEventListener(me, type, listener);
+				});
+			},
+
+			updateHoverStyle: function(elements, mode, enabled) {
+				var method = enabled ? 'setHoverStyle' : 'removeHoverStyle';
+				var element, i, ilen;
+
+				for (i = 0, ilen = elements.length; i < ilen; ++i) {
+					element = elements[i];
+					if (element) {
+						this.getDatasetMeta(element._datasetIndex).controller[method](element);
+					}
+				}
+			},
+
+			/**
+			 * @private
+			 */
+			eventHandler: function(e) {
+				var me = this;
+				var tooltip = me.tooltip;
+
+				if (plugins.notify(me, 'beforeEvent', [e]) === false) {
+					return;
+				}
+
+				// Buffer any update calls so that renders do not occur
+				me._bufferedRender = true;
+				me._bufferedRequest = null;
+
+				var changed = me.handleEvent(e);
+				changed |= tooltip && tooltip.handleEvent(e);
+
+				plugins.notify(me, 'afterEvent', [e]);
+
+				var bufferedRequest = me._bufferedRequest;
+				if (bufferedRequest) {
+					// If we have an update that was triggered, we need to do a normal render
+					me.render(bufferedRequest);
+				} else if (changed && !me.animating) {
+					// If entering, leaving, or changing elements, animate the change via pivot
+					me.stop();
+
+					// We only need to render at this point. Updating will cause scales to be
+					// recomputed generating flicker & using more memory than necessary.
+					me.render(me.options.hover.animationDuration, true);
+				}
+
+				me._bufferedRender = false;
+				me._bufferedRequest = null;
+
+				return me;
+			},
+
+			/**
+			 * Handle an event
+			 * @private
+			 * @param {IEvent} event the event to handle
+			 * @return {Boolean} true if the chart needs to re-render
+			 */
+			handleEvent: function(e) {
+				var me = this;
+				var options = me.options || {};
+				var hoverOptions = options.hover;
+				var changed = false;
+
+				me.lastActive = me.lastActive || [];
+
+				// Find Active Elements for hover and tooltips
+				if (e.type === 'mouseout') {
+					me.active = [];
+				} else {
+					me.active = me.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions);
+				}
+
+				// Invoke onHover hook
+				// Need to call with native event here to not break backwards compatibility
+				helpers.callback(options.onHover || options.hover.onHover, [e.native, me.active], me);
+
+				if (e.type === 'mouseup' || e.type === 'click') {
+					if (options.onClick) {
+						// Use e.native here for backwards compatibility
+						options.onClick.call(me, e.native, me.active);
+					}
+				}
+
+				// Remove styling for last active (even if it may still be active)
+				if (me.lastActive.length) {
+					me.updateHoverStyle(me.lastActive, hoverOptions.mode, false);
+				}
+
+				// Built in hover styling
+				if (me.active.length && hoverOptions.mode) {
+					me.updateHoverStyle(me.active, hoverOptions.mode, true);
+				}
+
+				changed = !helpers.arrayEquals(me.active, me.lastActive);
+
+				// Remember Last Actives
+				me.lastActive = me.active;
+
+				return changed;
+			}
+		});
+
+		/**
+		 * Provided for backward compatibility, use Chart instead.
+		 * @class Chart.Controller
+		 * @deprecated since version 2.6.0
+		 * @todo remove at version 3
+		 * @private
+		 */
+		Chart.Controller = Chart;
+	};
+
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+
+	module.exports = function(Chart) {
+
+		var arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'];
+
+		/**
+		 * Hooks the array methods that add or remove values ('push', pop', 'shift', 'splice',
+		 * 'unshift') and notify the listener AFTER the array has been altered. Listeners are
+		 * called on the 'onData*' callbacks (e.g. onDataPush, etc.) with same arguments.
+		 */
+		function listenArrayEvents(array, listener) {
+			if (array._chartjs) {
+				array._chartjs.listeners.push(listener);
+				return;
+			}
+
+			Object.defineProperty(array, '_chartjs', {
+				configurable: true,
+				enumerable: false,
+				value: {
+					listeners: [listener]
+				}
+			});
+
+			arrayEvents.forEach(function(key) {
+				var method = 'onData' + key.charAt(0).toUpperCase() + key.slice(1);
+				var base = array[key];
+
+				Object.defineProperty(array, key, {
+					configurable: true,
+					enumerable: false,
+					value: function() {
+						var args = Array.prototype.slice.call(arguments);
+						var res = base.apply(this, args);
+
+						helpers.each(array._chartjs.listeners, function(object) {
+							if (typeof object[method] === 'function') {
+								object[method].apply(object, args);
+							}
+						});
+
+						return res;
+					}
+				});
+			});
+		}
+
+		/**
+		 * Removes the given array event listener and cleanup extra attached properties (such as
+		 * the _chartjs stub and overridden methods) if array doesn't have any more listeners.
+		 */
+		function unlistenArrayEvents(array, listener) {
+			var stub = array._chartjs;
+			if (!stub) {
+				return;
+			}
+
+			var listeners = stub.listeners;
+			var index = listeners.indexOf(listener);
+			if (index !== -1) {
+				listeners.splice(index, 1);
+			}
+
+			if (listeners.length > 0) {
+				return;
+			}
+
+			arrayEvents.forEach(function(key) {
+				delete array[key];
+			});
+
+			delete array._chartjs;
+		}
+
+		// Base class for all dataset controllers (line, bar, etc)
+		Chart.DatasetController = function(chart, datasetIndex) {
+			this.initialize(chart, datasetIndex);
+		};
+
+		helpers.extend(Chart.DatasetController.prototype, {
+
+			/**
+			 * Element type used to generate a meta dataset (e.g. Chart.element.Line).
+			 * @type {Chart.core.element}
+			 */
+			datasetElementType: null,
+
+			/**
+			 * Element type used to generate a meta data (e.g. Chart.element.Point).
+			 * @type {Chart.core.element}
+			 */
+			dataElementType: null,
+
+			initialize: function(chart, datasetIndex) {
+				var me = this;
+				me.chart = chart;
+				me.index = datasetIndex;
+				me.linkScales();
+				me.addElements();
+			},
+
+			updateIndex: function(datasetIndex) {
+				this.index = datasetIndex;
+			},
+
+			linkScales: function() {
+				var me = this;
+				var meta = me.getMeta();
+				var dataset = me.getDataset();
+
+				if (meta.xAxisID === null) {
+					meta.xAxisID = dataset.xAxisID || me.chart.options.scales.xAxes[0].id;
+				}
+				if (meta.yAxisID === null) {
+					meta.yAxisID = dataset.yAxisID || me.chart.options.scales.yAxes[0].id;
+				}
+			},
+
+			getDataset: function() {
+				return this.chart.data.datasets[this.index];
+			},
+
+			getMeta: function() {
+				return this.chart.getDatasetMeta(this.index);
+			},
+
+			getScaleForId: function(scaleID) {
+				return this.chart.scales[scaleID];
+			},
+
+			reset: function() {
+				this.update(true);
+			},
+
+			/**
+			 * @private
+			 */
+			destroy: function() {
+				if (this._data) {
+					unlistenArrayEvents(this._data, this);
+				}
+			},
+
+			createMetaDataset: function() {
+				var me = this;
+				var type = me.datasetElementType;
+				return type && new type({
+					_chart: me.chart,
+					_datasetIndex: me.index
+				});
+			},
+
+			createMetaData: function(index) {
+				var me = this;
+				var type = me.dataElementType;
+				return type && new type({
+					_chart: me.chart,
+					_datasetIndex: me.index,
+					_index: index
+				});
+			},
+
+			addElements: function() {
+				var me = this;
+				var meta = me.getMeta();
+				var data = me.getDataset().data || [];
+				var metaData = meta.data;
+				var i, ilen;
+
+				for (i = 0, ilen = data.length; i < ilen; ++i) {
+					metaData[i] = metaData[i] || me.createMetaData(i);
+				}
+
+				meta.dataset = meta.dataset || me.createMetaDataset();
+			},
+
+			addElementAndReset: function(index) {
+				var element = this.createMetaData(index);
+				this.getMeta().data.splice(index, 0, element);
+				this.updateElement(element, index, true);
+			},
+
+			buildOrUpdateElements: function() {
+				var me = this;
+				var dataset = me.getDataset();
+				var data = dataset.data || (dataset.data = []);
+
+				// In order to correctly handle data addition/deletion animation (an thus simulate
+				// real-time charts), we need to monitor these data modifications and synchronize
+				// the internal meta data accordingly.
+				if (me._data !== data) {
+					if (me._data) {
+						// This case happens when the user replaced the data array instance.
+						unlistenArrayEvents(me._data, me);
+					}
+
+					listenArrayEvents(data, me);
+					me._data = data;
+				}
+
+				// Re-sync meta data in case the user replaced the data array or if we missed
+				// any updates and so make sure that we handle number of datapoints changing.
+				me.resyncElements();
+			},
+
+			update: helpers.noop,
+
+			transition: function(easingValue) {
+				var meta = this.getMeta();
+				var elements = meta.data || [];
+				var ilen = elements.length;
+				var i = 0;
+
+				for (; i < ilen; ++i) {
+					elements[i].transition(easingValue);
+				}
+
+				if (meta.dataset) {
+					meta.dataset.transition(easingValue);
+				}
+			},
+
+			draw: function() {
+				var meta = this.getMeta();
+				var elements = meta.data || [];
+				var ilen = elements.length;
+				var i = 0;
+
+				if (meta.dataset) {
+					meta.dataset.draw();
+				}
+
+				for (; i < ilen; ++i) {
+					elements[i].draw();
+				}
+			},
+
+			removeHoverStyle: function(element, elementOpts) {
+				var dataset = this.chart.data.datasets[element._datasetIndex];
+				var index = element._index;
+				var custom = element.custom || {};
+				var valueOrDefault = helpers.valueAtIndexOrDefault;
+				var model = element._model;
+
+				model.backgroundColor = custom.backgroundColor ? custom.backgroundColor : valueOrDefault(dataset.backgroundColor, index, elementOpts.backgroundColor);
+				model.borderColor = custom.borderColor ? custom.borderColor : valueOrDefault(dataset.borderColor, index, elementOpts.borderColor);
+				model.borderWidth = custom.borderWidth ? custom.borderWidth : valueOrDefault(dataset.borderWidth, index, elementOpts.borderWidth);
+			},
+
+			setHoverStyle: function(element) {
+				var dataset = this.chart.data.datasets[element._datasetIndex];
+				var index = element._index;
+				var custom = element.custom || {};
+				var valueOrDefault = helpers.valueAtIndexOrDefault;
+				var getHoverColor = helpers.getHoverColor;
+				var model = element._model;
+
+				model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : valueOrDefault(dataset.hoverBackgroundColor, index, getHoverColor(model.backgroundColor));
+				model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : valueOrDefault(dataset.hoverBorderColor, index, getHoverColor(model.borderColor));
+				model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : valueOrDefault(dataset.hoverBorderWidth, index, model.borderWidth);
+			},
+
+			/**
+			 * @private
+			 */
+			resyncElements: function() {
+				var me = this;
+				var meta = me.getMeta();
+				var data = me.getDataset().data;
+				var numMeta = meta.data.length;
+				var numData = data.length;
+
+				if (numData < numMeta) {
+					meta.data.splice(numData, numMeta - numData);
+				} else if (numData > numMeta) {
+					me.insertElements(numMeta, numData - numMeta);
+				}
+			},
+
+			/**
+			 * @private
+			 */
+			insertElements: function(start, count) {
+				for (var i = 0; i < count; ++i) {
+					this.addElementAndReset(start + i);
+				}
+			},
+
+			/**
+			 * @private
+			 */
+			onDataPush: function() {
+				this.insertElements(this.getDataset().data.length - 1, arguments.length);
+			},
+
+			/**
+			 * @private
+			 */
+			onDataPop: function() {
+				this.getMeta().data.pop();
+			},
+
+			/**
+			 * @private
+			 */
+			onDataShift: function() {
+				this.getMeta().data.shift();
+			},
+
+			/**
+			 * @private
+			 */
+			onDataSplice: function(start, count) {
+				this.getMeta().data.splice(start, count);
+				this.insertElements(start, arguments.length - 2);
+			},
+
+			/**
+			 * @private
+			 */
+			onDataUnshift: function() {
+				this.insertElements(0, arguments.length);
+			}
+		});
+
+		Chart.DatasetController.extend = helpers.inherits;
+	};
+
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+
+	module.exports = function(Chart) {
+
+		function filterByPosition(array, position) {
+			return helpers.where(array, function(v) {
+				return v.position === position;
+			});
+		}
+
+		function sortByWeight(array, reverse) {
+			array.forEach(function(v, i) {
+				v._tmpIndex_ = i;
+				return v;
+			});
+			array.sort(function(a, b) {
+				var v0 = reverse ? b : a;
+				var v1 = reverse ? a : b;
+				return v0.weight === v1.weight ?
+					v0._tmpIndex_ - v1._tmpIndex_ :
+					v0.weight - v1.weight;
+			});
+			array.forEach(function(v) {
+				delete v._tmpIndex_;
+			});
+		}
+
+		/**
+		 * @interface ILayoutItem
+		 * @prop {String} position - The position of the item in the chart layout. Possible values are
+		 * 'left', 'top', 'right', 'bottom', and 'chartArea'
+		 * @prop {Number} weight - The weight used to sort the item. Higher weights are further away from the chart area
+		 * @prop {Boolean} fullWidth - if true, and the item is horizontal, then push vertical boxes down
+		 * @prop {Function} isHorizontal - returns true if the layout item is horizontal (ie. top or bottom)
+		 * @prop {Function} update - Takes two parameters: width and height. Returns size of item
+		 * @prop {Function} getPadding -  Returns an object with padding on the edges
+		 * @prop {Number} width - Width of item. Must be valid after update()
+		 * @prop {Number} height - Height of item. Must be valid after update()
+		 * @prop {Number} left - Left edge of the item. Set by layout system and cannot be used in update
+		 * @prop {Number} top - Top edge of the item. Set by layout system and cannot be used in update
+		 * @prop {Number} right - Right edge of the item. Set by layout system and cannot be used in update
+		 * @prop {Number} bottom - Bottom edge of the item. Set by layout system and cannot be used in update
+		 */
+
+		// The layout service is very self explanatory.  It's responsible for the layout within a chart.
+		// Scales, Legends and Plugins all rely on the layout service and can easily register to be placed anywhere they need
+		// It is this service's responsibility of carrying out that layout.
+		Chart.layoutService = {
+			defaults: {},
+
+			/**
+			 * Register a box to a chart.
+			 * A box is simply a reference to an object that requires layout. eg. Scales, Legend, Title.
+			 * @param {Chart} chart - the chart to use
+			 * @param {ILayoutItem} item - the item to add to be layed out
+			 */
+			addBox: function(chart, item) {
+				if (!chart.boxes) {
+					chart.boxes = [];
+				}
+
+				// initialize item with default values
+				item.fullWidth = item.fullWidth || false;
+				item.position = item.position || 'top';
+				item.weight = item.weight || 0;
+
+				chart.boxes.push(item);
+			},
+
+			/**
+			 * Remove a layoutItem from a chart
+			 * @param {Chart} chart - the chart to remove the box from
+			 * @param {Object} layoutItem - the item to remove from the layout
+			 */
+			removeBox: function(chart, layoutItem) {
+				var index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;
+				if (index !== -1) {
+					chart.boxes.splice(index, 1);
+				}
+			},
+
+			/**
+			 * Sets (or updates) options on the given `item`.
+			 * @param {Chart} chart - the chart in which the item lives (or will be added to)
+			 * @param {Object} item - the item to configure with the given options
+			 * @param {Object} options - the new item options.
+			 */
+			configure: function(chart, item, options) {
+				var props = ['fullWidth', 'position', 'weight'];
+				var ilen = props.length;
+				var i = 0;
+				var prop;
+
+				for (; i < ilen; ++i) {
+					prop = props[i];
+					if (options.hasOwnProperty(prop)) {
+						item[prop] = options[prop];
+					}
+				}
+			},
+
+			/**
+			 * Fits boxes of the given chart into the given size by having each box measure itself
+			 * then running a fitting algorithm
+			 * @param {Chart} chart - the chart
+			 * @param {Number} width - the width to fit into
+			 * @param {Number} height - the height to fit into
+			 */
+			update: function(chart, width, height) {
+				if (!chart) {
+					return;
+				}
+
+				var layoutOptions = chart.options.layout || {};
+				var padding = helpers.options.toPadding(layoutOptions.padding);
+				var leftPadding = padding.left;
+				var rightPadding = padding.right;
+				var topPadding = padding.top;
+				var bottomPadding = padding.bottom;
+
+				var leftBoxes = filterByPosition(chart.boxes, 'left');
+				var rightBoxes = filterByPosition(chart.boxes, 'right');
+				var topBoxes = filterByPosition(chart.boxes, 'top');
+				var bottomBoxes = filterByPosition(chart.boxes, 'bottom');
+				var chartAreaBoxes = filterByPosition(chart.boxes, 'chartArea');
+
+				// Sort boxes by weight. A higher weight is further away from the chart area
+				sortByWeight(leftBoxes, true);
+				sortByWeight(rightBoxes, false);
+				sortByWeight(topBoxes, true);
+				sortByWeight(bottomBoxes, false);
+
+				// Essentially we now have any number of boxes on each of the 4 sides.
+				// Our canvas looks like the following.
+				// The areas L1 and L2 are the left axes. R1 is the right axis, T1 is the top axis and
+				// B1 is the bottom axis
+				// There are also 4 quadrant-like locations (left to right instead of clockwise) reserved for chart overlays
+				// These locations are single-box locations only, when trying to register a chartArea location that is already taken,
+				// an error will be thrown.
+				//
+				// |----------------------------------------------------|
+				// |                  T1 (Full Width)                   |
+				// |----------------------------------------------------|
+				// |    |    |                 T2                  |    |
+				// |    |----|-------------------------------------|----|
+				// |    |    | C1 |                           | C2 |    |
+				// |    |    |----|                           |----|    |
+				// |    |    |                                     |    |
+				// | L1 | L2 |           ChartArea (C0)            | R1 |
+				// |    |    |                                     |    |
+				// |    |    |----|                           |----|    |
+				// |    |    | C3 |                           | C4 |    |
+				// |    |----|-------------------------------------|----|
+				// |    |    |                 B1                  |    |
+				// |----------------------------------------------------|
+				// |                  B2 (Full Width)                   |
+				// |----------------------------------------------------|
+				//
+				// What we do to find the best sizing, we do the following
+				// 1. Determine the minimum size of the chart area.
+				// 2. Split the remaining width equally between each vertical axis
+				// 3. Split the remaining height equally between each horizontal axis
+				// 4. Give each layout the maximum size it can be. The layout will return it's minimum size
+				// 5. Adjust the sizes of each axis based on it's minimum reported size.
+				// 6. Refit each axis
+				// 7. Position each axis in the final location
+				// 8. Tell the chart the final location of the chart area
+				// 9. Tell any axes that overlay the chart area the positions of the chart area
+
+				// Step 1
+				var chartWidth = width - leftPadding - rightPadding;
+				var chartHeight = height - topPadding - bottomPadding;
+				var chartAreaWidth = chartWidth / 2; // min 50%
+				var chartAreaHeight = chartHeight / 2; // min 50%
+
+				// Step 2
+				var verticalBoxWidth = (width - chartAreaWidth) / (leftBoxes.length + rightBoxes.length);
+
+				// Step 3
+				var horizontalBoxHeight = (height - chartAreaHeight) / (topBoxes.length + bottomBoxes.length);
+
+				// Step 4
+				var maxChartAreaWidth = chartWidth;
+				var maxChartAreaHeight = chartHeight;
+				var minBoxSizes = [];
+
+				function getMinimumBoxSize(box) {
+					var minSize;
+					var isHorizontal = box.isHorizontal();
+
+					if (isHorizontal) {
+						minSize = box.update(box.fullWidth ? chartWidth : maxChartAreaWidth, horizontalBoxHeight);
+						maxChartAreaHeight -= minSize.height;
+					} else {
+						minSize = box.update(verticalBoxWidth, chartAreaHeight);
+						maxChartAreaWidth -= minSize.width;
+					}
+
+					minBoxSizes.push({
+						horizontal: isHorizontal,
+						minSize: minSize,
+						box: box,
+					});
+				}
+
+				helpers.each(leftBoxes.concat(rightBoxes, topBoxes, bottomBoxes), getMinimumBoxSize);
+
+				// If a horizontal box has padding, we move the left boxes over to avoid ugly charts (see issue #2478)
+				var maxHorizontalLeftPadding = 0;
+				var maxHorizontalRightPadding = 0;
+				var maxVerticalTopPadding = 0;
+				var maxVerticalBottomPadding = 0;
+
+				helpers.each(topBoxes.concat(bottomBoxes), function(horizontalBox) {
+					if (horizontalBox.getPadding) {
+						var boxPadding = horizontalBox.getPadding();
+						maxHorizontalLeftPadding = Math.max(maxHorizontalLeftPadding, boxPadding.left);
+						maxHorizontalRightPadding = Math.max(maxHorizontalRightPadding, boxPadding.right);
+					}
+				});
+
+				helpers.each(leftBoxes.concat(rightBoxes), function(verticalBox) {
+					if (verticalBox.getPadding) {
+						var boxPadding = verticalBox.getPadding();
+						maxVerticalTopPadding = Math.max(maxVerticalTopPadding, boxPadding.top);
+						maxVerticalBottomPadding = Math.max(maxVerticalBottomPadding, boxPadding.bottom);
+					}
+				});
+
+				// At this point, maxChartAreaHeight and maxChartAreaWidth are the size the chart area could
+				// be if the axes are drawn at their minimum sizes.
+				// Steps 5 & 6
+				var totalLeftBoxesWidth = leftPadding;
+				var totalRightBoxesWidth = rightPadding;
+				var totalTopBoxesHeight = topPadding;
+				var totalBottomBoxesHeight = bottomPadding;
+
+				// Function to fit a box
+				function fitBox(box) {
+					var minBoxSize = helpers.findNextWhere(minBoxSizes, function(minBox) {
+						return minBox.box === box;
+					});
+
+					if (minBoxSize) {
+						if (box.isHorizontal()) {
+							var scaleMargin = {
+								left: Math.max(totalLeftBoxesWidth, maxHorizontalLeftPadding),
+								right: Math.max(totalRightBoxesWidth, maxHorizontalRightPadding),
+								top: 0,
+								bottom: 0
+							};
+
+							// Don't use min size here because of label rotation. When the labels are rotated, their rotation highly depends
+							// on the margin. Sometimes they need to increase in size slightly
+							box.update(box.fullWidth ? chartWidth : maxChartAreaWidth, chartHeight / 2, scaleMargin);
+						} else {
+							box.update(minBoxSize.minSize.width, maxChartAreaHeight);
+						}
+					}
+				}
+
+				// Update, and calculate the left and right margins for the horizontal boxes
+				helpers.each(leftBoxes.concat(rightBoxes), fitBox);
+
+				helpers.each(leftBoxes, function(box) {
+					totalLeftBoxesWidth += box.width;
+				});
+
+				helpers.each(rightBoxes, function(box) {
+					totalRightBoxesWidth += box.width;
+				});
+
+				// Set the Left and Right margins for the horizontal boxes
+				helpers.each(topBoxes.concat(bottomBoxes), fitBox);
+
+				// Figure out how much margin is on the top and bottom of the vertical boxes
+				helpers.each(topBoxes, function(box) {
+					totalTopBoxesHeight += box.height;
+				});
+
+				helpers.each(bottomBoxes, function(box) {
+					totalBottomBoxesHeight += box.height;
+				});
+
+				function finalFitVerticalBox(box) {
+					var minBoxSize = helpers.findNextWhere(minBoxSizes, function(minSize) {
+						return minSize.box === box;
+					});
+
+					var scaleMargin = {
+						left: 0,
+						right: 0,
+						top: totalTopBoxesHeight,
+						bottom: totalBottomBoxesHeight
+					};
+
+					if (minBoxSize) {
+						box.update(minBoxSize.minSize.width, maxChartAreaHeight, scaleMargin);
+					}
+				}
+
+				// Let the left layout know the final margin
+				helpers.each(leftBoxes.concat(rightBoxes), finalFitVerticalBox);
+
+				// Recalculate because the size of each layout might have changed slightly due to the margins (label rotation for instance)
+				totalLeftBoxesWidth = leftPadding;
+				totalRightBoxesWidth = rightPadding;
+				totalTopBoxesHeight = topPadding;
+				totalBottomBoxesHeight = bottomPadding;
+
+				helpers.each(leftBoxes, function(box) {
+					totalLeftBoxesWidth += box.width;
+				});
+
+				helpers.each(rightBoxes, function(box) {
+					totalRightBoxesWidth += box.width;
+				});
+
+				helpers.each(topBoxes, function(box) {
+					totalTopBoxesHeight += box.height;
+				});
+				helpers.each(bottomBoxes, function(box) {
+					totalBottomBoxesHeight += box.height;
+				});
+
+				// We may be adding some padding to account for rotated x axis labels
+				var leftPaddingAddition = Math.max(maxHorizontalLeftPadding - totalLeftBoxesWidth, 0);
+				totalLeftBoxesWidth += leftPaddingAddition;
+				totalRightBoxesWidth += Math.max(maxHorizontalRightPadding - totalRightBoxesWidth, 0);
+
+				var topPaddingAddition = Math.max(maxVerticalTopPadding - totalTopBoxesHeight, 0);
+				totalTopBoxesHeight += topPaddingAddition;
+				totalBottomBoxesHeight += Math.max(maxVerticalBottomPadding - totalBottomBoxesHeight, 0);
+
+				// Figure out if our chart area changed. This would occur if the dataset layout label rotation
+				// changed due to the application of the margins in step 6. Since we can only get bigger, this is safe to do
+				// without calling `fit` again
+				var newMaxChartAreaHeight = height - totalTopBoxesHeight - totalBottomBoxesHeight;
+				var newMaxChartAreaWidth = width - totalLeftBoxesWidth - totalRightBoxesWidth;
+
+				if (newMaxChartAreaWidth !== maxChartAreaWidth || newMaxChartAreaHeight !== maxChartAreaHeight) {
+					helpers.each(leftBoxes, function(box) {
+						box.height = newMaxChartAreaHeight;
+					});
+
+					helpers.each(rightBoxes, function(box) {
+						box.height = newMaxChartAreaHeight;
+					});
+
+					helpers.each(topBoxes, function(box) {
+						if (!box.fullWidth) {
+							box.width = newMaxChartAreaWidth;
+						}
+					});
+
+					helpers.each(bottomBoxes, function(box) {
+						if (!box.fullWidth) {
+							box.width = newMaxChartAreaWidth;
+						}
+					});
+
+					maxChartAreaHeight = newMaxChartAreaHeight;
+					maxChartAreaWidth = newMaxChartAreaWidth;
+				}
+
+				// Step 7 - Position the boxes
+				var left = leftPadding + leftPaddingAddition;
+				var top = topPadding + topPaddingAddition;
+
+				function placeBox(box) {
+					if (box.isHorizontal()) {
+						box.left = box.fullWidth ? leftPadding : totalLeftBoxesWidth;
+						box.right = box.fullWidth ? width - rightPadding : totalLeftBoxesWidth + maxChartAreaWidth;
+						box.top = top;
+						box.bottom = top + box.height;
+
+						// Move to next point
+						top = box.bottom;
+
+					} else {
+
+						box.left = left;
+						box.right = left + box.width;
+						box.top = totalTopBoxesHeight;
+						box.bottom = totalTopBoxesHeight + maxChartAreaHeight;
+
+						// Move to next point
+						left = box.right;
+					}
+				}
+
+				helpers.each(leftBoxes.concat(topBoxes), placeBox);
+
+				// Account for chart width and height
+				left += maxChartAreaWidth;
+				top += maxChartAreaHeight;
+
+				helpers.each(rightBoxes, placeBox);
+				helpers.each(bottomBoxes, placeBox);
+
+				// Step 8
+				chart.chartArea = {
+					left: totalLeftBoxesWidth,
+					top: totalTopBoxesHeight,
+					right: totalLeftBoxesWidth + maxChartAreaWidth,
+					bottom: totalTopBoxesHeight + maxChartAreaHeight
+				};
+
+				// Step 9
+				helpers.each(chartAreaBoxes, function(box) {
+					box.left = chart.chartArea.left;
+					box.top = chart.chartArea.top;
+					box.right = chart.chartArea.right;
+					box.bottom = chart.chartArea.bottom;
+
+					box.update(maxChartAreaWidth, maxChartAreaHeight);
+				});
+			}
+		};
+	};
+
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var helpers = __webpack_require__(7);
+
+	module.exports = function(Chart) {
+
+		Chart.scaleService = {
+			// Scale registration object. Extensions can register new scale types (such as log or DB scales) and then
+			// use the new chart options to grab the correct scale
+			constructors: {},
+			// Use a registration function so that we can move to an ES6 map when we no longer need to support
+			// old browsers
+
+			// Scale config defaults
+			defaults: {},
+			registerScaleType: function(type, scaleConstructor, scaleDefaults) {
+				this.constructors[type] = scaleConstructor;
+				this.defaults[type] = helpers.clone(scaleDefaults);
+			},
+			getScaleConstructor: function(type) {
+				return this.constructors.hasOwnProperty(type) ? this.constructors[type] : undefined;
+			},
+			getScaleDefaults: function(type) {
+				// Return the scale defaults merged with the global settings so that we always use the latest ones
+				return this.defaults.hasOwnProperty(type) ? helpers.merge({}, [defaults.scale, this.defaults[type]]) : {};
+			},
+			updateScaleDefaults: function(type, additions) {
+				var me = this;
+				if (me.defaults.hasOwnProperty(type)) {
+					me.defaults[type] = helpers.extend(me.defaults[type], additions);
+				}
+			},
+			addScalesToLayout: function(chart) {
+				// Adds each scale to the chart.boxes array to be sized accordingly
+				helpers.each(chart.scales, function(scale) {
+					// Set ILayoutItem parameters for backwards compatibility
+					scale.fullWidth = scale.options.fullWidth;
+					scale.position = scale.options.position;
+					scale.weight = scale.options.weight;
+					Chart.layoutService.addBox(chart, scale);
+				});
+			}
+		};
+	};
+
+
+/***/ },
+/* 34 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+	var Ticks = __webpack_require__(35);
+
+	defaults._set('scale', {
+		display: true,
+		position: 'left',
+		offset: false,
+
+		// grid line settings
+		gridLines: {
+			display: true,
+			color: 'rgba(0, 0, 0, 0.1)',
+			lineWidth: 1,
+			drawBorder: true,
+			drawOnChartArea: true,
+			drawTicks: true,
+			tickMarkLength: 10,
+			zeroLineWidth: 1,
+			zeroLineColor: 'rgba(0,0,0,0.25)',
+			zeroLineBorderDash: [],
+			zeroLineBorderDashOffset: 0.0,
+			offsetGridLines: false,
+			borderDash: [],
+			borderDashOffset: 0.0
+		},
+
+		// scale label
+		scaleLabel: {
+			// display property
+			display: false,
+
+			// actual label
+			labelString: '',
+
+			// line height
+			lineHeight: 1.2,
+
+			// top/bottom padding
+			padding: {
+				top: 4,
+				bottom: 4
+			}
+		},
+
+		// label settings
+		ticks: {
+			beginAtZero: false,
+			minRotation: 0,
+			maxRotation: 50,
+			mirror: false,
+			padding: 0,
+			reverse: false,
+			display: true,
+			autoSkip: true,
+			autoSkipPadding: 0,
+			labelOffset: 0,
+			// We pass through arrays to be rendered as multiline labels, we convert Others to strings here.
+			callback: Ticks.formatters.values,
+			minor: {},
+			major: {}
+		}
+	});
+
+	function labelsFromTicks(ticks) {
+		var labels = [];
+		var i, ilen;
+
+		for (i = 0, ilen = ticks.length; i < ilen; ++i) {
+			labels.push(ticks[i].label);
+		}
+
+		return labels;
+	}
+
+	function getLineValue(scale, index, offsetGridLines) {
+		var lineValue = scale.getPixelForTick(index);
+
+		if (offsetGridLines) {
+			if (index === 0) {
+				lineValue -= (scale.getPixelForTick(1) - lineValue) / 2;
+			} else {
+				lineValue -= (lineValue - scale.getPixelForTick(index - 1)) / 2;
+			}
+		}
+		return lineValue;
+	}
+
+	module.exports = function(Chart) {
+
+		function computeTextSize(context, tick, font) {
+			return helpers.isArray(tick) ?
+				helpers.longestText(context, font, tick) :
+				context.measureText(tick).width;
+		}
+
+		function parseFontOptions(options) {
+			var valueOrDefault = helpers.valueOrDefault;
+			var globalDefaults = defaults.global;
+			var size = valueOrDefault(options.fontSize, globalDefaults.defaultFontSize);
+			var style = valueOrDefault(options.fontStyle, globalDefaults.defaultFontStyle);
+			var family = valueOrDefault(options.fontFamily, globalDefaults.defaultFontFamily);
+
+			return {
+				size: size,
+				style: style,
+				family: family,
+				font: helpers.fontString(size, style, family)
+			};
+		}
+
+		function parseLineHeight(options) {
+			return helpers.options.toLineHeight(
+				helpers.valueOrDefault(options.lineHeight, 1.2),
+				helpers.valueOrDefault(options.fontSize, defaults.global.defaultFontSize));
+		}
+
+		Chart.Scale = Element.extend({
+			/**
+			 * Get the padding needed for the scale
+			 * @method getPadding
+			 * @private
+			 * @returns {Padding} the necessary padding
+			 */
+			getPadding: function() {
+				var me = this;
+				return {
+					left: me.paddingLeft || 0,
+					top: me.paddingTop || 0,
+					right: me.paddingRight || 0,
+					bottom: me.paddingBottom || 0
+				};
+			},
+
+			/**
+			 * Returns the scale tick objects ({label, major})
+			 * @since 2.7
+			 */
+			getTicks: function() {
+				return this._ticks;
+			},
+
+			// These methods are ordered by lifecyle. Utilities then follow.
+			// Any function defined here is inherited by all scale types.
+			// Any function can be extended by the scale type
+
+			mergeTicksOptions: function() {
+				var ticks = this.options.ticks;
+				if (ticks.minor === false) {
+					ticks.minor = {
+						display: false
+					};
+				}
+				if (ticks.major === false) {
+					ticks.major = {
+						display: false
+					};
+				}
+				for (var key in ticks) {
+					if (key !== 'major' && key !== 'minor') {
+						if (typeof ticks.minor[key] === 'undefined') {
+							ticks.minor[key] = ticks[key];
+						}
+						if (typeof ticks.major[key] === 'undefined') {
+							ticks.major[key] = ticks[key];
+						}
+					}
+				}
+			},
+			beforeUpdate: function() {
+				helpers.callback(this.options.beforeUpdate, [this]);
+			},
+			update: function(maxWidth, maxHeight, margins) {
+				var me = this;
+				var i, ilen, labels, label, ticks, tick;
+
+				// Update Lifecycle - Probably don't want to ever extend or overwrite this function ;)
+				me.beforeUpdate();
+
+				// Absorb the master measurements
+				me.maxWidth = maxWidth;
+				me.maxHeight = maxHeight;
+				me.margins = helpers.extend({
+					left: 0,
+					right: 0,
+					top: 0,
+					bottom: 0
+				}, margins);
+				me.longestTextCache = me.longestTextCache || {};
+
+				// Dimensions
+				me.beforeSetDimensions();
+				me.setDimensions();
+				me.afterSetDimensions();
+
+				// Data min/max
+				me.beforeDataLimits();
+				me.determineDataLimits();
+				me.afterDataLimits();
+
+				// Ticks - `this.ticks` is now DEPRECATED!
+				// Internal ticks are now stored as objects in the PRIVATE `this._ticks` member
+				// and must not be accessed directly from outside this class. `this.ticks` being
+				// around for long time and not marked as private, we can't change its structure
+				// without unexpected breaking changes. If you need to access the scale ticks,
+				// use scale.getTicks() instead.
+
+				me.beforeBuildTicks();
+
+				// New implementations should return an array of objects but for BACKWARD COMPAT,
+				// we still support no return (`this.ticks` internally set by calling this method).
+				ticks = me.buildTicks() || [];
+
+				me.afterBuildTicks();
+
+				me.beforeTickToLabelConversion();
+
+				// New implementations should return the formatted tick labels but for BACKWARD
+				// COMPAT, we still support no return (`this.ticks` internally changed by calling
+				// this method and supposed to contain only string values).
+				labels = me.convertTicksToLabels(ticks) || me.ticks;
+
+				me.afterTickToLabelConversion();
+
+				me.ticks = labels;   // BACKWARD COMPATIBILITY
+
+				// IMPORTANT: from this point, we consider that `this.ticks` will NEVER change!
+
+				// BACKWARD COMPAT: synchronize `_ticks` with labels (so potentially `this.ticks`)
+				for (i = 0, ilen = labels.length; i < ilen; ++i) {
+					label = labels[i];
+					tick = ticks[i];
+					if (!tick) {
+						ticks.push(tick = {
+							label: label,
+							major: false
+						});
+					} else {
+						tick.label = label;
+					}
+				}
+
+				me._ticks = ticks;
+
+				// Tick Rotation
+				me.beforeCalculateTickRotation();
+				me.calculateTickRotation();
+				me.afterCalculateTickRotation();
+				// Fit
+				me.beforeFit();
+				me.fit();
+				me.afterFit();
+				//
+				me.afterUpdate();
+
+				return me.minSize;
+
+			},
+			afterUpdate: function() {
+				helpers.callback(this.options.afterUpdate, [this]);
+			},
+
+			//
+
+			beforeSetDimensions: function() {
+				helpers.callback(this.options.beforeSetDimensions, [this]);
+			},
+			setDimensions: function() {
+				var me = this;
+				// Set the unconstrained dimension before label rotation
+				if (me.isHorizontal()) {
+					// Reset position before calculating rotation
+					me.width = me.maxWidth;
+					me.left = 0;
+					me.right = me.width;
+				} else {
+					me.height = me.maxHeight;
+
+					// Reset position before calculating rotation
+					me.top = 0;
+					me.bottom = me.height;
+				}
+
+				// Reset padding
+				me.paddingLeft = 0;
+				me.paddingTop = 0;
+				me.paddingRight = 0;
+				me.paddingBottom = 0;
+			},
+			afterSetDimensions: function() {
+				helpers.callback(this.options.afterSetDimensions, [this]);
+			},
+
+			// Data limits
+			beforeDataLimits: function() {
+				helpers.callback(this.options.beforeDataLimits, [this]);
+			},
+			determineDataLimits: helpers.noop,
+			afterDataLimits: function() {
+				helpers.callback(this.options.afterDataLimits, [this]);
+			},
+
+			//
+			beforeBuildTicks: function() {
+				helpers.callback(this.options.beforeBuildTicks, [this]);
+			},
+			buildTicks: helpers.noop,
+			afterBuildTicks: function() {
+				helpers.callback(this.options.afterBuildTicks, [this]);
+			},
+
+			beforeTickToLabelConversion: function() {
+				helpers.callback(this.options.beforeTickToLabelConversion, [this]);
+			},
+			convertTicksToLabels: function() {
+				var me = this;
+				// Convert ticks to strings
+				var tickOpts = me.options.ticks;
+				me.ticks = me.ticks.map(tickOpts.userCallback || tickOpts.callback, this);
+			},
+			afterTickToLabelConversion: function() {
+				helpers.callback(this.options.afterTickToLabelConversion, [this]);
+			},
+
+			//
+
+			beforeCalculateTickRotation: function() {
+				helpers.callback(this.options.beforeCalculateTickRotation, [this]);
+			},
+			calculateTickRotation: function() {
+				var me = this;
+				var context = me.ctx;
+				var tickOpts = me.options.ticks;
+				var labels = labelsFromTicks(me._ticks);
+
+				// Get the width of each grid by calculating the difference
+				// between x offsets between 0 and 1.
+				var tickFont = parseFontOptions(tickOpts);
+				context.font = tickFont.font;
+
+				var labelRotation = tickOpts.minRotation || 0;
+
+				if (labels.length && me.options.display && me.isHorizontal()) {
+					var originalLabelWidth = helpers.longestText(context, tickFont.font, labels, me.longestTextCache);
+					var labelWidth = originalLabelWidth;
+					var cosRotation, sinRotation;
+
+					// Allow 3 pixels x2 padding either side for label readability
+					var tickWidth = me.getPixelForTick(1) - me.getPixelForTick(0) - 6;
+
+					// Max label rotation can be set or default to 90 - also act as a loop counter
+					while (labelWidth > tickWidth && labelRotation < tickOpts.maxRotation) {
+						var angleRadians = helpers.toRadians(labelRotation);
+						cosRotation = Math.cos(angleRadians);
+						sinRotation = Math.sin(angleRadians);
+
+						if (sinRotation * originalLabelWidth > me.maxHeight) {
+							// go back one step
+							labelRotation--;
+							break;
+						}
+
+						labelRotation++;
+						labelWidth = cosRotation * originalLabelWidth;
+					}
+				}
+
+				me.labelRotation = labelRotation;
+			},
+			afterCalculateTickRotation: function() {
+				helpers.callback(this.options.afterCalculateTickRotation, [this]);
+			},
+
+			//
+
+			beforeFit: function() {
+				helpers.callback(this.options.beforeFit, [this]);
+			},
+			fit: function() {
+				var me = this;
+				// Reset
+				var minSize = me.minSize = {
+					width: 0,
+					height: 0
+				};
+
+				var labels = labelsFromTicks(me._ticks);
+
+				var opts = me.options;
+				var tickOpts = opts.ticks;
+				var scaleLabelOpts = opts.scaleLabel;
+				var gridLineOpts = opts.gridLines;
+				var display = opts.display;
+				var isHorizontal = me.isHorizontal();
+
+				var tickFont = parseFontOptions(tickOpts);
+				var tickMarkLength = opts.gridLines.tickMarkLength;
+
+				// Width
+				if (isHorizontal) {
+					// subtract the margins to line up with the chartArea if we are a full width scale
+					minSize.width = me.isFullWidth() ? me.maxWidth - me.margins.left - me.margins.right : me.maxWidth;
+				} else {
+					minSize.width = display && gridLineOpts.drawTicks ? tickMarkLength : 0;
+				}
+
+				// height
+				if (isHorizontal) {
+					minSize.height = display && gridLineOpts.drawTicks ? tickMarkLength : 0;
+				} else {
+					minSize.height = me.maxHeight; // fill all the height
+				}
+
+				// Are we showing a title for the scale?
+				if (scaleLabelOpts.display && display) {
+					var scaleLabelLineHeight = parseLineHeight(scaleLabelOpts);
+					var scaleLabelPadding = helpers.options.toPadding(scaleLabelOpts.padding);
+					var deltaHeight = scaleLabelLineHeight + scaleLabelPadding.height;
+
+					if (isHorizontal) {
+						minSize.height += deltaHeight;
+					} else {
+						minSize.width += deltaHeight;
+					}
+				}
+
+				// Don't bother fitting the ticks if we are not showing them
+				if (tickOpts.display && display) {
+					var largestTextWidth = helpers.longestText(me.ctx, tickFont.font, labels, me.longestTextCache);
+					var tallestLabelHeightInLines = helpers.numberOfLabelLines(labels);
+					var lineSpace = tickFont.size * 0.5;
+					var tickPadding = me.options.ticks.padding;
+
+					if (isHorizontal) {
+						// A horizontal axis is more constrained by the height.
+						me.longestLabelWidth = largestTextWidth;
+
+						var angleRadians = helpers.toRadians(me.labelRotation);
+						var cosRotation = Math.cos(angleRadians);
+						var sinRotation = Math.sin(angleRadians);
+
+						// TODO - improve this calculation
+						var labelHeight = (sinRotation * largestTextWidth)
+							+ (tickFont.size * tallestLabelHeightInLines)
+							+ (lineSpace * (tallestLabelHeightInLines - 1))
+							+ lineSpace; // padding
+
+						minSize.height = Math.min(me.maxHeight, minSize.height + labelHeight + tickPadding);
+
+						me.ctx.font = tickFont.font;
+						var firstLabelWidth = computeTextSize(me.ctx, labels[0], tickFont.font);
+						var lastLabelWidth = computeTextSize(me.ctx, labels[labels.length - 1], tickFont.font);
+
+						// Ensure that our ticks are always inside the canvas. When rotated, ticks are right aligned
+						// which means that the right padding is dominated by the font height
+						if (me.labelRotation !== 0) {
+							me.paddingLeft = opts.position === 'bottom' ? (cosRotation * firstLabelWidth) + 3 : (cosRotation * lineSpace) + 3; // add 3 px to move away from canvas edges
+							me.paddingRight = opts.position === 'bottom' ? (cosRotation * lineSpace) + 3 : (cosRotation * lastLabelWidth) + 3;
+						} else {
+							me.paddingLeft = firstLabelWidth / 2 + 3; // add 3 px to move away from canvas edges
+							me.paddingRight = lastLabelWidth / 2 + 3;
+						}
+					} else {
+						// A vertical axis is more constrained by the width. Labels are the
+						// dominant factor here, so get that length first and account for padding
+						if (tickOpts.mirror) {
+							largestTextWidth = 0;
+						} else {
+							// use lineSpace for consistency with horizontal axis
+							// tickPadding is not implemented for horizontal
+							largestTextWidth += tickPadding + lineSpace;
+						}
+
+						minSize.width = Math.min(me.maxWidth, minSize.width + largestTextWidth);
+
+						me.paddingTop = tickFont.size / 2;
+						me.paddingBottom = tickFont.size / 2;
+					}
+				}
+
+				me.handleMargins();
+
+				me.width = minSize.width;
+				me.height = minSize.height;
+			},
+
+			/**
+			 * Handle margins and padding interactions
+			 * @private
+			 */
+			handleMargins: function() {
+				var me = this;
+				if (me.margins) {
+					me.paddingLeft = Math.max(me.paddingLeft - me.margins.left, 0);
+					me.paddingTop = Math.max(me.paddingTop - me.margins.top, 0);
+					me.paddingRight = Math.max(me.paddingRight - me.margins.right, 0);
+					me.paddingBottom = Math.max(me.paddingBottom - me.margins.bottom, 0);
+				}
+			},
+
+			afterFit: function() {
+				helpers.callback(this.options.afterFit, [this]);
+			},
+
+			// Shared Methods
+			isHorizontal: function() {
+				return this.options.position === 'top' || this.options.position === 'bottom';
+			},
+			isFullWidth: function() {
+				return (this.options.fullWidth);
+			},
+
+			// Get the correct value. NaN bad inputs, If the value type is object get the x or y based on whether we are horizontal or not
+			getRightValue: function(rawValue) {
+				// Null and undefined values first
+				if (helpers.isNullOrUndef(rawValue)) {
+					return NaN;
+				}
+				// isNaN(object) returns true, so make sure NaN is checking for a number; Discard Infinite values
+				if (typeof rawValue === 'number' && !isFinite(rawValue)) {
+					return NaN;
+				}
+				// If it is in fact an object, dive in one more level
+				if (rawValue) {
+					if (this.isHorizontal()) {
+						if (rawValue.x !== undefined) {
+							return this.getRightValue(rawValue.x);
+						}
+					} else if (rawValue.y !== undefined) {
+						return this.getRightValue(rawValue.y);
+					}
+				}
+
+				// Value is good, return it
+				return rawValue;
+			},
+
+			// Used to get the value to display in the tooltip for the data at the given index
+			// function getLabelForIndex(index, datasetIndex)
+			getLabelForIndex: helpers.noop,
+
+			// Used to get data value locations.  Value can either be an index or a numerical value
+			getPixelForValue: helpers.noop,
+
+			// Used to get the data value from a given pixel. This is the inverse of getPixelForValue
+			getValueForPixel: helpers.noop,
+
+			// Used for tick location, should
+			getPixelForTick: function(index) {
+				var me = this;
+				var offset = me.options.offset;
+				if (me.isHorizontal()) {
+					var innerWidth = me.width - (me.paddingLeft + me.paddingRight);
+					var tickWidth = innerWidth / Math.max((me._ticks.length - (offset ? 0 : 1)), 1);
+					var pixel = (tickWidth * index) + me.paddingLeft;
+
+					if (offset) {
+						pixel += tickWidth / 2;
+					}
+
+					var finalVal = me.left + Math.round(pixel);
+					finalVal += me.isFullWidth() ? me.margins.left : 0;
+					return finalVal;
+				}
+				var innerHeight = me.height - (me.paddingTop + me.paddingBottom);
+				return me.top + (index * (innerHeight / (me._ticks.length - 1)));
+			},
+
+			// Utility for getting the pixel location of a percentage of scale
+			getPixelForDecimal: function(decimal) {
+				var me = this;
+				if (me.isHorizontal()) {
+					var innerWidth = me.width - (me.paddingLeft + me.paddingRight);
+					var valueOffset = (innerWidth * decimal) + me.paddingLeft;
+
+					var finalVal = me.left + Math.round(valueOffset);
+					finalVal += me.isFullWidth() ? me.margins.left : 0;
+					return finalVal;
+				}
+				return me.top + (decimal * me.height);
+			},
+
+			getBasePixel: function() {
+				return this.getPixelForValue(this.getBaseValue());
+			},
+
+			getBaseValue: function() {
+				var me = this;
+				var min = me.min;
+				var max = me.max;
+
+				return me.beginAtZero ? 0 :
+					min < 0 && max < 0 ? max :
+					min > 0 && max > 0 ? min :
+					0;
+			},
+
+			/**
+			 * Returns a subset of ticks to be plotted to avoid overlapping labels.
+			 * @private
+			 */
+			_autoSkip: function(ticks) {
+				var skipRatio;
+				var me = this;
+				var isHorizontal = me.isHorizontal();
+				var optionTicks = me.options.ticks.minor;
+				var tickCount = ticks.length;
+				var labelRotationRadians = helpers.toRadians(me.labelRotation);
+				var cosRotation = Math.cos(labelRotationRadians);
+				var longestRotatedLabel = me.longestLabelWidth * cosRotation;
+				var result = [];
+				var i, tick, shouldSkip;
+
+				// figure out the maximum number of gridlines to show
+				var maxTicks;
+				if (optionTicks.maxTicksLimit) {
+					maxTicks = optionTicks.maxTicksLimit;
+				}
+
+				if (isHorizontal) {
+					skipRatio = false;
+
+					if ((longestRotatedLabel + optionTicks.autoSkipPadding) * tickCount > (me.width - (me.paddingLeft + me.paddingRight))) {
+						skipRatio = 1 + Math.floor(((longestRotatedLabel + optionTicks.autoSkipPadding) * tickCount) / (me.width - (me.paddingLeft + me.paddingRight)));
+					}
+
+					// if they defined a max number of optionTicks,
+					// increase skipRatio until that number is met
+					if (maxTicks && tickCount > maxTicks) {
+						skipRatio = Math.max(skipRatio, Math.floor(tickCount / maxTicks));
+					}
+				}
+
+				for (i = 0; i < tickCount; i++) {
+					tick = ticks[i];
+
+					// Since we always show the last tick,we need may need to hide the last shown one before
+					shouldSkip = (skipRatio > 1 && i % skipRatio > 0) || (i % skipRatio === 0 && i + skipRatio >= tickCount);
+					if (shouldSkip && i !== tickCount - 1 || helpers.isNullOrUndef(tick.label)) {
+						// leave tick in place but make sure it's not displayed (#4635)
+						delete tick.label;
+					}
+					result.push(tick);
+				}
+				return result;
+			},
+
+			// Actually draw the scale on the canvas
+			// @param {rectangle} chartArea : the area of the chart to draw full grid lines on
+			draw: function(chartArea) {
+				var me = this;
+				var options = me.options;
+				if (!options.display) {
+					return;
+				}
+
+				var context = me.ctx;
+				var globalDefaults = defaults.global;
+				var optionTicks = options.ticks.minor;
+				var optionMajorTicks = options.ticks.major || optionTicks;
+				var gridLines = options.gridLines;
+				var scaleLabel = options.scaleLabel;
+
+				var isRotated = me.labelRotation !== 0;
+				var isHorizontal = me.isHorizontal();
+
+				var ticks = optionTicks.autoSkip ? me._autoSkip(me.getTicks()) : me.getTicks();
+				var tickFontColor = helpers.valueOrDefault(optionTicks.fontColor, globalDefaults.defaultFontColor);
+				var tickFont = parseFontOptions(optionTicks);
+				var majorTickFontColor = helpers.valueOrDefault(optionMajorTicks.fontColor, globalDefaults.defaultFontColor);
+				var majorTickFont = parseFontOptions(optionMajorTicks);
+
+				var tl = gridLines.drawTicks ? gridLines.tickMarkLength : 0;
+
+				var scaleLabelFontColor = helpers.valueOrDefault(scaleLabel.fontColor, globalDefaults.defaultFontColor);
+				var scaleLabelFont = parseFontOptions(scaleLabel);
+				var scaleLabelPadding = helpers.options.toPadding(scaleLabel.padding);
+				var labelRotationRadians = helpers.toRadians(me.labelRotation);
+
+				var itemsToDraw = [];
+
+				var xTickStart = options.position === 'right' ? me.left : me.right - tl;
+				var xTickEnd = options.position === 'right' ? me.left + tl : me.right;
+				var yTickStart = options.position === 'bottom' ? me.top : me.bottom - tl;
+				var yTickEnd = options.position === 'bottom' ? me.top + tl : me.bottom;
+
+				helpers.each(ticks, function(tick, index) {
+					// autoskipper skipped this tick (#4635)
+					if (tick.label === undefined) {
+						return;
+					}
+
+					var label = tick.label;
+					var lineWidth, lineColor, borderDash, borderDashOffset;
+					if (index === me.zeroLineIndex && options.offset === gridLines.offsetGridLines) {
+						// Draw the first index specially
+						lineWidth = gridLines.zeroLineWidth;
+						lineColor = gridLines.zeroLineColor;
+						borderDash = gridLines.zeroLineBorderDash;
+						borderDashOffset = gridLines.zeroLineBorderDashOffset;
+					} else {
+						lineWidth = helpers.valueAtIndexOrDefault(gridLines.lineWidth, index);
+						lineColor = helpers.valueAtIndexOrDefault(gridLines.color, index);
+						borderDash = helpers.valueOrDefault(gridLines.borderDash, globalDefaults.borderDash);
+						borderDashOffset = helpers.valueOrDefault(gridLines.borderDashOffset, globalDefaults.borderDashOffset);
+					}
+
+					// Common properties
+					var tx1, ty1, tx2, ty2, x1, y1, x2, y2, labelX, labelY;
+					var textAlign = 'middle';
+					var textBaseline = 'middle';
+					var tickPadding = optionTicks.padding;
+
+					if (isHorizontal) {
+						var labelYOffset = tl + tickPadding;
+
+						if (options.position === 'bottom') {
+							// bottom
+							textBaseline = !isRotated ? 'top' : 'middle';
+							textAlign = !isRotated ? 'center' : 'right';
+							labelY = me.top + labelYOffset;
+						} else {
+							// top
+							textBaseline = !isRotated ? 'bottom' : 'middle';
+							textAlign = !isRotated ? 'center' : 'left';
+							labelY = me.bottom - labelYOffset;
+						}
+
+						var xLineValue = getLineValue(me, index, gridLines.offsetGridLines && ticks.length > 1);
+						if (xLineValue < me.left) {
+							lineColor = 'rgba(0,0,0,0)';
+						}
+						xLineValue += helpers.aliasPixel(lineWidth);
+
+						labelX = me.getPixelForTick(index) + optionTicks.labelOffset; // x values for optionTicks (need to consider offsetLabel option)
+
+						tx1 = tx2 = x1 = x2 = xLineValue;
+						ty1 = yTickStart;
+						ty2 = yTickEnd;
+						y1 = chartArea.top;
+						y2 = chartArea.bottom;
+					} else {
+						var isLeft = options.position === 'left';
+						var labelXOffset;
+
+						if (optionTicks.mirror) {
+							textAlign = isLeft ? 'left' : 'right';
+							labelXOffset = tickPadding;
+						} else {
+							textAlign = isLeft ? 'right' : 'left';
+							labelXOffset = tl + tickPadding;
+						}
+
+						labelX = isLeft ? me.right - labelXOffset : me.left + labelXOffset;
+
+						var yLineValue = getLineValue(me, index, gridLines.offsetGridLines && ticks.length > 1);
+						if (yLineValue < me.top) {
+							lineColor = 'rgba(0,0,0,0)';
+						}
+						yLineValue += helpers.aliasPixel(lineWidth);
+
+						labelY = me.getPixelForTick(index) + optionTicks.labelOffset;
+
+						tx1 = xTickStart;
+						tx2 = xTickEnd;
+						x1 = chartArea.left;
+						x2 = chartArea.right;
+						ty1 = ty2 = y1 = y2 = yLineValue;
+					}
+
+					itemsToDraw.push({
+						tx1: tx1,
+						ty1: ty1,
+						tx2: tx2,
+						ty2: ty2,
+						x1: x1,
+						y1: y1,
+						x2: x2,
+						y2: y2,
+						labelX: labelX,
+						labelY: labelY,
+						glWidth: lineWidth,
+						glColor: lineColor,
+						glBorderDash: borderDash,
+						glBorderDashOffset: borderDashOffset,
+						rotation: -1 * labelRotationRadians,
+						label: label,
+						major: tick.major,
+						textBaseline: textBaseline,
+						textAlign: textAlign
+					});
+				});
+
+				// Draw all of the tick labels, tick marks, and grid lines at the correct places
+				helpers.each(itemsToDraw, function(itemToDraw) {
+					if (gridLines.display) {
+						context.save();
+						context.lineWidth = itemToDraw.glWidth;
+						context.strokeStyle = itemToDraw.glColor;
+						if (context.setLineDash) {
+							context.setLineDash(itemToDraw.glBorderDash);
+							context.lineDashOffset = itemToDraw.glBorderDashOffset;
+						}
+
+						context.beginPath();
+
+						if (gridLines.drawTicks) {
+							context.moveTo(itemToDraw.tx1, itemToDraw.ty1);
+							context.lineTo(itemToDraw.tx2, itemToDraw.ty2);
+						}
+
+						if (gridLines.drawOnChartArea) {
+							context.moveTo(itemToDraw.x1, itemToDraw.y1);
+							context.lineTo(itemToDraw.x2, itemToDraw.y2);
+						}
+
+						context.stroke();
+						context.restore();
+					}
+
+					if (optionTicks.display) {
+						// Make sure we draw text in the correct color and font
+						context.save();
+						context.translate(itemToDraw.labelX, itemToDraw.labelY);
+						context.rotate(itemToDraw.rotation);
+						context.font = itemToDraw.major ? majorTickFont.font : tickFont.font;
+						context.fillStyle = itemToDraw.major ? majorTickFontColor : tickFontColor;
+						context.textBaseline = itemToDraw.textBaseline;
+						context.textAlign = itemToDraw.textAlign;
+
+						var label = itemToDraw.label;
+						if (helpers.isArray(label)) {
+							for (var i = 0, y = 0; i < label.length; ++i) {
+								// We just make sure the multiline element is a string here..
+								context.fillText('' + label[i], 0, y);
+								// apply same lineSpacing as calculated @ L#320
+								y += (tickFont.size * 1.5);
+							}
+						} else {
+							context.fillText(label, 0, 0);
+						}
+						context.restore();
+					}
+				});
+
+				if (scaleLabel.display) {
+					// Draw the scale label
+					var scaleLabelX;
+					var scaleLabelY;
+					var rotation = 0;
+					var halfLineHeight = parseLineHeight(scaleLabel) / 2;
+
+					if (isHorizontal) {
+						scaleLabelX = me.left + ((me.right - me.left) / 2); // midpoint of the width
+						scaleLabelY = options.position === 'bottom'
+							? me.bottom - halfLineHeight - scaleLabelPadding.bottom
+							: me.top + halfLineHeight + scaleLabelPadding.top;
+					} else {
+						var isLeft = options.position === 'left';
+						scaleLabelX = isLeft
+							? me.left + halfLineHeight + scaleLabelPadding.top
+							: me.right - halfLineHeight - scaleLabelPadding.top;
+						scaleLabelY = me.top + ((me.bottom - me.top) / 2);
+						rotation = isLeft ? -0.5 * Math.PI : 0.5 * Math.PI;
+					}
+
+					context.save();
+					context.translate(scaleLabelX, scaleLabelY);
+					context.rotate(rotation);
+					context.textAlign = 'center';
+					context.textBaseline = 'middle';
+					context.fillStyle = scaleLabelFontColor; // render in correct colour
+					context.font = scaleLabelFont.font;
+					context.fillText(scaleLabel.labelString, 0, 0);
+					context.restore();
+				}
+
+				if (gridLines.drawBorder) {
+					// Draw the line at the edge of the axis
+					context.lineWidth = helpers.valueAtIndexOrDefault(gridLines.lineWidth, 0);
+					context.strokeStyle = helpers.valueAtIndexOrDefault(gridLines.color, 0);
+					var x1 = me.left;
+					var x2 = me.right;
+					var y1 = me.top;
+					var y2 = me.bottom;
+
+					var aliasPixel = helpers.aliasPixel(context.lineWidth);
+					if (isHorizontal) {
+						y1 = y2 = options.position === 'top' ? me.bottom : me.top;
+						y1 += aliasPixel;
+						y2 += aliasPixel;
+					} else {
+						x1 = x2 = options.position === 'left' ? me.right : me.left;
+						x1 += aliasPixel;
+						x2 += aliasPixel;
+					}
+
+					context.beginPath();
+					context.moveTo(x1, y1);
+					context.lineTo(x2, y2);
+					context.stroke();
+				}
+			}
+		});
+	};
+
+
+/***/ },
+/* 35 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+
+	/**
+	 * Namespace to hold static tick generation functions
+	 * @namespace Chart.Ticks
+	 */
+	module.exports = {
+		/**
+		 * Namespace to hold generators for different types of ticks
+		 * @namespace Chart.Ticks.generators
+		 */
+		generators: {
+			/**
+			 * Interface for the options provided to the numeric tick generator
+			 * @interface INumericTickGenerationOptions
+			 */
+			/**
+			 * The maximum number of ticks to display
+			 * @name INumericTickGenerationOptions#maxTicks
+			 * @type Number
+			 */
+			/**
+			 * The distance between each tick.
+			 * @name INumericTickGenerationOptions#stepSize
+			 * @type Number
+			 * @optional
+			 */
+			/**
+			 * Forced minimum for the ticks. If not specified, the minimum of the data range is used to calculate the tick minimum
+			 * @name INumericTickGenerationOptions#min
+			 * @type Number
+			 * @optional
+			 */
+			/**
+			 * The maximum value of the ticks. If not specified, the maximum of the data range is used to calculate the tick maximum
+			 * @name INumericTickGenerationOptions#max
+			 * @type Number
+			 * @optional
+			 */
+
+			/**
+			 * Generate a set of linear ticks
+			 * @method Chart.Ticks.generators.linear
+			 * @param generationOptions {INumericTickGenerationOptions} the options used to generate the ticks
+			 * @param dataRange {IRange} the range of the data
+			 * @returns {Array<Number>} array of tick values
+			 */
+			linear: function(generationOptions, dataRange) {
+				var ticks = [];
+				// To get a "nice" value for the tick spacing, we will use the appropriately named
+				// "nice number" algorithm. See http://stackoverflow.com/questions/8506881/nice-label-algorithm-for-charts-with-minimum-ticks
+				// for details.
+
+				var spacing;
+				if (generationOptions.stepSize && generationOptions.stepSize > 0) {
+					spacing = generationOptions.stepSize;
+				} else {
+					var niceRange = helpers.niceNum(dataRange.max - dataRange.min, false);
+					spacing = helpers.niceNum(niceRange / (generationOptions.maxTicks - 1), true);
+				}
+				var niceMin = Math.floor(dataRange.min / spacing) * spacing;
+				var niceMax = Math.ceil(dataRange.max / spacing) * spacing;
+
+				// If min, max and stepSize is set and they make an evenly spaced scale use it.
+				if (generationOptions.min && generationOptions.max && generationOptions.stepSize) {
+					// If very close to our whole number, use it.
+					if (helpers.almostWhole((generationOptions.max - generationOptions.min) / generationOptions.stepSize, spacing / 1000)) {
+						niceMin = generationOptions.min;
+						niceMax = generationOptions.max;
+					}
+				}
+
+				var numSpaces = (niceMax - niceMin) / spacing;
+				// If very close to our rounded value, use it.
+				if (helpers.almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {
+					numSpaces = Math.round(numSpaces);
+				} else {
+					numSpaces = Math.ceil(numSpaces);
+				}
+
+				// Put the values into the ticks array
+				ticks.push(generationOptions.min !== undefined ? generationOptions.min : niceMin);
+				for (var j = 1; j < numSpaces; ++j) {
+					ticks.push(niceMin + (j * spacing));
+				}
+				ticks.push(generationOptions.max !== undefined ? generationOptions.max : niceMax);
+
+				return ticks;
+			},
+
+			/**
+			 * Generate a set of logarithmic ticks
+			 * @method Chart.Ticks.generators.logarithmic
+			 * @param generationOptions {INumericTickGenerationOptions} the options used to generate the ticks
+			 * @param dataRange {IRange} the range of the data
+			 * @returns {Array<Number>} array of tick values
+			 */
+			logarithmic: function(generationOptions, dataRange) {
+				var ticks = [];
+				var valueOrDefault = helpers.valueOrDefault;
+
+				// Figure out what the max number of ticks we can support it is based on the size of
+				// the axis area. For now, we say that the minimum tick spacing in pixels must be 50
+				// We also limit the maximum number of ticks to 11 which gives a nice 10 squares on
+				// the graph
+				var tickVal = valueOrDefault(generationOptions.min, Math.pow(10, Math.floor(helpers.log10(dataRange.min))));
+
+				var endExp = Math.floor(helpers.log10(dataRange.max));
+				var endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp));
+				var exp, significand;
+
+				if (tickVal === 0) {
+					exp = Math.floor(helpers.log10(dataRange.minNotZero));
+					significand = Math.floor(dataRange.minNotZero / Math.pow(10, exp));
+
+					ticks.push(tickVal);
+					tickVal = significand * Math.pow(10, exp);
+				} else {
+					exp = Math.floor(helpers.log10(tickVal));
+					significand = Math.floor(tickVal / Math.pow(10, exp));
+				}
+
+				do {
+					ticks.push(tickVal);
+
+					++significand;
+					if (significand === 10) {
+						significand = 1;
+						++exp;
+					}
+
+					tickVal = significand * Math.pow(10, exp);
+				} while (exp < endExp || (exp === endExp && significand < endSignificand));
+
+				var lastTick = valueOrDefault(generationOptions.max, tickVal);
+				ticks.push(lastTick);
+
+				return ticks;
+			}
+		},
+
+		/**
+		 * Namespace to hold formatters for different types of ticks
+		 * @namespace Chart.Ticks.formatters
+		 */
+		formatters: {
+			/**
+			 * Formatter for value labels
+			 * @method Chart.Ticks.formatters.values
+			 * @param value the value to display
+			 * @return {String|Array} the label to display
+			 */
+			values: function(value) {
+				return helpers.isArray(value) ? value : '' + value;
+			},
+
+			/**
+			 * Formatter for linear numeric ticks
+			 * @method Chart.Ticks.formatters.linear
+			 * @param tickValue {Number} the value to be formatted
+			 * @param index {Number} the position of the tickValue parameter in the ticks array
+			 * @param ticks {Array<Number>} the list of ticks being converted
+			 * @return {String} string representation of the tickValue parameter
+			 */
+			linear: function(tickValue, index, ticks) {
+				// If we have lots of ticks, don't use the ones
+				var delta = ticks.length > 3 ? ticks[2] - ticks[1] : ticks[1] - ticks[0];
+
+				// If we have a number like 2.5 as the delta, figure out how many decimal places we need
+				if (Math.abs(delta) > 1) {
+					if (tickValue !== Math.floor(tickValue)) {
+						// not an integer
+						delta = tickValue - Math.floor(tickValue);
+					}
+				}
+
+				var logDelta = helpers.log10(Math.abs(delta));
+				var tickString = '';
+
+				if (tickValue !== 0) {
+					var numDecimal = -1 * Math.floor(logDelta);
+					numDecimal = Math.max(Math.min(numDecimal, 20), 0); // toFixed has a max of 20 decimal places
+					tickString = tickValue.toFixed(numDecimal);
+				} else {
+					tickString = '0'; // never show decimal places for 0
+				}
+
+				return tickString;
+			},
+
+			logarithmic: function(tickValue, index, ticks) {
+				var remain = tickValue / (Math.pow(10, Math.floor(helpers.log10(tickValue))));
+
+				if (tickValue === 0) {
+					return '0';
+				} else if (remain === 1 || remain === 2 || remain === 5 || index === 0 || index === ticks.length - 1) {
+					return tickValue.toExponential();
+				}
+				return '';
+			}
+		}
+	};
+
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('global', {
+		tooltips: {
+			enabled: true,
+			custom: null,
+			mode: 'nearest',
+			position: 'average',
+			intersect: true,
+			backgroundColor: 'rgba(0,0,0,0.8)',
+			titleFontStyle: 'bold',
+			titleSpacing: 2,
+			titleMarginBottom: 6,
+			titleFontColor: '#fff',
+			titleAlign: 'left',
+			bodySpacing: 2,
+			bodyFontColor: '#fff',
+			bodyAlign: 'left',
+			footerFontStyle: 'bold',
+			footerSpacing: 2,
+			footerMarginTop: 6,
+			footerFontColor: '#fff',
+			footerAlign: 'left',
+			yPadding: 6,
+			xPadding: 6,
+			caretPadding: 2,
+			caretSize: 5,
+			cornerRadius: 6,
+			multiKeyBackground: '#fff',
+			displayColors: true,
+			borderColor: 'rgba(0,0,0,0)',
+			borderWidth: 0,
+			callbacks: {
+				// Args are: (tooltipItems, data)
+				beforeTitle: helpers.noop,
+				title: function(tooltipItems, data) {
+					// Pick first xLabel for now
+					var title = '';
+					var labels = data.labels;
+					var labelCount = labels ? labels.length : 0;
+
+					if (tooltipItems.length > 0) {
+						var item = tooltipItems[0];
+
+						if (item.xLabel) {
+							title = item.xLabel;
+						} else if (labelCount > 0 && item.index < labelCount) {
+							title = labels[item.index];
+						}
+					}
+
+					return title;
+				},
+				afterTitle: helpers.noop,
+
+				// Args are: (tooltipItems, data)
+				beforeBody: helpers.noop,
+
+				// Args are: (tooltipItem, data)
+				beforeLabel: helpers.noop,
+				label: function(tooltipItem, data) {
+					var label = data.datasets[tooltipItem.datasetIndex].label || '';
+
+					if (label) {
+						label += ': ';
+					}
+					label += tooltipItem.yLabel;
+					return label;
+				},
+				labelColor: function(tooltipItem, chart) {
+					var meta = chart.getDatasetMeta(tooltipItem.datasetIndex);
+					var activeElement = meta.data[tooltipItem.index];
+					var view = activeElement._view;
+					return {
+						borderColor: view.borderColor,
+						backgroundColor: view.backgroundColor
+					};
+				},
+				labelTextColor: function() {
+					return this._options.bodyFontColor;
+				},
+				afterLabel: helpers.noop,
+
+				// Args are: (tooltipItems, data)
+				afterBody: helpers.noop,
+
+				// Args are: (tooltipItems, data)
+				beforeFooter: helpers.noop,
+				footer: helpers.noop,
+				afterFooter: helpers.noop
+			}
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		/**
+	 	 * Helper method to merge the opacity into a color
+	 	 */
+		function mergeOpacity(colorString, opacity) {
+			var color = helpers.color(colorString);
+			return color.alpha(opacity * color.alpha()).rgbaString();
+		}
+
+		// Helper to push or concat based on if the 2nd parameter is an array or not
+		function pushOrConcat(base, toPush) {
+			if (toPush) {
+				if (helpers.isArray(toPush)) {
+					// base = base.concat(toPush);
+					Array.prototype.push.apply(base, toPush);
+				} else {
+					base.push(toPush);
+				}
+			}
+
+			return base;
+		}
+
+		// Private helper to create a tooltip item model
+		// @param element : the chart element (point, arc, bar) to create the tooltip item for
+		// @return : new tooltip item
+		function createTooltipItem(element) {
+			var xScale = element._xScale;
+			var yScale = element._yScale || element._scale; // handle radar || polarArea charts
+			var index = element._index;
+			var datasetIndex = element._datasetIndex;
+
+			return {
+				xLabel: xScale ? xScale.getLabelForIndex(index, datasetIndex) : '',
+				yLabel: yScale ? yScale.getLabelForIndex(index, datasetIndex) : '',
+				index: index,
+				datasetIndex: datasetIndex,
+				x: element._model.x,
+				y: element._model.y
+			};
+		}
+
+		/**
+		 * Helper to get the reset model for the tooltip
+		 * @param tooltipOpts {Object} the tooltip options
+		 */
+		function getBaseModel(tooltipOpts) {
+			var globalDefaults = defaults.global;
+			var valueOrDefault = helpers.valueOrDefault;
+
+			return {
+				// Positioning
+				xPadding: tooltipOpts.xPadding,
+				yPadding: tooltipOpts.yPadding,
+				xAlign: tooltipOpts.xAlign,
+				yAlign: tooltipOpts.yAlign,
+
+				// Body
+				bodyFontColor: tooltipOpts.bodyFontColor,
+				_bodyFontFamily: valueOrDefault(tooltipOpts.bodyFontFamily, globalDefaults.defaultFontFamily),
+				_bodyFontStyle: valueOrDefault(tooltipOpts.bodyFontStyle, globalDefaults.defaultFontStyle),
+				_bodyAlign: tooltipOpts.bodyAlign,
+				bodyFontSize: valueOrDefault(tooltipOpts.bodyFontSize, globalDefaults.defaultFontSize),
+				bodySpacing: tooltipOpts.bodySpacing,
+
+				// Title
+				titleFontColor: tooltipOpts.titleFontColor,
+				_titleFontFamily: valueOrDefault(tooltipOpts.titleFontFamily, globalDefaults.defaultFontFamily),
+				_titleFontStyle: valueOrDefault(tooltipOpts.titleFontStyle, globalDefaults.defaultFontStyle),
+				titleFontSize: valueOrDefault(tooltipOpts.titleFontSize, globalDefaults.defaultFontSize),
+				_titleAlign: tooltipOpts.titleAlign,
+				titleSpacing: tooltipOpts.titleSpacing,
+				titleMarginBottom: tooltipOpts.titleMarginBottom,
+
+				// Footer
+				footerFontColor: tooltipOpts.footerFontColor,
+				_footerFontFamily: valueOrDefault(tooltipOpts.footerFontFamily, globalDefaults.defaultFontFamily),
+				_footerFontStyle: valueOrDefault(tooltipOpts.footerFontStyle, globalDefaults.defaultFontStyle),
+				footerFontSize: valueOrDefault(tooltipOpts.footerFontSize, globalDefaults.defaultFontSize),
+				_footerAlign: tooltipOpts.footerAlign,
+				footerSpacing: tooltipOpts.footerSpacing,
+				footerMarginTop: tooltipOpts.footerMarginTop,
+
+				// Appearance
+				caretSize: tooltipOpts.caretSize,
+				cornerRadius: tooltipOpts.cornerRadius,
+				backgroundColor: tooltipOpts.backgroundColor,
+				opacity: 0,
+				legendColorBackground: tooltipOpts.multiKeyBackground,
+				displayColors: tooltipOpts.displayColors,
+				borderColor: tooltipOpts.borderColor,
+				borderWidth: tooltipOpts.borderWidth
+			};
+		}
+
+		/**
+		 * Get the size of the tooltip
+		 */
+		function getTooltipSize(tooltip, model) {
+			var ctx = tooltip._chart.ctx;
+
+			var height = model.yPadding * 2; // Tooltip Padding
+			var width = 0;
+
+			// Count of all lines in the body
+			var body = model.body;
+			var combinedBodyLength = body.reduce(function(count, bodyItem) {
+				return count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length;
+			}, 0);
+			combinedBodyLength += model.beforeBody.length + model.afterBody.length;
+
+			var titleLineCount = model.title.length;
+			var footerLineCount = model.footer.length;
+			var titleFontSize = model.titleFontSize;
+			var bodyFontSize = model.bodyFontSize;
+			var footerFontSize = model.footerFontSize;
+
+			height += titleLineCount * titleFontSize; // Title Lines
+			height += titleLineCount ? (titleLineCount - 1) * model.titleSpacing : 0; // Title Line Spacing
+			height += titleLineCount ? model.titleMarginBottom : 0; // Title's bottom Margin
+			height += combinedBodyLength * bodyFontSize; // Body Lines
+			height += combinedBodyLength ? (combinedBodyLength - 1) * model.bodySpacing : 0; // Body Line Spacing
+			height += footerLineCount ? model.footerMarginTop : 0; // Footer Margin
+			height += footerLineCount * (footerFontSize); // Footer Lines
+			height += footerLineCount ? (footerLineCount - 1) * model.footerSpacing : 0; // Footer Line Spacing
+
+			// Title width
+			var widthPadding = 0;
+			var maxLineWidth = function(line) {
+				width = Math.max(width, ctx.measureText(line).width + widthPadding);
+			};
+
+			ctx.font = helpers.fontString(titleFontSize, model._titleFontStyle, model._titleFontFamily);
+			helpers.each(model.title, maxLineWidth);
+
+			// Body width
+			ctx.font = helpers.fontString(bodyFontSize, model._bodyFontStyle, model._bodyFontFamily);
+			helpers.each(model.beforeBody.concat(model.afterBody), maxLineWidth);
+
+			// Body lines may include some extra width due to the color box
+			widthPadding = model.displayColors ? (bodyFontSize + 2) : 0;
+			helpers.each(body, function(bodyItem) {
+				helpers.each(bodyItem.before, maxLineWidth);
+				helpers.each(bodyItem.lines, maxLineWidth);
+				helpers.each(bodyItem.after, maxLineWidth);
+			});
+
+			// Reset back to 0
+			widthPadding = 0;
+
+			// Footer width
+			ctx.font = helpers.fontString(footerFontSize, model._footerFontStyle, model._footerFontFamily);
+			helpers.each(model.footer, maxLineWidth);
+
+			// Add padding
+			width += 2 * model.xPadding;
+
+			return {
+				width: width,
+				height: height
+			};
+		}
+
+		/**
+		 * Helper to get the alignment of a tooltip given the size
+		 */
+		function determineAlignment(tooltip, size) {
+			var model = tooltip._model;
+			var chart = tooltip._chart;
+			var chartArea = tooltip._chart.chartArea;
+			var xAlign = 'center';
+			var yAlign = 'center';
+
+			if (model.y < size.height) {
+				yAlign = 'top';
+			} else if (model.y > (chart.height - size.height)) {
+				yAlign = 'bottom';
+			}
+
+			var lf, rf; // functions to determine left, right alignment
+			var olf, orf; // functions to determine if left/right alignment causes tooltip to go outside chart
+			var yf; // function to get the y alignment if the tooltip goes outside of the left or right edges
+			var midX = (chartArea.left + chartArea.right) / 2;
+			var midY = (chartArea.top + chartArea.bottom) / 2;
+
+			if (yAlign === 'center') {
+				lf = function(x) {
+					return x <= midX;
+				};
+				rf = function(x) {
+					return x > midX;
+				};
+			} else {
+				lf = function(x) {
+					return x <= (size.width / 2);
+				};
+				rf = function(x) {
+					return x >= (chart.width - (size.width / 2));
+				};
+			}
+
+			olf = function(x) {
+				return x + size.width > chart.width;
+			};
+			orf = function(x) {
+				return x - size.width < 0;
+			};
+			yf = function(y) {
+				return y <= midY ? 'top' : 'bottom';
+			};
+
+			if (lf(model.x)) {
+				xAlign = 'left';
+
+				// Is tooltip too wide and goes over the right side of the chart.?
+				if (olf(model.x)) {
+					xAlign = 'center';
+					yAlign = yf(model.y);
+				}
+			} else if (rf(model.x)) {
+				xAlign = 'right';
+
+				// Is tooltip too wide and goes outside left edge of canvas?
+				if (orf(model.x)) {
+					xAlign = 'center';
+					yAlign = yf(model.y);
+				}
+			}
+
+			var opts = tooltip._options;
+			return {
+				xAlign: opts.xAlign ? opts.xAlign : xAlign,
+				yAlign: opts.yAlign ? opts.yAlign : yAlign
+			};
+		}
+
+		/**
+		 * @Helper to get the location a tooltip needs to be placed at given the initial position (via the vm) and the size and alignment
+		 */
+		function getBackgroundPoint(vm, size, alignment) {
+			// Background Position
+			var x = vm.x;
+			var y = vm.y;
+
+			var caretSize = vm.caretSize;
+			var caretPadding = vm.caretPadding;
+			var cornerRadius = vm.cornerRadius;
+			var xAlign = alignment.xAlign;
+			var yAlign = alignment.yAlign;
+			var paddingAndSize = caretSize + caretPadding;
+			var radiusAndPadding = cornerRadius + caretPadding;
+
+			if (xAlign === 'right') {
+				x -= size.width;
+			} else if (xAlign === 'center') {
+				x -= (size.width / 2);
+			}
+
+			if (yAlign === 'top') {
+				y += paddingAndSize;
+			} else if (yAlign === 'bottom') {
+				y -= size.height + paddingAndSize;
+			} else {
+				y -= (size.height / 2);
+			}
+
+			if (yAlign === 'center') {
+				if (xAlign === 'left') {
+					x += paddingAndSize;
+				} else if (xAlign === 'right') {
+					x -= paddingAndSize;
+				}
+			} else if (xAlign === 'left') {
+				x -= radiusAndPadding;
+			} else if (xAlign === 'right') {
+				x += radiusAndPadding;
+			}
+
+			return {
+				x: x,
+				y: y
+			};
+		}
+
+		Chart.Tooltip = Element.extend({
+			initialize: function() {
+				this._model = getBaseModel(this._options);
+			},
+
+			// Get the title
+			// Args are: (tooltipItem, data)
+			getTitle: function() {
+				var me = this;
+				var opts = me._options;
+				var callbacks = opts.callbacks;
+
+				var beforeTitle = callbacks.beforeTitle.apply(me, arguments);
+				var title = callbacks.title.apply(me, arguments);
+				var afterTitle = callbacks.afterTitle.apply(me, arguments);
+
+				var lines = [];
+				lines = pushOrConcat(lines, beforeTitle);
+				lines = pushOrConcat(lines, title);
+				lines = pushOrConcat(lines, afterTitle);
+
+				return lines;
+			},
+
+			// Args are: (tooltipItem, data)
+			getBeforeBody: function() {
+				var lines = this._options.callbacks.beforeBody.apply(this, arguments);
+				return helpers.isArray(lines) ? lines : lines !== undefined ? [lines] : [];
+			},
+
+			// Args are: (tooltipItem, data)
+			getBody: function(tooltipItems, data) {
+				var me = this;
+				var callbacks = me._options.callbacks;
+				var bodyItems = [];
+
+				helpers.each(tooltipItems, function(tooltipItem) {
+					var bodyItem = {
+						before: [],
+						lines: [],
+						after: []
+					};
+					pushOrConcat(bodyItem.before, callbacks.beforeLabel.call(me, tooltipItem, data));
+					pushOrConcat(bodyItem.lines, callbacks.label.call(me, tooltipItem, data));
+					pushOrConcat(bodyItem.after, callbacks.afterLabel.call(me, tooltipItem, data));
+
+					bodyItems.push(bodyItem);
+				});
+
+				return bodyItems;
+			},
+
+			// Args are: (tooltipItem, data)
+			getAfterBody: function() {
+				var lines = this._options.callbacks.afterBody.apply(this, arguments);
+				return helpers.isArray(lines) ? lines : lines !== undefined ? [lines] : [];
+			},
+
+			// Get the footer and beforeFooter and afterFooter lines
+			// Args are: (tooltipItem, data)
+			getFooter: function() {
+				var me = this;
+				var callbacks = me._options.callbacks;
+
+				var beforeFooter = callbacks.beforeFooter.apply(me, arguments);
+				var footer = callbacks.footer.apply(me, arguments);
+				var afterFooter = callbacks.afterFooter.apply(me, arguments);
+
+				var lines = [];
+				lines = pushOrConcat(lines, beforeFooter);
+				lines = pushOrConcat(lines, footer);
+				lines = pushOrConcat(lines, afterFooter);
+
+				return lines;
+			},
+
+			update: function(changed) {
+				var me = this;
+				var opts = me._options;
+
+				// Need to regenerate the model because its faster than using extend and it is necessary due to the optimization in Chart.Element.transition
+				// that does _view = _model if ease === 1. This causes the 2nd tooltip update to set properties in both the view and model at the same time
+				// which breaks any animations.
+				var existingModel = me._model;
+				var model = me._model = getBaseModel(opts);
+				var active = me._active;
+
+				var data = me._data;
+
+				// In the case where active.length === 0 we need to keep these at existing values for good animations
+				var alignment = {
+					xAlign: existingModel.xAlign,
+					yAlign: existingModel.yAlign
+				};
+				var backgroundPoint = {
+					x: existingModel.x,
+					y: existingModel.y
+				};
+				var tooltipSize = {
+					width: existingModel.width,
+					height: existingModel.height
+				};
+				var tooltipPosition = {
+					x: existingModel.caretX,
+					y: existingModel.caretY
+				};
+
+				var i, len;
+
+				if (active.length) {
+					model.opacity = 1;
+
+					var labelColors = [];
+					var labelTextColors = [];
+					tooltipPosition = Chart.Tooltip.positioners[opts.position](active, me._eventPosition);
+
+					var tooltipItems = [];
+					for (i = 0, len = active.length; i < len; ++i) {
+						tooltipItems.push(createTooltipItem(active[i]));
+					}
+
+					// If the user provided a filter function, use it to modify the tooltip items
+					if (opts.filter) {
+						tooltipItems = tooltipItems.filter(function(a) {
+							return opts.filter(a, data);
+						});
+					}
+
+					// If the user provided a sorting function, use it to modify the tooltip items
+					if (opts.itemSort) {
+						tooltipItems = tooltipItems.sort(function(a, b) {
+							return opts.itemSort(a, b, data);
+						});
+					}
+
+					// Determine colors for boxes
+					helpers.each(tooltipItems, function(tooltipItem) {
+						labelColors.push(opts.callbacks.labelColor.call(me, tooltipItem, me._chart));
+						labelTextColors.push(opts.callbacks.labelTextColor.call(me, tooltipItem, me._chart));
+					});
+
+
+					// Build the Text Lines
+					model.title = me.getTitle(tooltipItems, data);
+					model.beforeBody = me.getBeforeBody(tooltipItems, data);
+					model.body = me.getBody(tooltipItems, data);
+					model.afterBody = me.getAfterBody(tooltipItems, data);
+					model.footer = me.getFooter(tooltipItems, data);
+
+					// Initial positioning and colors
+					model.x = Math.round(tooltipPosition.x);
+					model.y = Math.round(tooltipPosition.y);
+					model.caretPadding = opts.caretPadding;
+					model.labelColors = labelColors;
+					model.labelTextColors = labelTextColors;
+
+					// data points
+					model.dataPoints = tooltipItems;
+
+					// We need to determine alignment of the tooltip
+					tooltipSize = getTooltipSize(this, model);
+					alignment = determineAlignment(this, tooltipSize);
+					// Final Size and Position
+					backgroundPoint = getBackgroundPoint(model, tooltipSize, alignment);
+				} else {
+					model.opacity = 0;
+				}
+
+				model.xAlign = alignment.xAlign;
+				model.yAlign = alignment.yAlign;
+				model.x = backgroundPoint.x;
+				model.y = backgroundPoint.y;
+				model.width = tooltipSize.width;
+				model.height = tooltipSize.height;
+
+				// Point where the caret on the tooltip points to
+				model.caretX = tooltipPosition.x;
+				model.caretY = tooltipPosition.y;
+
+				me._model = model;
+
+				if (changed && opts.custom) {
+					opts.custom.call(me, model);
+				}
+
+				return me;
+			},
+			drawCaret: function(tooltipPoint, size) {
+				var ctx = this._chart.ctx;
+				var vm = this._view;
+				var caretPosition = this.getCaretPosition(tooltipPoint, size, vm);
+
+				ctx.lineTo(caretPosition.x1, caretPosition.y1);
+				ctx.lineTo(caretPosition.x2, caretPosition.y2);
+				ctx.lineTo(caretPosition.x3, caretPosition.y3);
+			},
+			getCaretPosition: function(tooltipPoint, size, vm) {
+				var x1, x2, x3, y1, y2, y3;
+				var caretSize = vm.caretSize;
+				var cornerRadius = vm.cornerRadius;
+				var xAlign = vm.xAlign;
+				var yAlign = vm.yAlign;
+				var ptX = tooltipPoint.x;
+				var ptY = tooltipPoint.y;
+				var width = size.width;
+				var height = size.height;
+
+				if (yAlign === 'center') {
+					y2 = ptY + (height / 2);
+
+					if (xAlign === 'left') {
+						x1 = ptX;
+						x2 = x1 - caretSize;
+						x3 = x1;
+
+						y1 = y2 + caretSize;
+						y3 = y2 - caretSize;
+					} else {
+						x1 = ptX + width;
+						x2 = x1 + caretSize;
+						x3 = x1;
+
+						y1 = y2 - caretSize;
+						y3 = y2 + caretSize;
+					}
+				} else {
+					if (xAlign === 'left') {
+						x2 = ptX + cornerRadius + (caretSize);
+						x1 = x2 - caretSize;
+						x3 = x2 + caretSize;
+					} else if (xAlign === 'right') {
+						x2 = ptX + width - cornerRadius - caretSize;
+						x1 = x2 - caretSize;
+						x3 = x2 + caretSize;
+					} else {
+						x2 = ptX + (width / 2);
+						x1 = x2 - caretSize;
+						x3 = x2 + caretSize;
+					}
+					if (yAlign === 'top') {
+						y1 = ptY;
+						y2 = y1 - caretSize;
+						y3 = y1;
+					} else {
+						y1 = ptY + height;
+						y2 = y1 + caretSize;
+						y3 = y1;
+						// invert drawing order
+						var tmp = x3;
+						x3 = x1;
+						x1 = tmp;
+					}
+				}
+				return {x1: x1, x2: x2, x3: x3, y1: y1, y2: y2, y3: y3};
+			},
+			drawTitle: function(pt, vm, ctx, opacity) {
+				var title = vm.title;
+
+				if (title.length) {
+					ctx.textAlign = vm._titleAlign;
+					ctx.textBaseline = 'top';
+
+					var titleFontSize = vm.titleFontSize;
+					var titleSpacing = vm.titleSpacing;
+
+					ctx.fillStyle = mergeOpacity(vm.titleFontColor, opacity);
+					ctx.font = helpers.fontString(titleFontSize, vm._titleFontStyle, vm._titleFontFamily);
+
+					var i, len;
+					for (i = 0, len = title.length; i < len; ++i) {
+						ctx.fillText(title[i], pt.x, pt.y);
+						pt.y += titleFontSize + titleSpacing; // Line Height and spacing
+
+						if (i + 1 === title.length) {
+							pt.y += vm.titleMarginBottom - titleSpacing; // If Last, add margin, remove spacing
+						}
+					}
+				}
+			},
+			drawBody: function(pt, vm, ctx, opacity) {
+				var bodyFontSize = vm.bodyFontSize;
+				var bodySpacing = vm.bodySpacing;
+				var body = vm.body;
+
+				ctx.textAlign = vm._bodyAlign;
+				ctx.textBaseline = 'top';
+				ctx.font = helpers.fontString(bodyFontSize, vm._bodyFontStyle, vm._bodyFontFamily);
+
+				// Before Body
+				var xLinePadding = 0;
+				var fillLineOfText = function(line) {
+					ctx.fillText(line, pt.x + xLinePadding, pt.y);
+					pt.y += bodyFontSize + bodySpacing;
+				};
+
+				// Before body lines
+				helpers.each(vm.beforeBody, fillLineOfText);
+
+				var drawColorBoxes = vm.displayColors;
+				xLinePadding = drawColorBoxes ? (bodyFontSize + 2) : 0;
+
+				// Draw body lines now
+				helpers.each(body, function(bodyItem, i) {
+					helpers.each(bodyItem.before, fillLineOfText);
+
+					helpers.each(bodyItem.lines, function(line) {
+						// Draw Legend-like boxes if needed
+						if (drawColorBoxes) {
+							// Fill a white rect so that colours merge nicely if the opacity is < 1
+							ctx.fillStyle = mergeOpacity(vm.legendColorBackground, opacity);
+							ctx.fillRect(pt.x, pt.y, bodyFontSize, bodyFontSize);
+
+							// Border
+							ctx.lineWidth = 1;
+							ctx.strokeStyle = mergeOpacity(vm.labelColors[i].borderColor, opacity);
+							ctx.strokeRect(pt.x, pt.y, bodyFontSize, bodyFontSize);
+
+							// Inner square
+							ctx.fillStyle = mergeOpacity(vm.labelColors[i].backgroundColor, opacity);
+							ctx.fillRect(pt.x + 1, pt.y + 1, bodyFontSize - 2, bodyFontSize - 2);
+							var textColor = mergeOpacity(vm.labelTextColors[i], opacity);
+							ctx.fillStyle = textColor;
+						}
+
+						fillLineOfText(line);
+					});
+
+					helpers.each(bodyItem.after, fillLineOfText);
+				});
+
+				// Reset back to 0 for after body
+				xLinePadding = 0;
+
+				// After body lines
+				helpers.each(vm.afterBody, fillLineOfText);
+				pt.y -= bodySpacing; // Remove last body spacing
+			},
+			drawFooter: function(pt, vm, ctx, opacity) {
+				var footer = vm.footer;
+
+				if (footer.length) {
+					pt.y += vm.footerMarginTop;
+
+					ctx.textAlign = vm._footerAlign;
+					ctx.textBaseline = 'top';
+
+					ctx.fillStyle = mergeOpacity(vm.footerFontColor, opacity);
+					ctx.font = helpers.fontString(vm.footerFontSize, vm._footerFontStyle, vm._footerFontFamily);
+
+					helpers.each(footer, function(line) {
+						ctx.fillText(line, pt.x, pt.y);
+						pt.y += vm.footerFontSize + vm.footerSpacing;
+					});
+				}
+			},
+			drawBackground: function(pt, vm, ctx, tooltipSize, opacity) {
+				ctx.fillStyle = mergeOpacity(vm.backgroundColor, opacity);
+				ctx.strokeStyle = mergeOpacity(vm.borderColor, opacity);
+				ctx.lineWidth = vm.borderWidth;
+				var xAlign = vm.xAlign;
+				var yAlign = vm.yAlign;
+				var x = pt.x;
+				var y = pt.y;
+				var width = tooltipSize.width;
+				var height = tooltipSize.height;
+				var radius = vm.cornerRadius;
+
+				ctx.beginPath();
+				ctx.moveTo(x + radius, y);
+				if (yAlign === 'top') {
+					this.drawCaret(pt, tooltipSize);
+				}
+				ctx.lineTo(x + width - radius, y);
+				ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+				if (yAlign === 'center' && xAlign === 'right') {
+					this.drawCaret(pt, tooltipSize);
+				}
+				ctx.lineTo(x + width, y + height - radius);
+				ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+				if (yAlign === 'bottom') {
+					this.drawCaret(pt, tooltipSize);
+				}
+				ctx.lineTo(x + radius, y + height);
+				ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+				if (yAlign === 'center' && xAlign === 'left') {
+					this.drawCaret(pt, tooltipSize);
+				}
+				ctx.lineTo(x, y + radius);
+				ctx.quadraticCurveTo(x, y, x + radius, y);
+				ctx.closePath();
+
+				ctx.fill();
+
+				if (vm.borderWidth > 0) {
+					ctx.stroke();
+				}
+			},
+			draw: function() {
+				var ctx = this._chart.ctx;
+				var vm = this._view;
+
+				if (vm.opacity === 0) {
+					return;
+				}
+
+				var tooltipSize = {
+					width: vm.width,
+					height: vm.height
+				};
+				var pt = {
+					x: vm.x,
+					y: vm.y
+				};
+
+				// IE11/Edge does not like very small opacities, so snap to 0
+				var opacity = Math.abs(vm.opacity < 1e-3) ? 0 : vm.opacity;
+
+				// Truthy/falsey value for empty tooltip
+				var hasTooltipContent = vm.title.length || vm.beforeBody.length || vm.body.length || vm.afterBody.length || vm.footer.length;
+
+				if (this._options.enabled && hasTooltipContent) {
+					// Draw Background
+					this.drawBackground(pt, vm, ctx, tooltipSize, opacity);
+
+					// Draw Title, Body, and Footer
+					pt.x += vm.xPadding;
+					pt.y += vm.yPadding;
+
+					// Titles
+					this.drawTitle(pt, vm, ctx, opacity);
+
+					// Body
+					this.drawBody(pt, vm, ctx, opacity);
+
+					// Footer
+					this.drawFooter(pt, vm, ctx, opacity);
+				}
+			},
+
+			/**
+			 * Handle an event
+			 * @private
+			 * @param {IEvent} event - The event to handle
+			 * @returns {Boolean} true if the tooltip changed
+			 */
+			handleEvent: function(e) {
+				var me = this;
+				var options = me._options;
+				var changed = false;
+
+				me._lastActive = me._lastActive || [];
+
+				// Find Active Elements for tooltips
+				if (e.type === 'mouseout') {
+					me._active = [];
+				} else {
+					me._active = me._chart.getElementsAtEventForMode(e, options.mode, options);
+				}
+
+				// Remember Last Actives
+				changed = !helpers.arrayEquals(me._active, me._lastActive);
+
+				// If tooltip didn't change, do not handle the target event
+				if (!changed) {
+					return false;
+				}
+
+				me._lastActive = me._active;
+
+				if (options.enabled || options.custom) {
+					me._eventPosition = {
+						x: e.x,
+						y: e.y
+					};
+
+					var model = me._model;
+					me.update(true);
+					me.pivot();
+
+					// See if our tooltip position changed
+					changed |= (model.x !== me._model.x) || (model.y !== me._model.y);
+				}
+
+				return changed;
+			}
+		});
+
+		/**
+		 * @namespace Chart.Tooltip.positioners
+		 */
+		Chart.Tooltip.positioners = {
+			/**
+			 * Average mode places the tooltip at the average position of the elements shown
+			 * @function Chart.Tooltip.positioners.average
+			 * @param elements {ChartElement[]} the elements being displayed in the tooltip
+			 * @returns {Point} tooltip position
+			 */
+			average: function(elements) {
+				if (!elements.length) {
+					return false;
+				}
+
+				var i, len;
+				var x = 0;
+				var y = 0;
+				var count = 0;
+
+				for (i = 0, len = elements.length; i < len; ++i) {
+					var el = elements[i];
+					if (el && el.hasValue()) {
+						var pos = el.tooltipPosition();
+						x += pos.x;
+						y += pos.y;
+						++count;
+					}
+				}
+
+				return {
+					x: Math.round(x / count),
+					y: Math.round(y / count)
+				};
+			},
+
+			/**
+			 * Gets the tooltip position nearest of the item nearest to the event position
+			 * @function Chart.Tooltip.positioners.nearest
+			 * @param elements {Chart.Element[]} the tooltip elements
+			 * @param eventPosition {Point} the position of the event in canvas coordinates
+			 * @returns {Point} the tooltip position
+			 */
+			nearest: function(elements, eventPosition) {
+				var x = eventPosition.x;
+				var y = eventPosition.y;
+				var minDistance = Number.POSITIVE_INFINITY;
+				var i, len, nearestElement;
+
+				for (i = 0, len = elements.length; i < len; ++i) {
+					var el = elements[i];
+					if (el && el.hasValue()) {
+						var center = el.getCenterPoint();
+						var d = helpers.distanceBetweenPoints(eventPosition, center);
+
+						if (d < minDistance) {
+							minDistance = d;
+							nearestElement = el;
+						}
+					}
+				}
+
+				if (nearestElement) {
+					var tp = nearestElement.tooltipPosition();
+					x = tp.x;
+					y = tp.y;
+				}
+
+				return {
+					x: x,
+					y: y
+				};
+			}
+		};
+	};
+
+
+/***/ },
+/* 37 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+	var Ticks = __webpack_require__(35);
+
+	module.exports = function(Chart) {
+
+		var noop = helpers.noop;
+
+		Chart.LinearScaleBase = Chart.Scale.extend({
+			getRightValue: function(value) {
+				if (typeof value === 'string') {
+					return +value;
+				}
+				return Chart.Scale.prototype.getRightValue.call(this, value);
+			},
+
+			handleTickRangeOptions: function() {
+				var me = this;
+				var opts = me.options;
+				var tickOpts = opts.ticks;
+
+				// If we are forcing it to begin at 0, but 0 will already be rendered on the chart,
+				// do nothing since that would make the chart weird. If the user really wants a weird chart
+				// axis, they can manually override it
+				if (tickOpts.beginAtZero) {
+					var minSign = helpers.sign(me.min);
+					var maxSign = helpers.sign(me.max);
+
+					if (minSign < 0 && maxSign < 0) {
+						// move the top up to 0
+						me.max = 0;
+					} else if (minSign > 0 && maxSign > 0) {
+						// move the bottom down to 0
+						me.min = 0;
+					}
+				}
+
+				var setMin = tickOpts.min !== undefined || tickOpts.suggestedMin !== undefined;
+				var setMax = tickOpts.max !== undefined || tickOpts.suggestedMax !== undefined;
+
+				if (tickOpts.min !== undefined) {
+					me.min = tickOpts.min;
+				} else if (tickOpts.suggestedMin !== undefined) {
+					if (me.min === null) {
+						me.min = tickOpts.suggestedMin;
+					} else {
+						me.min = Math.min(me.min, tickOpts.suggestedMin);
+					}
+				}
+
+				if (tickOpts.max !== undefined) {
+					me.max = tickOpts.max;
+				} else if (tickOpts.suggestedMax !== undefined) {
+					if (me.max === null) {
+						me.max = tickOpts.suggestedMax;
+					} else {
+						me.max = Math.max(me.max, tickOpts.suggestedMax);
+					}
+				}
+
+				if (setMin !== setMax) {
+					// We set the min or the max but not both.
+					// So ensure that our range is good
+					// Inverted or 0 length range can happen when
+					// ticks.min is set, and no datasets are visible
+					if (me.min >= me.max) {
+						if (setMin) {
+							me.max = me.min + 1;
+						} else {
+							me.min = me.max - 1;
+						}
+					}
+				}
+
+				if (me.min === me.max) {
+					me.max++;
+
+					if (!tickOpts.beginAtZero) {
+						me.min--;
+					}
+				}
+			},
+			getTickLimit: noop,
+			handleDirectionalChanges: noop,
+
+			buildTicks: function() {
+				var me = this;
+				var opts = me.options;
+				var tickOpts = opts.ticks;
+
+				// Figure out what the max number of ticks we can support it is based on the size of
+				// the axis area. For now, we say that the minimum tick spacing in pixels must be 50
+				// We also limit the maximum number of ticks to 11 which gives a nice 10 squares on
+				// the graph. Make sure we always have at least 2 ticks
+				var maxTicks = me.getTickLimit();
+				maxTicks = Math.max(2, maxTicks);
+
+				var numericGeneratorOptions = {
+					maxTicks: maxTicks,
+					min: tickOpts.min,
+					max: tickOpts.max,
+					stepSize: helpers.valueOrDefault(tickOpts.fixedStepSize, tickOpts.stepSize)
+				};
+				var ticks = me.ticks = Ticks.generators.linear(numericGeneratorOptions, me);
+
+				me.handleDirectionalChanges();
+
+				// At this point, we need to update our max and min given the tick values since we have expanded the
+				// range of the scale
+				me.max = helpers.max(ticks);
+				me.min = helpers.min(ticks);
+
+				if (tickOpts.reverse) {
+					ticks.reverse();
+
+					me.start = me.max;
+					me.end = me.min;
+				} else {
+					me.start = me.min;
+					me.end = me.max;
+				}
+			},
+			convertTicksToLabels: function() {
+				var me = this;
+				me.ticksAsNumbers = me.ticks.slice();
+				me.zeroLineIndex = me.ticks.indexOf(0);
+
+				Chart.Scale.prototype.convertTicksToLabels.call(me);
+			}
+		});
+	};
+
+
+/***/ },
+/* 38 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+
+		// Default config for a category scale
+		var defaultConfig = {
+			position: 'bottom'
+		};
+
+		var DatasetScale = Chart.Scale.extend({
+			/**
+			* Internal function to get the correct labels. If data.xLabels or data.yLabels are defined, use those
+			* else fall back to data.labels
+			* @private
+			*/
+			getLabels: function() {
+				var data = this.chart.data;
+				return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels;
+			},
+
+			determineDataLimits: function() {
+				var me = this;
+				var labels = me.getLabels();
+				me.minIndex = 0;
+				me.maxIndex = labels.length - 1;
+				var findIndex;
+
+				if (me.options.ticks.min !== undefined) {
+					// user specified min value
+					findIndex = labels.indexOf(me.options.ticks.min);
+					me.minIndex = findIndex !== -1 ? findIndex : me.minIndex;
+				}
+
+				if (me.options.ticks.max !== undefined) {
+					// user specified max value
+					findIndex = labels.indexOf(me.options.ticks.max);
+					me.maxIndex = findIndex !== -1 ? findIndex : me.maxIndex;
+				}
+
+				me.min = labels[me.minIndex];
+				me.max = labels[me.maxIndex];
+			},
+
+			buildTicks: function() {
+				var me = this;
+				var labels = me.getLabels();
+				// If we are viewing some subset of labels, slice the original array
+				me.ticks = (me.minIndex === 0 && me.maxIndex === labels.length - 1) ? labels : labels.slice(me.minIndex, me.maxIndex + 1);
+			},
+
+			getLabelForIndex: function(index, datasetIndex) {
+				var me = this;
+				var data = me.chart.data;
+				var isHorizontal = me.isHorizontal();
+
+				if (data.yLabels && !isHorizontal) {
+					return me.getRightValue(data.datasets[datasetIndex].data[index]);
+				}
+				return me.ticks[index - me.minIndex];
+			},
+
+			// Used to get data value locations.  Value can either be an index or a numerical value
+			getPixelForValue: function(value, index) {
+				var me = this;
+				var offset = me.options.offset;
+				// 1 is added because we need the length but we have the indexes
+				var offsetAmt = Math.max((me.maxIndex + 1 - me.minIndex - (offset ? 0 : 1)), 1);
+
+				// If value is a data object, then index is the index in the data array,
+				// not the index of the scale. We need to change that.
+				var valueCategory;
+				if (value !== undefined && value !== null) {
+					valueCategory = me.isHorizontal() ? value.x : value.y;
+				}
+				if (valueCategory !== undefined || (value !== undefined && isNaN(index))) {
+					var labels = me.getLabels();
+					value = valueCategory || value;
+					var idx = labels.indexOf(value);
+					index = idx !== -1 ? idx : index;
+				}
+
+				if (me.isHorizontal()) {
+					var valueWidth = me.width / offsetAmt;
+					var widthOffset = (valueWidth * (index - me.minIndex));
+
+					if (offset) {
+						widthOffset += (valueWidth / 2);
+					}
+
+					return me.left + Math.round(widthOffset);
+				}
+				var valueHeight = me.height / offsetAmt;
+				var heightOffset = (valueHeight * (index - me.minIndex));
+
+				if (offset) {
+					heightOffset += (valueHeight / 2);
+				}
+
+				return me.top + Math.round(heightOffset);
+			},
+			getPixelForTick: function(index) {
+				return this.getPixelForValue(this.ticks[index], index + this.minIndex, null);
+			},
+			getValueForPixel: function(pixel) {
+				var me = this;
+				var offset = me.options.offset;
+				var value;
+				var offsetAmt = Math.max((me._ticks.length - (offset ? 0 : 1)), 1);
+				var horz = me.isHorizontal();
+				var valueDimension = (horz ? me.width : me.height) / offsetAmt;
+
+				pixel -= horz ? me.left : me.top;
+
+				if (offset) {
+					pixel -= (valueDimension / 2);
+				}
+
+				if (pixel <= 0) {
+					value = 0;
+				} else {
+					value = Math.round(pixel / valueDimension);
+				}
+
+				return value + me.minIndex;
+			},
+			getBasePixel: function() {
+				return this.bottom;
+			}
+		});
+
+		Chart.scaleService.registerScaleType('category', DatasetScale, defaultConfig);
+
+	};
+
+
+/***/ },
+/* 39 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var helpers = __webpack_require__(7);
+	var Ticks = __webpack_require__(35);
+
+	module.exports = function(Chart) {
+
+		var defaultConfig = {
+			position: 'left',
+			ticks: {
+				callback: Ticks.formatters.linear
+			}
+		};
+
+		var LinearScale = Chart.LinearScaleBase.extend({
+
+			determineDataLimits: function() {
+				var me = this;
+				var opts = me.options;
+				var chart = me.chart;
+				var data = chart.data;
+				var datasets = data.datasets;
+				var isHorizontal = me.isHorizontal();
+				var DEFAULT_MIN = 0;
+				var DEFAULT_MAX = 1;
+
+				function IDMatches(meta) {
+					return isHorizontal ? meta.xAxisID === me.id : meta.yAxisID === me.id;
+				}
+
+				// First Calculate the range
+				me.min = null;
+				me.max = null;
+
+				var hasStacks = opts.stacked;
+				if (hasStacks === undefined) {
+					helpers.each(datasets, function(dataset, datasetIndex) {
+						if (hasStacks) {
+							return;
+						}
+
+						var meta = chart.getDatasetMeta(datasetIndex);
+						if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta) &&
+							meta.stack !== undefined) {
+							hasStacks = true;
+						}
+					});
+				}
+
+				if (opts.stacked || hasStacks) {
+					var valuesPerStack = {};
+
+					helpers.each(datasets, function(dataset, datasetIndex) {
+						var meta = chart.getDatasetMeta(datasetIndex);
+						var key = [
+							meta.type,
+							// we have a separate stack for stack=undefined datasets when the opts.stacked is undefined
+							((opts.stacked === undefined && meta.stack === undefined) ? datasetIndex : ''),
+							meta.stack
+						].join('.');
+
+						if (valuesPerStack[key] === undefined) {
+							valuesPerStack[key] = {
+								positiveValues: [],
+								negativeValues: []
+							};
+						}
+
+						// Store these per type
+						var positiveValues = valuesPerStack[key].positiveValues;
+						var negativeValues = valuesPerStack[key].negativeValues;
+
+						if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) {
+							helpers.each(dataset.data, function(rawValue, index) {
+								var value = +me.getRightValue(rawValue);
+								if (isNaN(value) || meta.data[index].hidden) {
+									return;
+								}
+
+								positiveValues[index] = positiveValues[index] || 0;
+								negativeValues[index] = negativeValues[index] || 0;
+
+								if (opts.relativePoints) {
+									positiveValues[index] = 100;
+								} else if (value < 0) {
+									negativeValues[index] += value;
+								} else {
+									positiveValues[index] += value;
+								}
+							});
+						}
+					});
+
+					helpers.each(valuesPerStack, function(valuesForType) {
+						var values = valuesForType.positiveValues.concat(valuesForType.negativeValues);
+						var minVal = helpers.min(values);
+						var maxVal = helpers.max(values);
+						me.min = me.min === null ? minVal : Math.min(me.min, minVal);
+						me.max = me.max === null ? maxVal : Math.max(me.max, maxVal);
+					});
+
+				} else {
+					helpers.each(datasets, function(dataset, datasetIndex) {
+						var meta = chart.getDatasetMeta(datasetIndex);
+						if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) {
+							helpers.each(dataset.data, function(rawValue, index) {
+								var value = +me.getRightValue(rawValue);
+								if (isNaN(value) || meta.data[index].hidden) {
+									return;
+								}
+
+								if (me.min === null) {
+									me.min = value;
+								} else if (value < me.min) {
+									me.min = value;
+								}
+
+								if (me.max === null) {
+									me.max = value;
+								} else if (value > me.max) {
+									me.max = value;
+								}
+							});
+						}
+					});
+				}
+
+				me.min = isFinite(me.min) && !isNaN(me.min) ? me.min : DEFAULT_MIN;
+				me.max = isFinite(me.max) && !isNaN(me.max) ? me.max : DEFAULT_MAX;
+
+				// Common base implementation to handle ticks.min, ticks.max, ticks.beginAtZero
+				this.handleTickRangeOptions();
+			},
+			getTickLimit: function() {
+				var maxTicks;
+				var me = this;
+				var tickOpts = me.options.ticks;
+
+				if (me.isHorizontal()) {
+					maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(me.width / 50));
+				} else {
+					// The factor of 2 used to scale the font size has been experimentally determined.
+					var tickFontSize = helpers.valueOrDefault(tickOpts.fontSize, defaults.global.defaultFontSize);
+					maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(me.height / (2 * tickFontSize)));
+				}
+
+				return maxTicks;
+			},
+			// Called after the ticks are built. We need
+			handleDirectionalChanges: function() {
+				if (!this.isHorizontal()) {
+					// We are in a vertical orientation. The top value is the highest. So reverse the array
+					this.ticks.reverse();
+				}
+			},
+			getLabelForIndex: function(index, datasetIndex) {
+				return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]);
+			},
+			// Utils
+			getPixelForValue: function(value) {
+				// This must be called after fit has been run so that
+				// this.left, this.top, this.right, and this.bottom have been defined
+				var me = this;
+				var start = me.start;
+
+				var rightValue = +me.getRightValue(value);
+				var pixel;
+				var range = me.end - start;
+
+				if (me.isHorizontal()) {
+					pixel = me.left + (me.width / range * (rightValue - start));
+					return Math.round(pixel);
+				}
+
+				pixel = me.bottom - (me.height / range * (rightValue - start));
+				return Math.round(pixel);
+			},
+			getValueForPixel: function(pixel) {
+				var me = this;
+				var isHorizontal = me.isHorizontal();
+				var innerDimension = isHorizontal ? me.width : me.height;
+				var offset = (isHorizontal ? pixel - me.left : me.bottom - pixel) / innerDimension;
+				return me.start + ((me.end - me.start) * offset);
+			},
+			getPixelForTick: function(index) {
+				return this.getPixelForValue(this.ticksAsNumbers[index]);
+			}
+		});
+		Chart.scaleService.registerScaleType('linear', LinearScale, defaultConfig);
+
+	};
+
+
+/***/ },
+/* 40 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var helpers = __webpack_require__(7);
+	var Ticks = __webpack_require__(35);
+
+	module.exports = function(Chart) {
+
+		var defaultConfig = {
+			position: 'left',
+
+			// label settings
+			ticks: {
+				callback: Ticks.formatters.logarithmic
+			}
+		};
+
+		var LogarithmicScale = Chart.Scale.extend({
+			determineDataLimits: function() {
+				var me = this;
+				var opts = me.options;
+				var tickOpts = opts.ticks;
+				var chart = me.chart;
+				var data = chart.data;
+				var datasets = data.datasets;
+				var valueOrDefault = helpers.valueOrDefault;
+				var isHorizontal = me.isHorizontal();
+				function IDMatches(meta) {
+					return isHorizontal ? meta.xAxisID === me.id : meta.yAxisID === me.id;
+				}
+
+				// Calculate Range
+				me.min = null;
+				me.max = null;
+				me.minNotZero = null;
+
+				var hasStacks = opts.stacked;
+				if (hasStacks === undefined) {
+					helpers.each(datasets, function(dataset, datasetIndex) {
+						if (hasStacks) {
+							return;
+						}
+
+						var meta = chart.getDatasetMeta(datasetIndex);
+						if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta) &&
+							meta.stack !== undefined) {
+							hasStacks = true;
+						}
+					});
+				}
+
+				if (opts.stacked || hasStacks) {
+					var valuesPerStack = {};
+
+					helpers.each(datasets, function(dataset, datasetIndex) {
+						var meta = chart.getDatasetMeta(datasetIndex);
+						var key = [
+							meta.type,
+							// we have a separate stack for stack=undefined datasets when the opts.stacked is undefined
+							((opts.stacked === undefined && meta.stack === undefined) ? datasetIndex : ''),
+							meta.stack
+						].join('.');
+
+						if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) {
+							if (valuesPerStack[key] === undefined) {
+								valuesPerStack[key] = [];
+							}
+
+							helpers.each(dataset.data, function(rawValue, index) {
+								var values = valuesPerStack[key];
+								var value = +me.getRightValue(rawValue);
+								if (isNaN(value) || meta.data[index].hidden) {
+									return;
+								}
+
+								values[index] = values[index] || 0;
+
+								if (opts.relativePoints) {
+									values[index] = 100;
+								} else {
+									// Don't need to split positive and negative since the log scale can't handle a 0 crossing
+									values[index] += value;
+								}
+							});
+						}
+					});
+
+					helpers.each(valuesPerStack, function(valuesForType) {
+						var minVal = helpers.min(valuesForType);
+						var maxVal = helpers.max(valuesForType);
+						me.min = me.min === null ? minVal : Math.min(me.min, minVal);
+						me.max = me.max === null ? maxVal : Math.max(me.max, maxVal);
+					});
+
+				} else {
+					helpers.each(datasets, function(dataset, datasetIndex) {
+						var meta = chart.getDatasetMeta(datasetIndex);
+						if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) {
+							helpers.each(dataset.data, function(rawValue, index) {
+								var value = +me.getRightValue(rawValue);
+								if (isNaN(value) || meta.data[index].hidden) {
+									return;
+								}
+
+								if (me.min === null) {
+									me.min = value;
+								} else if (value < me.min) {
+									me.min = value;
+								}
+
+								if (me.max === null) {
+									me.max = value;
+								} else if (value > me.max) {
+									me.max = value;
+								}
+
+								if (value !== 0 && (me.minNotZero === null || value < me.minNotZero)) {
+									me.minNotZero = value;
+								}
+							});
+						}
+					});
+				}
+
+				me.min = valueOrDefault(tickOpts.min, me.min);
+				me.max = valueOrDefault(tickOpts.max, me.max);
+
+				if (me.min === me.max) {
+					if (me.min !== 0 && me.min !== null) {
+						me.min = Math.pow(10, Math.floor(helpers.log10(me.min)) - 1);
+						me.max = Math.pow(10, Math.floor(helpers.log10(me.max)) + 1);
+					} else {
+						me.min = 1;
+						me.max = 10;
+					}
+				}
+			},
+			buildTicks: function() {
+				var me = this;
+				var opts = me.options;
+				var tickOpts = opts.ticks;
+
+				var generationOptions = {
+					min: tickOpts.min,
+					max: tickOpts.max
+				};
+				var ticks = me.ticks = Ticks.generators.logarithmic(generationOptions, me);
+
+				if (!me.isHorizontal()) {
+					// We are in a vertical orientation. The top value is the highest. So reverse the array
+					ticks.reverse();
+				}
+
+				// At this point, we need to update our max and min given the tick values since we have expanded the
+				// range of the scale
+				me.max = helpers.max(ticks);
+				me.min = helpers.min(ticks);
+
+				if (tickOpts.reverse) {
+					ticks.reverse();
+
+					me.start = me.max;
+					me.end = me.min;
+				} else {
+					me.start = me.min;
+					me.end = me.max;
+				}
+			},
+			convertTicksToLabels: function() {
+				this.tickValues = this.ticks.slice();
+
+				Chart.Scale.prototype.convertTicksToLabels.call(this);
+			},
+			// Get the correct tooltip label
+			getLabelForIndex: function(index, datasetIndex) {
+				return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]);
+			},
+			getPixelForTick: function(index) {
+				return this.getPixelForValue(this.tickValues[index]);
+			},
+			getPixelForValue: function(value) {
+				var me = this;
+				var start = me.start;
+				var newVal = +me.getRightValue(value);
+				var opts = me.options;
+				var tickOpts = opts.ticks;
+				var innerDimension, pixel, range;
+
+				if (me.isHorizontal()) {
+					range = helpers.log10(me.end) - helpers.log10(start); // todo: if start === 0
+					if (newVal === 0) {
+						pixel = me.left;
+					} else {
+						innerDimension = me.width;
+						pixel = me.left + (innerDimension / range * (helpers.log10(newVal) - helpers.log10(start)));
+					}
+				} else {
+					// Bottom - top since pixels increase downward on a screen
+					innerDimension = me.height;
+					if (start === 0 && !tickOpts.reverse) {
+						range = helpers.log10(me.end) - helpers.log10(me.minNotZero);
+						if (newVal === start) {
+							pixel = me.bottom;
+						} else if (newVal === me.minNotZero) {
+							pixel = me.bottom - innerDimension * 0.02;
+						} else {
+							pixel = me.bottom - innerDimension * 0.02 - (innerDimension * 0.98 / range * (helpers.log10(newVal) - helpers.log10(me.minNotZero)));
+						}
+					} else if (me.end === 0 && tickOpts.reverse) {
+						range = helpers.log10(me.start) - helpers.log10(me.minNotZero);
+						if (newVal === me.end) {
+							pixel = me.top;
+						} else if (newVal === me.minNotZero) {
+							pixel = me.top + innerDimension * 0.02;
+						} else {
+							pixel = me.top + innerDimension * 0.02 + (innerDimension * 0.98 / range * (helpers.log10(newVal) - helpers.log10(me.minNotZero)));
+						}
+					} else if (newVal === 0) {
+						pixel = tickOpts.reverse ? me.top : me.bottom;
+					} else {
+						range = helpers.log10(me.end) - helpers.log10(start);
+						innerDimension = me.height;
+						pixel = me.bottom - (innerDimension / range * (helpers.log10(newVal) - helpers.log10(start)));
+					}
+				}
+				return pixel;
+			},
+			getValueForPixel: function(pixel) {
+				var me = this;
+				var range = helpers.log10(me.end) - helpers.log10(me.start);
+				var value, innerDimension;
+
+				if (me.isHorizontal()) {
+					innerDimension = me.width;
+					value = me.start * Math.pow(10, (pixel - me.left) * range / innerDimension);
+				} else { // todo: if start === 0
+					innerDimension = me.height;
+					value = Math.pow(10, (me.bottom - pixel) * range / innerDimension) / me.start;
+				}
+				return value;
+			}
+		});
+		Chart.scaleService.registerScaleType('logarithmic', LogarithmicScale, defaultConfig);
+
+	};
+
+
+/***/ },
+/* 41 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var helpers = __webpack_require__(7);
+	var Ticks = __webpack_require__(35);
+
+	module.exports = function(Chart) {
+
+		var globalDefaults = defaults.global;
+
+		var defaultConfig = {
+			display: true,
+
+			// Boolean - Whether to animate scaling the chart from the centre
+			animate: true,
+			position: 'chartArea',
+
+			angleLines: {
+				display: true,
+				color: 'rgba(0, 0, 0, 0.1)',
+				lineWidth: 1
+			},
+
+			gridLines: {
+				circular: false
+			},
+
+			// label settings
+			ticks: {
+				// Boolean - Show a backdrop to the scale label
+				showLabelBackdrop: true,
+
+				// String - The colour of the label backdrop
+				backdropColor: 'rgba(255,255,255,0.75)',
+
+				// Number - The backdrop padding above & below the label in pixels
+				backdropPaddingY: 2,
+
+				// Number - The backdrop padding to the side of the label in pixels
+				backdropPaddingX: 2,
+
+				callback: Ticks.formatters.linear
+			},
+
+			pointLabels: {
+				// Boolean - if true, show point labels
+				display: true,
+
+				// Number - Point label font size in pixels
+				fontSize: 10,
+
+				// Function - Used to convert point labels
+				callback: function(label) {
+					return label;
+				}
+			}
+		};
+
+		function getValueCount(scale) {
+			var opts = scale.options;
+			return opts.angleLines.display || opts.pointLabels.display ? scale.chart.data.labels.length : 0;
+		}
+
+		function getPointLabelFontOptions(scale) {
+			var pointLabelOptions = scale.options.pointLabels;
+			var fontSize = helpers.valueOrDefault(pointLabelOptions.fontSize, globalDefaults.defaultFontSize);
+			var fontStyle = helpers.valueOrDefault(pointLabelOptions.fontStyle, globalDefaults.defaultFontStyle);
+			var fontFamily = helpers.valueOrDefault(pointLabelOptions.fontFamily, globalDefaults.defaultFontFamily);
+			var font = helpers.fontString(fontSize, fontStyle, fontFamily);
+
+			return {
+				size: fontSize,
+				style: fontStyle,
+				family: fontFamily,
+				font: font
+			};
+		}
+
+		function measureLabelSize(ctx, fontSize, label) {
+			if (helpers.isArray(label)) {
+				return {
+					w: helpers.longestText(ctx, ctx.font, label),
+					h: (label.length * fontSize) + ((label.length - 1) * 1.5 * fontSize)
+				};
+			}
+
+			return {
+				w: ctx.measureText(label).width,
+				h: fontSize
+			};
+		}
+
+		function determineLimits(angle, pos, size, min, max) {
+			if (angle === min || angle === max) {
+				return {
+					start: pos - (size / 2),
+					end: pos + (size / 2)
+				};
+			} else if (angle < min || angle > max) {
+				return {
+					start: pos - size - 5,
+					end: pos
+				};
+			}
+
+			return {
+				start: pos,
+				end: pos + size + 5
+			};
+		}
+
+		/**
+		 * Helper function to fit a radial linear scale with point labels
+		 */
+		function fitWithPointLabels(scale) {
+			/*
+			 * Right, this is really confusing and there is a lot of maths going on here
+			 * The gist of the problem is here: https://gist.github.com/nnnick/696cc9c55f4b0beb8fe9
+			 *
+			 * Reaction: https://dl.dropboxusercontent.com/u/34601363/toomuchscience.gif
+			 *
+			 * Solution:
+			 *
+			 * We assume the radius of the polygon is half the size of the canvas at first
+			 * at each index we check if the text overlaps.
+			 *
+			 * Where it does, we store that angle and that index.
+			 *
+			 * After finding the largest index and angle we calculate how much we need to remove
+			 * from the shape radius to move the point inwards by that x.
+			 *
+			 * We average the left and right distances to get the maximum shape radius that can fit in the box
+			 * along with labels.
+			 *
+			 * Once we have that, we can find the centre point for the chart, by taking the x text protrusion
+			 * on each side, removing that from the size, halving it and adding the left x protrusion width.
+			 *
+			 * This will mean we have a shape fitted to the canvas, as large as it can be with the labels
+			 * and position it in the most space efficient manner
+			 *
+			 * https://dl.dropboxusercontent.com/u/34601363/yeahscience.gif
+			 */
+
+			var plFont = getPointLabelFontOptions(scale);
+
+			// Get maximum radius of the polygon. Either half the height (minus the text width) or half the width.
+			// Use this to calculate the offset + change. - Make sure L/R protrusion is at least 0 to stop issues with centre points
+			var largestPossibleRadius = Math.min(scale.height / 2, scale.width / 2);
+			var furthestLimits = {
+				r: scale.width,
+				l: 0,
+				t: scale.height,
+				b: 0
+			};
+			var furthestAngles = {};
+			var i, textSize, pointPosition;
+
+			scale.ctx.font = plFont.font;
+			scale._pointLabelSizes = [];
+
+			var valueCount = getValueCount(scale);
+			for (i = 0; i < valueCount; i++) {
+				pointPosition = scale.getPointPosition(i, largestPossibleRadius);
+				textSize = measureLabelSize(scale.ctx, plFont.size, scale.pointLabels[i] || '');
+				scale._pointLabelSizes[i] = textSize;
+
+				// Add quarter circle to make degree 0 mean top of circle
+				var angleRadians = scale.getIndexAngle(i);
+				var angle = helpers.toDegrees(angleRadians) % 360;
+				var hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);
+				var vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);
+
+				if (hLimits.start < furthestLimits.l) {
+					furthestLimits.l = hLimits.start;
+					furthestAngles.l = angleRadians;
+				}
+
+				if (hLimits.end > furthestLimits.r) {
+					furthestLimits.r = hLimits.end;
+					furthestAngles.r = angleRadians;
+				}
+
+				if (vLimits.start < furthestLimits.t) {
+					furthestLimits.t = vLimits.start;
+					furthestAngles.t = angleRadians;
+				}
+
+				if (vLimits.end > furthestLimits.b) {
+					furthestLimits.b = vLimits.end;
+					furthestAngles.b = angleRadians;
+				}
+			}
+
+			scale.setReductions(largestPossibleRadius, furthestLimits, furthestAngles);
+		}
+
+		/**
+		 * Helper function to fit a radial linear scale with no point labels
+		 */
+		function fit(scale) {
+			var largestPossibleRadius = Math.min(scale.height / 2, scale.width / 2);
+			scale.drawingArea = Math.round(largestPossibleRadius);
+			scale.setCenterPoint(0, 0, 0, 0);
+		}
+
+		function getTextAlignForAngle(angle) {
+			if (angle === 0 || angle === 180) {
+				return 'center';
+			} else if (angle < 180) {
+				return 'left';
+			}
+
+			return 'right';
+		}
+
+		function fillText(ctx, text, position, fontSize) {
+			if (helpers.isArray(text)) {
+				var y = position.y;
+				var spacing = 1.5 * fontSize;
+
+				for (var i = 0; i < text.length; ++i) {
+					ctx.fillText(text[i], position.x, y);
+					y += spacing;
+				}
+			} else {
+				ctx.fillText(text, position.x, position.y);
+			}
+		}
+
+		function adjustPointPositionForLabelHeight(angle, textSize, position) {
+			if (angle === 90 || angle === 270) {
+				position.y -= (textSize.h / 2);
+			} else if (angle > 270 || angle < 90) {
+				position.y -= textSize.h;
+			}
+		}
+
+		function drawPointLabels(scale) {
+			var ctx = scale.ctx;
+			var valueOrDefault = helpers.valueOrDefault;
+			var opts = scale.options;
+			var angleLineOpts = opts.angleLines;
+			var pointLabelOpts = opts.pointLabels;
+
+			ctx.lineWidth = angleLineOpts.lineWidth;
+			ctx.strokeStyle = angleLineOpts.color;
+
+			var outerDistance = scale.getDistanceFromCenterForValue(opts.ticks.reverse ? scale.min : scale.max);
+
+			// Point Label Font
+			var plFont = getPointLabelFontOptions(scale);
+
+			ctx.textBaseline = 'top';
+
+			for (var i = getValueCount(scale) - 1; i >= 0; i--) {
+				if (angleLineOpts.display) {
+					var outerPosition = scale.getPointPosition(i, outerDistance);
+					ctx.beginPath();
+					ctx.moveTo(scale.xCenter, scale.yCenter);
+					ctx.lineTo(outerPosition.x, outerPosition.y);
+					ctx.stroke();
+					ctx.closePath();
+				}
+
+				if (pointLabelOpts.display) {
+					// Extra 3px out for some label spacing
+					var pointLabelPosition = scale.getPointPosition(i, outerDistance + 5);
+
+					// Keep this in loop since we may support array properties here
+					var pointLabelFontColor = valueOrDefault(pointLabelOpts.fontColor, globalDefaults.defaultFontColor);
+					ctx.font = plFont.font;
+					ctx.fillStyle = pointLabelFontColor;
+
+					var angleRadians = scale.getIndexAngle(i);
+					var angle = helpers.toDegrees(angleRadians);
+					ctx.textAlign = getTextAlignForAngle(angle);
+					adjustPointPositionForLabelHeight(angle, scale._pointLabelSizes[i], pointLabelPosition);
+					fillText(ctx, scale.pointLabels[i] || '', pointLabelPosition, plFont.size);
+				}
+			}
+		}
+
+		function drawRadiusLine(scale, gridLineOpts, radius, index) {
+			var ctx = scale.ctx;
+			ctx.strokeStyle = helpers.valueAtIndexOrDefault(gridLineOpts.color, index - 1);
+			ctx.lineWidth = helpers.valueAtIndexOrDefault(gridLineOpts.lineWidth, index - 1);
+
+			if (scale.options.gridLines.circular) {
+				// Draw circular arcs between the points
+				ctx.beginPath();
+				ctx.arc(scale.xCenter, scale.yCenter, radius, 0, Math.PI * 2);
+				ctx.closePath();
+				ctx.stroke();
+			} else {
+				// Draw straight lines connecting each index
+				var valueCount = getValueCount(scale);
+
+				if (valueCount === 0) {
+					return;
+				}
+
+				ctx.beginPath();
+				var pointPosition = scale.getPointPosition(0, radius);
+				ctx.moveTo(pointPosition.x, pointPosition.y);
+
+				for (var i = 1; i < valueCount; i++) {
+					pointPosition = scale.getPointPosition(i, radius);
+					ctx.lineTo(pointPosition.x, pointPosition.y);
+				}
+
+				ctx.closePath();
+				ctx.stroke();
+			}
+		}
+
+		function numberOrZero(param) {
+			return helpers.isNumber(param) ? param : 0;
+		}
+
+		var LinearRadialScale = Chart.LinearScaleBase.extend({
+			setDimensions: function() {
+				var me = this;
+				var opts = me.options;
+				var tickOpts = opts.ticks;
+				// Set the unconstrained dimension before label rotation
+				me.width = me.maxWidth;
+				me.height = me.maxHeight;
+				me.xCenter = Math.round(me.width / 2);
+				me.yCenter = Math.round(me.height / 2);
+
+				var minSize = helpers.min([me.height, me.width]);
+				var tickFontSize = helpers.valueOrDefault(tickOpts.fontSize, globalDefaults.defaultFontSize);
+				me.drawingArea = opts.display ? (minSize / 2) - (tickFontSize / 2 + tickOpts.backdropPaddingY) : (minSize / 2);
+			},
+			determineDataLimits: function() {
+				var me = this;
+				var chart = me.chart;
+				var min = Number.POSITIVE_INFINITY;
+				var max = Number.NEGATIVE_INFINITY;
+
+				helpers.each(chart.data.datasets, function(dataset, datasetIndex) {
+					if (chart.isDatasetVisible(datasetIndex)) {
+						var meta = chart.getDatasetMeta(datasetIndex);
+
+						helpers.each(dataset.data, function(rawValue, index) {
+							var value = +me.getRightValue(rawValue);
+							if (isNaN(value) || meta.data[index].hidden) {
+								return;
+							}
+
+							min = Math.min(value, min);
+							max = Math.max(value, max);
+						});
+					}
+				});
+
+				me.min = (min === Number.POSITIVE_INFINITY ? 0 : min);
+				me.max = (max === Number.NEGATIVE_INFINITY ? 0 : max);
+
+				// Common base implementation to handle ticks.min, ticks.max, ticks.beginAtZero
+				me.handleTickRangeOptions();
+			},
+			getTickLimit: function() {
+				var tickOpts = this.options.ticks;
+				var tickFontSize = helpers.valueOrDefault(tickOpts.fontSize, globalDefaults.defaultFontSize);
+				return Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(this.drawingArea / (1.5 * tickFontSize)));
+			},
+			convertTicksToLabels: function() {
+				var me = this;
+
+				Chart.LinearScaleBase.prototype.convertTicksToLabels.call(me);
+
+				// Point labels
+				me.pointLabels = me.chart.data.labels.map(me.options.pointLabels.callback, me);
+			},
+			getLabelForIndex: function(index, datasetIndex) {
+				return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]);
+			},
+			fit: function() {
+				if (this.options.pointLabels.display) {
+					fitWithPointLabels(this);
+				} else {
+					fit(this);
+				}
+			},
+			/**
+			 * Set radius reductions and determine new radius and center point
+			 * @private
+			 */
+			setReductions: function(largestPossibleRadius, furthestLimits, furthestAngles) {
+				var me = this;
+				var radiusReductionLeft = furthestLimits.l / Math.sin(furthestAngles.l);
+				var radiusReductionRight = Math.max(furthestLimits.r - me.width, 0) / Math.sin(furthestAngles.r);
+				var radiusReductionTop = -furthestLimits.t / Math.cos(furthestAngles.t);
+				var radiusReductionBottom = -Math.max(furthestLimits.b - me.height, 0) / Math.cos(furthestAngles.b);
+
+				radiusReductionLeft = numberOrZero(radiusReductionLeft);
+				radiusReductionRight = numberOrZero(radiusReductionRight);
+				radiusReductionTop = numberOrZero(radiusReductionTop);
+				radiusReductionBottom = numberOrZero(radiusReductionBottom);
+
+				me.drawingArea = Math.min(
+					Math.round(largestPossibleRadius - (radiusReductionLeft + radiusReductionRight) / 2),
+					Math.round(largestPossibleRadius - (radiusReductionTop + radiusReductionBottom) / 2));
+				me.setCenterPoint(radiusReductionLeft, radiusReductionRight, radiusReductionTop, radiusReductionBottom);
+			},
+			setCenterPoint: function(leftMovement, rightMovement, topMovement, bottomMovement) {
+				var me = this;
+				var maxRight = me.width - rightMovement - me.drawingArea;
+				var maxLeft = leftMovement + me.drawingArea;
+				var maxTop = topMovement + me.drawingArea;
+				var maxBottom = me.height - bottomMovement - me.drawingArea;
+
+				me.xCenter = Math.round(((maxLeft + maxRight) / 2) + me.left);
+				me.yCenter = Math.round(((maxTop + maxBottom) / 2) + me.top);
+			},
+
+			getIndexAngle: function(index) {
+				var angleMultiplier = (Math.PI * 2) / getValueCount(this);
+				var startAngle = this.chart.options && this.chart.options.startAngle ?
+					this.chart.options.startAngle :
+					0;
+
+				var startAngleRadians = startAngle * Math.PI * 2 / 360;
+
+				// Start from the top instead of right, so remove a quarter of the circle
+				return index * angleMultiplier + startAngleRadians;
+			},
+			getDistanceFromCenterForValue: function(value) {
+				var me = this;
+
+				if (value === null) {
+					return 0; // null always in center
+				}
+
+				// Take into account half font size + the yPadding of the top value
+				var scalingFactor = me.drawingArea / (me.max - me.min);
+				if (me.options.ticks.reverse) {
+					return (me.max - value) * scalingFactor;
+				}
+				return (value - me.min) * scalingFactor;
+			},
+			getPointPosition: function(index, distanceFromCenter) {
+				var me = this;
+				var thisAngle = me.getIndexAngle(index) - (Math.PI / 2);
+				return {
+					x: Math.round(Math.cos(thisAngle) * distanceFromCenter) + me.xCenter,
+					y: Math.round(Math.sin(thisAngle) * distanceFromCenter) + me.yCenter
+				};
+			},
+			getPointPositionForValue: function(index, value) {
+				return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));
+			},
+
+			getBasePosition: function() {
+				var me = this;
+				var min = me.min;
+				var max = me.max;
+
+				return me.getPointPositionForValue(0,
+					me.beginAtZero ? 0 :
+					min < 0 && max < 0 ? max :
+					min > 0 && max > 0 ? min :
+					0);
+			},
+
+			draw: function() {
+				var me = this;
+				var opts = me.options;
+				var gridLineOpts = opts.gridLines;
+				var tickOpts = opts.ticks;
+				var valueOrDefault = helpers.valueOrDefault;
+
+				if (opts.display) {
+					var ctx = me.ctx;
+					var startAngle = this.getIndexAngle(0);
+
+					// Tick Font
+					var tickFontSize = valueOrDefault(tickOpts.fontSize, globalDefaults.defaultFontSize);
+					var tickFontStyle = valueOrDefault(tickOpts.fontStyle, globalDefaults.defaultFontStyle);
+					var tickFontFamily = valueOrDefault(tickOpts.fontFamily, globalDefaults.defaultFontFamily);
+					var tickLabelFont = helpers.fontString(tickFontSize, tickFontStyle, tickFontFamily);
+
+					helpers.each(me.ticks, function(label, index) {
+						// Don't draw a centre value (if it is minimum)
+						if (index > 0 || tickOpts.reverse) {
+							var yCenterOffset = me.getDistanceFromCenterForValue(me.ticksAsNumbers[index]);
+
+							// Draw circular lines around the scale
+							if (gridLineOpts.display && index !== 0) {
+								drawRadiusLine(me, gridLineOpts, yCenterOffset, index);
+							}
+
+							if (tickOpts.display) {
+								var tickFontColor = valueOrDefault(tickOpts.fontColor, globalDefaults.defaultFontColor);
+								ctx.font = tickLabelFont;
+
+								ctx.save();
+								ctx.translate(me.xCenter, me.yCenter);
+								ctx.rotate(startAngle);
+
+								if (tickOpts.showLabelBackdrop) {
+									var labelWidth = ctx.measureText(label).width;
+									ctx.fillStyle = tickOpts.backdropColor;
+									ctx.fillRect(
+										-labelWidth / 2 - tickOpts.backdropPaddingX,
+										-yCenterOffset - tickFontSize / 2 - tickOpts.backdropPaddingY,
+										labelWidth + tickOpts.backdropPaddingX * 2,
+										tickFontSize + tickOpts.backdropPaddingY * 2
+									);
+								}
+
+								ctx.textAlign = 'center';
+								ctx.textBaseline = 'middle';
+								ctx.fillStyle = tickFontColor;
+								ctx.fillText(label, 0, -yCenterOffset);
+								ctx.restore();
+							}
+						}
+					});
+
+					if (opts.angleLines.display || opts.pointLabels.display) {
+						drawPointLabels(me);
+					}
+				}
+			}
+		});
+		Chart.scaleService.registerScaleType('radialLinear', LinearRadialScale, defaultConfig);
+
+	};
+
+
+/***/ },
+/* 42 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* global window: false */
+	'use strict';
+
+	var moment = __webpack_require__(43);
+	moment = typeof moment === 'function' ? moment : window.moment;
+
+	var defaults = __webpack_require__(6);
+	var helpers = __webpack_require__(7);
+
+	// Integer constants are from the ES6 spec.
+	var MIN_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991;
+	var MAX_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+
+	var INTERVALS = {
+		millisecond: {
+			major: true,
+			size: 1,
+			steps: [1, 2, 5, 10, 20, 50, 100, 250, 500]
+		},
+		second: {
+			major: true,
+			size: 1000,
+			steps: [1, 2, 5, 10, 30]
+		},
+		minute: {
+			major: true,
+			size: 60000,
+			steps: [1, 2, 5, 10, 30]
+		},
+		hour: {
+			major: true,
+			size: 3600000,
+			steps: [1, 2, 3, 6, 12]
+		},
+		day: {
+			major: true,
+			size: 86400000,
+			steps: [1, 2, 5]
+		},
+		week: {
+			major: false,
+			size: 604800000,
+			steps: [1, 2, 3, 4]
+		},
+		month: {
+			major: true,
+			size: 2.628e9,
+			steps: [1, 2, 3]
+		},
+		quarter: {
+			major: false,
+			size: 7.884e9,
+			steps: [1, 2, 3, 4]
+		},
+		year: {
+			major: true,
+			size: 3.154e10
+		}
+	};
+
+	var UNITS = Object.keys(INTERVALS);
+
+	function sorter(a, b) {
+		return a - b;
+	}
+
+	function arrayUnique(items) {
+		var hash = {};
+		var out = [];
+		var i, ilen, item;
+
+		for (i = 0, ilen = items.length; i < ilen; ++i) {
+			item = items[i];
+			if (!hash[item]) {
+				hash[item] = true;
+				out.push(item);
+			}
+		}
+
+		return out;
+	}
+
+	/**
+	 * Returns an array of {time, pos} objects used to interpolate a specific `time` or position
+	 * (`pos`) on the scale, by searching entries before and after the requested value. `pos` is
+	 * a decimal between 0 and 1: 0 being the start of the scale (left or top) and 1 the other
+	 * extremity (left + width or top + height). Note that it would be more optimized to directly
+	 * store pre-computed pixels, but the scale dimensions are not guaranteed at the time we need
+	 * to create the lookup table. The table ALWAYS contains at least two items: min and max.
+	 *
+	 * @param {Number[]} timestamps - timestamps sorted from lowest to highest.
+	 * @param {String} distribution - If 'linear', timestamps will be spread linearly along the min
+	 * and max range, so basically, the table will contains only two items: {min, 0} and {max, 1}.
+	 * If 'series', timestamps will be positioned at the same distance from each other. In this
+	 * case, only timestamps that break the time linearity are registered, meaning that in the
+	 * best case, all timestamps are linear, the table contains only min and max.
+	 */
+	function buildLookupTable(timestamps, min, max, distribution) {
+		if (distribution === 'linear' || !timestamps.length) {
+			return [
+				{time: min, pos: 0},
+				{time: max, pos: 1}
+			];
+		}
+
+		var table = [];
+		var items = [min];
+		var i, ilen, prev, curr, next;
+
+		for (i = 0, ilen = timestamps.length; i < ilen; ++i) {
+			curr = timestamps[i];
+			if (curr > min && curr < max) {
+				items.push(curr);
+			}
+		}
+
+		items.push(max);
+
+		for (i = 0, ilen = items.length; i < ilen; ++i) {
+			next = items[i + 1];
+			prev = items[i - 1];
+			curr = items[i];
+
+			// only add points that breaks the scale linearity
+			if (prev === undefined || next === undefined || Math.round((next + prev) / 2) !== curr) {
+				table.push({time: curr, pos: i / (ilen - 1)});
+			}
+		}
+
+		return table;
+	}
+
+	// @see adapted from http://www.anujgakhar.com/2014/03/01/binary-search-in-javascript/
+	function lookup(table, key, value) {
+		var lo = 0;
+		var hi = table.length - 1;
+		var mid, i0, i1;
+
+		while (lo >= 0 && lo <= hi) {
+			mid = (lo + hi) >> 1;
+			i0 = table[mid - 1] || null;
+			i1 = table[mid];
+
+			if (!i0) {
+				// given value is outside table (before first item)
+				return {lo: null, hi: i1};
+			} else if (i1[key] < value) {
+				lo = mid + 1;
+			} else if (i0[key] > value) {
+				hi = mid - 1;
+			} else {
+				return {lo: i0, hi: i1};
+			}
+		}
+
+		// given value is outside table (after last item)
+		return {lo: i1, hi: null};
+	}
+
+	/**
+	 * Linearly interpolates the given source `value` using the table items `skey` values and
+	 * returns the associated `tkey` value. For example, interpolate(table, 'time', 42, 'pos')
+	 * returns the position for a timestamp equal to 42. If value is out of bounds, values at
+	 * index [0, 1] or [n - 1, n] are used for the interpolation.
+	 */
+	function interpolate(table, skey, sval, tkey) {
+		var range = lookup(table, skey, sval);
+
+		// Note: the lookup table ALWAYS contains at least 2 items (min and max)
+		var prev = !range.lo ? table[0] : !range.hi ? table[table.length - 2] : range.lo;
+		var next = !range.lo ? table[1] : !range.hi ? table[table.length - 1] : range.hi;
+
+		var span = next[skey] - prev[skey];
+		var ratio = span ? (sval - prev[skey]) / span : 0;
+		var offset = (next[tkey] - prev[tkey]) * ratio;
+
+		return prev[tkey] + offset;
+	}
+
+	/**
+	 * Convert the given value to a moment object using the given time options.
+	 * @see http://momentjs.com/docs/#/parsing/
+	 */
+	function momentify(value, options) {
+		var parser = options.parser;
+		var format = options.parser || options.format;
+
+		if (typeof parser === 'function') {
+			return parser(value);
+		}
+
+		if (typeof value === 'string' && typeof format === 'string') {
+			return moment(value, format);
+		}
+
+		if (!(value instanceof moment)) {
+			value = moment(value);
+		}
+
+		if (value.isValid()) {
+			return value;
+		}
+
+		// Labels are in an incompatible moment format and no `parser` has been provided.
+		// The user might still use the deprecated `format` option to convert his inputs.
+		if (typeof format === 'function') {
+			return format(value);
+		}
+
+		return value;
+	}
+
+	function parse(input, scale) {
+		if (helpers.isNullOrUndef(input)) {
+			return null;
+		}
+
+		var options = scale.options.time;
+		var value = momentify(scale.getRightValue(input), options);
+		if (!value.isValid()) {
+			return null;
+		}
+
+		if (options.round) {
+			value.startOf(options.round);
+		}
+
+		return value.valueOf();
+	}
+
+	/**
+	 * Returns the number of unit to skip to be able to display up to `capacity` number of ticks
+	 * in `unit` for the given `min` / `max` range and respecting the interval steps constraints.
+	 */
+	function determineStepSize(min, max, unit, capacity) {
+		var range = max - min;
+		var interval = INTERVALS[unit];
+		var milliseconds = interval.size;
+		var steps = interval.steps;
+		var i, ilen, factor;
+
+		if (!steps) {
+			return Math.ceil(range / ((capacity || 1) * milliseconds));
+		}
+
+		for (i = 0, ilen = steps.length; i < ilen; ++i) {
+			factor = steps[i];
+			if (Math.ceil(range / (milliseconds * factor)) <= capacity) {
+				break;
+			}
+		}
+
+		return factor;
+	}
+
+	function determineUnit(minUnit, min, max, capacity) {
+		var ilen = UNITS.length;
+		var i, interval, factor;
+
+		for (i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) {
+			interval = INTERVALS[UNITS[i]];
+			factor = interval.steps ? interval.steps[interval.steps.length - 1] : MAX_INTEGER;
+
+			if (Math.ceil((max - min) / (factor * interval.size)) <= capacity) {
+				return UNITS[i];
+			}
+		}
+
+		return UNITS[ilen - 1];
+	}
+
+	function determineMajorUnit(unit) {
+		for (var i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) {
+			if (INTERVALS[UNITS[i]].major) {
+				return UNITS[i];
+			}
+		}
+	}
+
+	/**
+	 * Generates a maximum of `capacity` timestamps between min and max, rounded to the
+	 * `minor` unit, aligned on the `major` unit and using the given scale time `options`.
+	 * Important: this method can return ticks outside the min and max range, it's the
+	 * responsibility of the calling code to clamp values if needed.
+	 */
+	function generate(min, max, minor, major, capacity, options) {
+		var timeOpts = options.time;
+		var stepSize = helpers.valueOrDefault(timeOpts.stepSize, timeOpts.unitStepSize);
+		var weekday = minor === 'week' ? timeOpts.isoWeekday : false;
+		var majorTicksEnabled = options.ticks.major.enabled;
+		var interval = INTERVALS[minor];
+		var first = moment(min);
+		var last = moment(max);
+		var ticks = [];
+		var time;
+
+		if (!stepSize) {
+			stepSize = determineStepSize(min, max, minor, capacity);
+		}
+
+		// For 'week' unit, handle the first day of week option
+		if (weekday) {
+			first = first.isoWeekday(weekday);
+			last = last.isoWeekday(weekday);
+		}
+
+		// Align first/last ticks on unit
+		first = first.startOf(weekday ? 'day' : minor);
+		last = last.startOf(weekday ? 'day' : minor);
+
+		// Make sure that the last tick include max
+		if (last < max) {
+			last.add(1, minor);
+		}
+
+		time = moment(first);
+
+		if (majorTicksEnabled && major && !weekday && !timeOpts.round) {
+			// Align the first tick on the previous `minor` unit aligned on the `major` unit:
+			// we first aligned time on the previous `major` unit then add the number of full
+			// stepSize there is between first and the previous major time.
+			time.startOf(major);
+			time.add(~~((first - time) / (interval.size * stepSize)) * stepSize, minor);
+		}
+
+		for (; time < last; time.add(stepSize, minor)) {
+			ticks.push(+time);
+		}
+
+		ticks.push(+time);
+
+		return ticks;
+	}
+
+	/**
+	 * Returns the right and left offsets from edges in the form of {left, right}.
+	 * Offsets are added when the `offset` option is true.
+	 */
+	function computeOffsets(table, ticks, min, max, options) {
+		var left = 0;
+		var right = 0;
+		var upper, lower;
+
+		if (options.offset && ticks.length) {
+			if (!options.time.min) {
+				upper = ticks.length > 1 ? ticks[1] : max;
+				lower = ticks[0];
+				left = (
+					interpolate(table, 'time', upper, 'pos') -
+					interpolate(table, 'time', lower, 'pos')
+				) / 2;
+			}
+			if (!options.time.max) {
+				upper = ticks[ticks.length - 1];
+				lower = ticks.length > 1 ? ticks[ticks.length - 2] : min;
+				right = (
+					interpolate(table, 'time', upper, 'pos') -
+					interpolate(table, 'time', lower, 'pos')
+				) / 2;
+			}
+		}
+
+		return {left: left, right: right};
+	}
+
+	function ticksFromTimestamps(values, majorUnit) {
+		var ticks = [];
+		var i, ilen, value, major;
+
+		for (i = 0, ilen = values.length; i < ilen; ++i) {
+			value = values[i];
+			major = majorUnit ? value === +moment(value).startOf(majorUnit) : false;
+
+			ticks.push({
+				value: value,
+				major: major
+			});
+		}
+
+		return ticks;
+	}
+
+	module.exports = function(Chart) {
+
+		var defaultConfig = {
+			position: 'bottom',
+
+			/**
+			 * Data distribution along the scale:
+			 * - 'linear': data are spread according to their time (distances can vary),
+			 * - 'series': data are spread at the same distance from each other.
+			 * @see https://github.com/chartjs/Chart.js/pull/4507
+			 * @since 2.7.0
+			 */
+			distribution: 'linear',
+
+			/**
+			 * Scale boundary strategy (bypassed by min/max time options)
+			 * - `data`: make sure data are fully visible, ticks outside are removed
+			 * - `ticks`: make sure ticks are fully visible, data outside are truncated
+			 * @see https://github.com/chartjs/Chart.js/pull/4556
+			 * @since 2.7.0
+			 */
+			bounds: 'data',
+
+			time: {
+				parser: false, // false == a pattern string from http://momentjs.com/docs/#/parsing/string-format/ or a custom callback that converts its argument to a moment
+				format: false, // DEPRECATED false == date objects, moment object, callback or a pattern string from http://momentjs.com/docs/#/parsing/string-format/
+				unit: false, // false == automatic or override with week, month, year, etc.
+				round: false, // none, or override with week, month, year, etc.
+				displayFormat: false, // DEPRECATED
+				isoWeekday: false, // override week start day - see http://momentjs.com/docs/#/get-set/iso-weekday/
+				minUnit: 'millisecond',
+
+				// defaults to unit's corresponding unitFormat below or override using pattern string from http://momentjs.com/docs/#/displaying/format/
+				displayFormats: {
+					millisecond: 'h:mm:ss.SSS a', // 11:20:01.123 AM,
+					second: 'h:mm:ss a', // 11:20:01 AM
+					minute: 'h:mm a', // 11:20 AM
+					hour: 'hA', // 5PM
+					day: 'MMM D', // Sep 4
+					week: 'll', // Week 46, or maybe "[W]WW - YYYY" ?
+					month: 'MMM YYYY', // Sept 2015
+					quarter: '[Q]Q - YYYY', // Q3
+					year: 'YYYY' // 2015
+				},
+			},
+			ticks: {
+				autoSkip: false,
+
+				/**
+				 * Ticks generation input values:
+				 * - 'auto': generates "optimal" ticks based on scale size and time options.
+				 * - 'data': generates ticks from data (including labels from data {t|x|y} objects).
+				 * - 'labels': generates ticks from user given `data.labels` values ONLY.
+				 * @see https://github.com/chartjs/Chart.js/pull/4507
+				 * @since 2.7.0
+				 */
+				source: 'auto',
+
+				major: {
+					enabled: false
+				}
+			}
+		};
+
+		var TimeScale = Chart.Scale.extend({
+			initialize: function() {
+				if (!moment) {
+					throw new Error('Chart.js - Moment.js could not be found! You must include it before Chart.js to use the time scale. Download at https://momentjs.com');
+				}
+
+				this.mergeTicksOptions();
+
+				Chart.Scale.prototype.initialize.call(this);
+			},
+
+			update: function() {
+				var me = this;
+				var options = me.options;
+
+				// DEPRECATIONS: output a message only one time per update
+				if (options.time && options.time.format) {
+					console.warn('options.time.format is deprecated and replaced by options.time.parser.');
+				}
+
+				return Chart.Scale.prototype.update.apply(me, arguments);
+			},
+
+			/**
+			 * Allows data to be referenced via 't' attribute
+			 */
+			getRightValue: function(rawValue) {
+				if (rawValue && rawValue.t !== undefined) {
+					rawValue = rawValue.t;
+				}
+				return Chart.Scale.prototype.getRightValue.call(this, rawValue);
+			},
+
+			determineDataLimits: function() {
+				var me = this;
+				var chart = me.chart;
+				var timeOpts = me.options.time;
+				var min = parse(timeOpts.min, me) || MAX_INTEGER;
+				var max = parse(timeOpts.max, me) || MIN_INTEGER;
+				var timestamps = [];
+				var datasets = [];
+				var labels = [];
+				var i, j, ilen, jlen, data, timestamp;
+
+				// Convert labels to timestamps
+				for (i = 0, ilen = chart.data.labels.length; i < ilen; ++i) {
+					labels.push(parse(chart.data.labels[i], me));
+				}
+
+				// Convert data to timestamps
+				for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) {
+					if (chart.isDatasetVisible(i)) {
+						data = chart.data.datasets[i].data;
+
+						// Let's consider that all data have the same format.
+						if (helpers.isObject(data[0])) {
+							datasets[i] = [];
+
+							for (j = 0, jlen = data.length; j < jlen; ++j) {
+								timestamp = parse(data[j], me);
+								timestamps.push(timestamp);
+								datasets[i][j] = timestamp;
+							}
+						} else {
+							timestamps.push.apply(timestamps, labels);
+							datasets[i] = labels.slice(0);
+						}
+					} else {
+						datasets[i] = [];
+					}
+				}
+
+				if (labels.length) {
+					// Sort labels **after** data have been converted
+					labels = arrayUnique(labels).sort(sorter);
+					min = Math.min(min, labels[0]);
+					max = Math.max(max, labels[labels.length - 1]);
+				}
+
+				if (timestamps.length) {
+					timestamps = arrayUnique(timestamps).sort(sorter);
+					min = Math.min(min, timestamps[0]);
+					max = Math.max(max, timestamps[timestamps.length - 1]);
+				}
+
+				// In case there is no valid min/max, let's use today limits
+				min = min === MAX_INTEGER ? +moment().startOf('day') : min;
+				max = max === MIN_INTEGER ? +moment().endOf('day') + 1 : max;
+
+				// Make sure that max is strictly higher than min (required by the lookup table)
+				me.min = Math.min(min, max);
+				me.max = Math.max(min + 1, max);
+
+				// PRIVATE
+				me._horizontal = me.isHorizontal();
+				me._table = [];
+				me._timestamps = {
+					data: timestamps,
+					datasets: datasets,
+					labels: labels
+				};
+			},
+
+			buildTicks: function() {
+				var me = this;
+				var min = me.min;
+				var max = me.max;
+				var options = me.options;
+				var timeOpts = options.time;
+				var formats = timeOpts.displayFormats;
+				var capacity = me.getLabelCapacity(min);
+				var unit = timeOpts.unit || determineUnit(timeOpts.minUnit, min, max, capacity);
+				var majorUnit = determineMajorUnit(unit);
+				var timestamps = [];
+				var ticks = [];
+				var i, ilen, timestamp;
+
+				switch (options.ticks.source) {
+				case 'data':
+					timestamps = me._timestamps.data;
+					break;
+				case 'labels':
+					timestamps = me._timestamps.labels;
+					break;
+				case 'auto':
+				default:
+					timestamps = generate(min, max, unit, majorUnit, capacity, options);
+				}
+
+				if (options.bounds === 'ticks' && timestamps.length) {
+					min = timestamps[0];
+					max = timestamps[timestamps.length - 1];
+				}
+
+				// Enforce limits with user min/max options
+				min = parse(timeOpts.min, me) || min;
+				max = parse(timeOpts.max, me) || max;
+
+				// Remove ticks outside the min/max range
+				for (i = 0, ilen = timestamps.length; i < ilen; ++i) {
+					timestamp = timestamps[i];
+					if (timestamp >= min && timestamp <= max) {
+						ticks.push(timestamp);
+					}
+				}
+
+				me.min = min;
+				me.max = max;
+
+				// PRIVATE
+				me._unit = unit;
+				me._majorUnit = majorUnit;
+				me._minorFormat = formats[unit];
+				me._majorFormat = formats[majorUnit];
+				me._table = buildLookupTable(me._timestamps.data, min, max, options.distribution);
+				me._offsets = computeOffsets(me._table, ticks, min, max, options);
+
+				return ticksFromTimestamps(ticks, majorUnit);
+			},
+
+			getLabelForIndex: function(index, datasetIndex) {
+				var me = this;
+				var data = me.chart.data;
+				var timeOpts = me.options.time;
+				var label = data.labels && index < data.labels.length ? data.labels[index] : '';
+				var value = data.datasets[datasetIndex].data[index];
+
+				if (helpers.isObject(value)) {
+					label = me.getRightValue(value);
+				}
+				if (timeOpts.tooltipFormat) {
+					label = momentify(label, timeOpts).format(timeOpts.tooltipFormat);
+				}
+
+				return label;
+			},
+
+			/**
+			 * Function to format an individual tick mark
+			 * @private
+			 */
+			tickFormatFunction: function(tick, index, ticks) {
+				var me = this;
+				var options = me.options;
+				var time = tick.valueOf();
+				var majorUnit = me._majorUnit;
+				var majorFormat = me._majorFormat;
+				var majorTime = tick.clone().startOf(me._majorUnit).valueOf();
+				var majorTickOpts = options.ticks.major;
+				var major = majorTickOpts.enabled && majorUnit && majorFormat && time === majorTime;
+				var label = tick.format(major ? majorFormat : me._minorFormat);
+				var tickOpts = major ? majorTickOpts : options.ticks.minor;
+				var formatter = helpers.valueOrDefault(tickOpts.callback, tickOpts.userCallback);
+
+				return formatter ? formatter(label, index, ticks) : label;
+			},
+
+			convertTicksToLabels: function(ticks) {
+				var labels = [];
+				var i, ilen;
+
+				for (i = 0, ilen = ticks.length; i < ilen; ++i) {
+					labels.push(this.tickFormatFunction(moment(ticks[i].value), i, ticks));
+				}
+
+				return labels;
+			},
+
+			/**
+			 * @private
+			 */
+			getPixelForOffset: function(time) {
+				var me = this;
+				var size = me._horizontal ? me.width : me.height;
+				var start = me._horizontal ? me.left : me.top;
+				var pos = interpolate(me._table, 'time', time, 'pos');
+
+				return start + size * (me._offsets.left + pos) / (me._offsets.left + 1 + me._offsets.right);
+			},
+
+			getPixelForValue: function(value, index, datasetIndex) {
+				var me = this;
+				var time = null;
+
+				if (index !== undefined && datasetIndex !== undefined) {
+					time = me._timestamps.datasets[datasetIndex][index];
+				}
+
+				if (time === null) {
+					time = parse(value, me);
+				}
+
+				if (time !== null) {
+					return me.getPixelForOffset(time);
+				}
+			},
+
+			getPixelForTick: function(index) {
+				var ticks = this.getTicks();
+				return index >= 0 && index < ticks.length ?
+					this.getPixelForOffset(ticks[index].value) :
+					null;
+			},
+
+			getValueForPixel: function(pixel) {
+				var me = this;
+				var size = me._horizontal ? me.width : me.height;
+				var start = me._horizontal ? me.left : me.top;
+				var pos = (size ? (pixel - start) / size : 0) * (me._offsets.left + 1 + me._offsets.left) - me._offsets.right;
+				var time = interpolate(me._table, 'pos', pos, 'time');
+
+				return moment(time);
+			},
+
+			/**
+			 * Crude approximation of what the label width might be
+			 * @private
+			 */
+			getLabelWidth: function(label) {
+				var me = this;
+				var ticksOpts = me.options.ticks;
+				var tickLabelWidth = me.ctx.measureText(label).width;
+				var angle = helpers.toRadians(ticksOpts.maxRotation);
+				var cosRotation = Math.cos(angle);
+				var sinRotation = Math.sin(angle);
+				var tickFontSize = helpers.valueOrDefault(ticksOpts.fontSize, defaults.global.defaultFontSize);
+
+				return (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation);
+			},
+
+			/**
+			 * @private
+			 */
+			getLabelCapacity: function(exampleTime) {
+				var me = this;
+
+				me._minorFormat = me.options.time.displayFormats.millisecond;	// Pick the longest format for guestimation
+
+				var exampleLabel = me.tickFormatFunction(moment(exampleTime), 0, []);
+				var tickLabelWidth = me.getLabelWidth(exampleLabel);
+				var innerWidth = me.isHorizontal() ? me.width : me.height;
+
+				return Math.floor(innerWidth / tickLabelWidth);
+			}
+		});
+
+		Chart.scaleService.registerScaleType('time', TimeScale, defaultConfig);
+	};
+
+
+/***/ },
+/* 43 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(module) {//! moment.js
+	//! version : 2.18.1
+	//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
+	//! license : MIT
+	//! momentjs.com
+
+	;(function (global, factory) {
+	     true ? module.exports = factory() :
+	    typeof define === 'function' && define.amd ? define(factory) :
+	    global.moment = factory()
+	}(this, (function () { 'use strict';
+
+	var hookCallback;
+
+	function hooks () {
+	    return hookCallback.apply(null, arguments);
+	}
+
+	// This is done to register the method called with moment()
+	// without creating circular dependencies.
+	function setHookCallback (callback) {
+	    hookCallback = callback;
+	}
+
+	function isArray(input) {
+	    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
+	}
+
+	function isObject(input) {
+	    // IE8 will treat undefined and null as object if it wasn't for
+	    // input != null
+	    return input != null && Object.prototype.toString.call(input) === '[object Object]';
+	}
+
+	function isObjectEmpty(obj) {
+	    var k;
+	    for (k in obj) {
+	        // even if its not own property I'd still call it non-empty
+	        return false;
+	    }
+	    return true;
+	}
+
+	function isUndefined(input) {
+	    return input === void 0;
+	}
+
+	function isNumber(input) {
+	    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
+	}
+
+	function isDate(input) {
+	    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+	}
+
+	function map(arr, fn) {
+	    var res = [], i;
+	    for (i = 0; i < arr.length; ++i) {
+	        res.push(fn(arr[i], i));
+	    }
+	    return res;
+	}
+
+	function hasOwnProp(a, b) {
+	    return Object.prototype.hasOwnProperty.call(a, b);
+	}
+
+	function extend(a, b) {
+	    for (var i in b) {
+	        if (hasOwnProp(b, i)) {
+	            a[i] = b[i];
+	        }
+	    }
+
+	    if (hasOwnProp(b, 'toString')) {
+	        a.toString = b.toString;
+	    }
+
+	    if (hasOwnProp(b, 'valueOf')) {
+	        a.valueOf = b.valueOf;
+	    }
+
+	    return a;
+	}
+
+	function createUTC (input, format, locale, strict) {
+	    return createLocalOrUTC(input, format, locale, strict, true).utc();
+	}
+
+	function defaultParsingFlags() {
+	    // We need to deep clone this object.
+	    return {
+	        empty           : false,
+	        unusedTokens    : [],
+	        unusedInput     : [],
+	        overflow        : -2,
+	        charsLeftOver   : 0,
+	        nullInput       : false,
+	        invalidMonth    : null,
+	        invalidFormat   : false,
+	        userInvalidated : false,
+	        iso             : false,
+	        parsedDateParts : [],
+	        meridiem        : null,
+	        rfc2822         : false,
+	        weekdayMismatch : false
+	    };
+	}
+
+	function getParsingFlags(m) {
+	    if (m._pf == null) {
+	        m._pf = defaultParsingFlags();
+	    }
+	    return m._pf;
+	}
+
+	var some;
+	if (Array.prototype.some) {
+	    some = Array.prototype.some;
+	} else {
+	    some = function (fun) {
+	        var t = Object(this);
+	        var len = t.length >>> 0;
+
+	        for (var i = 0; i < len; i++) {
+	            if (i in t && fun.call(this, t[i], i, t)) {
+	                return true;
+	            }
+	        }
+
+	        return false;
+	    };
+	}
+
+	var some$1 = some;
+
+	function isValid(m) {
+	    if (m._isValid == null) {
+	        var flags = getParsingFlags(m);
+	        var parsedParts = some$1.call(flags.parsedDateParts, function (i) {
+	            return i != null;
+	        });
+	        var isNowValid = !isNaN(m._d.getTime()) &&
+	            flags.overflow < 0 &&
+	            !flags.empty &&
+	            !flags.invalidMonth &&
+	            !flags.invalidWeekday &&
+	            !flags.nullInput &&
+	            !flags.invalidFormat &&
+	            !flags.userInvalidated &&
+	            (!flags.meridiem || (flags.meridiem && parsedParts));
+
+	        if (m._strict) {
+	            isNowValid = isNowValid &&
+	                flags.charsLeftOver === 0 &&
+	                flags.unusedTokens.length === 0 &&
+	                flags.bigHour === undefined;
+	        }
+
+	        if (Object.isFrozen == null || !Object.isFrozen(m)) {
+	            m._isValid = isNowValid;
+	        }
+	        else {
+	            return isNowValid;
+	        }
+	    }
+	    return m._isValid;
+	}
+
+	function createInvalid (flags) {
+	    var m = createUTC(NaN);
+	    if (flags != null) {
+	        extend(getParsingFlags(m), flags);
+	    }
+	    else {
+	        getParsingFlags(m).userInvalidated = true;
+	    }
+
+	    return m;
+	}
+
+	// Plugins that add properties should also add the key here (null value),
+	// so we can properly clone ourselves.
+	var momentProperties = hooks.momentProperties = [];
+
+	function copyConfig(to, from) {
+	    var i, prop, val;
+
+	    if (!isUndefined(from._isAMomentObject)) {
+	        to._isAMomentObject = from._isAMomentObject;
+	    }
+	    if (!isUndefined(from._i)) {
+	        to._i = from._i;
+	    }
+	    if (!isUndefined(from._f)) {
+	        to._f = from._f;
+	    }
+	    if (!isUndefined(from._l)) {
+	        to._l = from._l;
+	    }
+	    if (!isUndefined(from._strict)) {
+	        to._strict = from._strict;
+	    }
+	    if (!isUndefined(from._tzm)) {
+	        to._tzm = from._tzm;
+	    }
+	    if (!isUndefined(from._isUTC)) {
+	        to._isUTC = from._isUTC;
+	    }
+	    if (!isUndefined(from._offset)) {
+	        to._offset = from._offset;
+	    }
+	    if (!isUndefined(from._pf)) {
+	        to._pf = getParsingFlags(from);
+	    }
+	    if (!isUndefined(from._locale)) {
+	        to._locale = from._locale;
+	    }
+
+	    if (momentProperties.length > 0) {
+	        for (i = 0; i < momentProperties.length; i++) {
+	            prop = momentProperties[i];
+	            val = from[prop];
+	            if (!isUndefined(val)) {
+	                to[prop] = val;
+	            }
+	        }
+	    }
+
+	    return to;
+	}
+
+	var updateInProgress = false;
+
+	// Moment prototype object
+	function Moment(config) {
+	    copyConfig(this, config);
+	    this._d = new Date(config._d != null ? config._d.getTime() : NaN);
+	    if (!this.isValid()) {
+	        this._d = new Date(NaN);
+	    }
+	    // Prevent infinite loop in case updateOffset creates new moment
+	    // objects.
+	    if (updateInProgress === false) {
+	        updateInProgress = true;
+	        hooks.updateOffset(this);
+	        updateInProgress = false;
+	    }
+	}
+
+	function isMoment (obj) {
+	    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
+	}
+
+	function absFloor (number) {
+	    if (number < 0) {
+	        // -0 -> 0
+	        return Math.ceil(number) || 0;
+	    } else {
+	        return Math.floor(number);
+	    }
+	}
+
+	function toInt(argumentForCoercion) {
+	    var coercedNumber = +argumentForCoercion,
+	        value = 0;
+
+	    if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+	        value = absFloor(coercedNumber);
+	    }
+
+	    return value;
+	}
+
+	// compare two arrays, return the number of differences
+	function compareArrays(array1, array2, dontConvert) {
+	    var len = Math.min(array1.length, array2.length),
+	        lengthDiff = Math.abs(array1.length - array2.length),
+	        diffs = 0,
+	        i;
+	    for (i = 0; i < len; i++) {
+	        if ((dontConvert && array1[i] !== array2[i]) ||
+	            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
+	            diffs++;
+	        }
+	    }
+	    return diffs + lengthDiff;
+	}
+
+	function warn(msg) {
+	    if (hooks.suppressDeprecationWarnings === false &&
+	            (typeof console !==  'undefined') && console.warn) {
+	        console.warn('Deprecation warning: ' + msg);
+	    }
+	}
+
+	function deprecate(msg, fn) {
+	    var firstTime = true;
+
+	    return extend(function () {
+	        if (hooks.deprecationHandler != null) {
+	            hooks.deprecationHandler(null, msg);
+	        }
+	        if (firstTime) {
+	            var args = [];
+	            var arg;
+	            for (var i = 0; i < arguments.length; i++) {
+	                arg = '';
+	                if (typeof arguments[i] === 'object') {
+	                    arg += '\n[' + i + '] ';
+	                    for (var key in arguments[0]) {
+	                        arg += key + ': ' + arguments[0][key] + ', ';
+	                    }
+	                    arg = arg.slice(0, -2); // Remove trailing comma and space
+	                } else {
+	                    arg = arguments[i];
+	                }
+	                args.push(arg);
+	            }
+	            warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
+	            firstTime = false;
+	        }
+	        return fn.apply(this, arguments);
+	    }, fn);
+	}
+
+	var deprecations = {};
+
+	function deprecateSimple(name, msg) {
+	    if (hooks.deprecationHandler != null) {
+	        hooks.deprecationHandler(name, msg);
+	    }
+	    if (!deprecations[name]) {
+	        warn(msg);
+	        deprecations[name] = true;
+	    }
+	}
+
+	hooks.suppressDeprecationWarnings = false;
+	hooks.deprecationHandler = null;
+
+	function isFunction(input) {
+	    return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
+	}
+
+	function set (config) {
+	    var prop, i;
+	    for (i in config) {
+	        prop = config[i];
+	        if (isFunction(prop)) {
+	            this[i] = prop;
+	        } else {
+	            this['_' + i] = prop;
+	        }
+	    }
+	    this._config = config;
+	    // Lenient ordinal parsing accepts just a number in addition to
+	    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
+	    // TODO: Remove "ordinalParse" fallback in next major release.
+	    this._dayOfMonthOrdinalParseLenient = new RegExp(
+	        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
+	            '|' + (/\d{1,2}/).source);
+	}
+
+	function mergeConfigs(parentConfig, childConfig) {
+	    var res = extend({}, parentConfig), prop;
+	    for (prop in childConfig) {
+	        if (hasOwnProp(childConfig, prop)) {
+	            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
+	                res[prop] = {};
+	                extend(res[prop], parentConfig[prop]);
+	                extend(res[prop], childConfig[prop]);
+	            } else if (childConfig[prop] != null) {
+	                res[prop] = childConfig[prop];
+	            } else {
+	                delete res[prop];
+	            }
+	        }
+	    }
+	    for (prop in parentConfig) {
+	        if (hasOwnProp(parentConfig, prop) &&
+	                !hasOwnProp(childConfig, prop) &&
+	                isObject(parentConfig[prop])) {
+	            // make sure changes to properties don't modify parent config
+	            res[prop] = extend({}, res[prop]);
+	        }
+	    }
+	    return res;
+	}
+
+	function Locale(config) {
+	    if (config != null) {
+	        this.set(config);
+	    }
+	}
+
+	var keys;
+
+	if (Object.keys) {
+	    keys = Object.keys;
+	} else {
+	    keys = function (obj) {
+	        var i, res = [];
+	        for (i in obj) {
+	            if (hasOwnProp(obj, i)) {
+	                res.push(i);
+	            }
+	        }
+	        return res;
+	    };
+	}
+
+	var keys$1 = keys;
+
+	var defaultCalendar = {
+	    sameDay : '[Today at] LT',
+	    nextDay : '[Tomorrow at] LT',
+	    nextWeek : 'dddd [at] LT',
+	    lastDay : '[Yesterday at] LT',
+	    lastWeek : '[Last] dddd [at] LT',
+	    sameElse : 'L'
+	};
+
+	function calendar (key, mom, now) {
+	    var output = this._calendar[key] || this._calendar['sameElse'];
+	    return isFunction(output) ? output.call(mom, now) : output;
+	}
+
+	var defaultLongDateFormat = {
+	    LTS  : 'h:mm:ss A',
+	    LT   : 'h:mm A',
+	    L    : 'MM/DD/YYYY',
+	    LL   : 'MMMM D, YYYY',
+	    LLL  : 'MMMM D, YYYY h:mm A',
+	    LLLL : 'dddd, MMMM D, YYYY h:mm A'
+	};
+
+	function longDateFormat (key) {
+	    var format = this._longDateFormat[key],
+	        formatUpper = this._longDateFormat[key.toUpperCase()];
+
+	    if (format || !formatUpper) {
+	        return format;
+	    }
+
+	    this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
+	        return val.slice(1);
+	    });
+
+	    return this._longDateFormat[key];
+	}
+
+	var defaultInvalidDate = 'Invalid date';
+
+	function invalidDate () {
+	    return this._invalidDate;
+	}
+
+	var defaultOrdinal = '%d';
+	var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+
+	function ordinal (number) {
+	    return this._ordinal.replace('%d', number);
+	}
+
+	var defaultRelativeTime = {
+	    future : 'in %s',
+	    past   : '%s ago',
+	    s  : 'a few seconds',
+	    ss : '%d seconds',
+	    m  : 'a minute',
+	    mm : '%d minutes',
+	    h  : 'an hour',
+	    hh : '%d hours',
+	    d  : 'a day',
+	    dd : '%d days',
+	    M  : 'a month',
+	    MM : '%d months',
+	    y  : 'a year',
+	    yy : '%d years'
+	};
+
+	function relativeTime (number, withoutSuffix, string, isFuture) {
+	    var output = this._relativeTime[string];
+	    return (isFunction(output)) ?
+	        output(number, withoutSuffix, string, isFuture) :
+	        output.replace(/%d/i, number);
+	}
+
+	function pastFuture (diff, output) {
+	    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+	    return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+	}
+
+	var aliases = {};
+
+	function addUnitAlias (unit, shorthand) {
+	    var lowerCase = unit.toLowerCase();
+	    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+	}
+
+	function normalizeUnits(units) {
+	    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
+	}
+
+	function normalizeObjectUnits(inputObject) {
+	    var normalizedInput = {},
+	        normalizedProp,
+	        prop;
+
+	    for (prop in inputObject) {
+	        if (hasOwnProp(inputObject, prop)) {
+	            normalizedProp = normalizeUnits(prop);
+	            if (normalizedProp) {
+	                normalizedInput[normalizedProp] = inputObject[prop];
+	            }
+	        }
+	    }
+
+	    return normalizedInput;
+	}
+
+	var priorities = {};
+
+	function addUnitPriority(unit, priority) {
+	    priorities[unit] = priority;
+	}
+
+	function getPrioritizedUnits(unitsObj) {
+	    var units = [];
+	    for (var u in unitsObj) {
+	        units.push({unit: u, priority: priorities[u]});
+	    }
+	    units.sort(function (a, b) {
+	        return a.priority - b.priority;
+	    });
+	    return units;
+	}
+
+	function makeGetSet (unit, keepTime) {
+	    return function (value) {
+	        if (value != null) {
+	            set$1(this, unit, value);
+	            hooks.updateOffset(this, keepTime);
+	            return this;
+	        } else {
+	            return get(this, unit);
+	        }
+	    };
+	}
+
+	function get (mom, unit) {
+	    return mom.isValid() ?
+	        mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
+	}
+
+	function set$1 (mom, unit, value) {
+	    if (mom.isValid()) {
+	        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
+	    }
+	}
+
+	// MOMENTS
+
+	function stringGet (units) {
+	    units = normalizeUnits(units);
+	    if (isFunction(this[units])) {
+	        return this[units]();
+	    }
+	    return this;
+	}
+
+
+	function stringSet (units, value) {
+	    if (typeof units === 'object') {
+	        units = normalizeObjectUnits(units);
+	        var prioritized = getPrioritizedUnits(units);
+	        for (var i = 0; i < prioritized.length; i++) {
+	            this[prioritized[i].unit](units[prioritized[i].unit]);
+	        }
+	    } else {
+	        units = normalizeUnits(units);
+	        if (isFunction(this[units])) {
+	            return this[units](value);
+	        }
+	    }
+	    return this;
+	}
+
+	function zeroFill(number, targetLength, forceSign) {
+	    var absNumber = '' + Math.abs(number),
+	        zerosToFill = targetLength - absNumber.length,
+	        sign = number >= 0;
+	    return (sign ? (forceSign ? '+' : '') : '-') +
+	        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
+	}
+
+	var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
+
+	var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
+
+	var formatFunctions = {};
+
+	var formatTokenFunctions = {};
+
+	// token:    'M'
+	// padded:   ['MM', 2]
+	// ordinal:  'Mo'
+	// callback: function () { this.month() + 1 }
+	function addFormatToken (token, padded, ordinal, callback) {
+	    var func = callback;
+	    if (typeof callback === 'string') {
+	        func = function () {
+	            return this[callback]();
+	        };
+	    }
+	    if (token) {
+	        formatTokenFunctions[token] = func;
+	    }
+	    if (padded) {
+	        formatTokenFunctions[padded[0]] = function () {
+	            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
+	        };
+	    }
+	    if (ordinal) {
+	        formatTokenFunctions[ordinal] = function () {
+	            return this.localeData().ordinal(func.apply(this, arguments), token);
+	        };
+	    }
+	}
+
+	function removeFormattingTokens(input) {
+	    if (input.match(/\[[\s\S]/)) {
+	        return input.replace(/^\[|\]$/g, '');
+	    }
+	    return input.replace(/\\/g, '');
+	}
+
+	function makeFormatFunction(format) {
+	    var array = format.match(formattingTokens), i, length;
+
+	    for (i = 0, length = array.length; i < length; i++) {
+	        if (formatTokenFunctions[array[i]]) {
+	            array[i] = formatTokenFunctions[array[i]];
+	        } else {
+	            array[i] = removeFormattingTokens(array[i]);
+	        }
+	    }
+
+	    return function (mom) {
+	        var output = '', i;
+	        for (i = 0; i < length; i++) {
+	            output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
+	        }
+	        return output;
+	    };
+	}
+
+	// format date using native date object
+	function formatMoment(m, format) {
+	    if (!m.isValid()) {
+	        return m.localeData().invalidDate();
+	    }
+
+	    format = expandFormat(format, m.localeData());
+	    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
+
+	    return formatFunctions[format](m);
+	}
+
+	function expandFormat(format, locale) {
+	    var i = 5;
+
+	    function replaceLongDateFormatTokens(input) {
+	        return locale.longDateFormat(input) || input;
+	    }
+
+	    localFormattingTokens.lastIndex = 0;
+	    while (i >= 0 && localFormattingTokens.test(format)) {
+	        format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
+	        localFormattingTokens.lastIndex = 0;
+	        i -= 1;
+	    }
+
+	    return format;
+	}
+
+	var match1         = /\d/;            //       0 - 9
+	var match2         = /\d\d/;          //      00 - 99
+	var match3         = /\d{3}/;         //     000 - 999
+	var match4         = /\d{4}/;         //    0000 - 9999
+	var match6         = /[+-]?\d{6}/;    // -999999 - 999999
+	var match1to2      = /\d\d?/;         //       0 - 99
+	var match3to4      = /\d\d\d\d?/;     //     999 - 9999
+	var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
+	var match1to3      = /\d{1,3}/;       //       0 - 999
+	var match1to4      = /\d{1,4}/;       //       0 - 9999
+	var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
+
+	var matchUnsigned  = /\d+/;           //       0 - inf
+	var matchSigned    = /[+-]?\d+/;      //    -inf - inf
+
+	var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
+	var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
+
+	var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
+
+	// any word (or two) characters or numbers including two/three word month in arabic.
+	// includes scottish gaelic two word and hyphenated months
+	var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
+
+
+	var regexes = {};
+
+	function addRegexToken (token, regex, strictRegex) {
+	    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
+	        return (isStrict && strictRegex) ? strictRegex : regex;
+	    };
+	}
+
+	function getParseRegexForToken (token, config) {
+	    if (!hasOwnProp(regexes, token)) {
+	        return new RegExp(unescapeFormat(token));
+	    }
+
+	    return regexes[token](config._strict, config._locale);
+	}
+
+	// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+	function unescapeFormat(s) {
+	    return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
+	        return p1 || p2 || p3 || p4;
+	    }));
+	}
+
+	function regexEscape(s) {
+	    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+	}
+
+	var tokens = {};
+
+	function addParseToken (token, callback) {
+	    var i, func = callback;
+	    if (typeof token === 'string') {
+	        token = [token];
+	    }
+	    if (isNumber(callback)) {
+	        func = function (input, array) {
+	            array[callback] = toInt(input);
+	        };
+	    }
+	    for (i = 0; i < token.length; i++) {
+	        tokens[token[i]] = func;
+	    }
+	}
+
+	function addWeekParseToken (token, callback) {
+	    addParseToken(token, function (input, array, config, token) {
+	        config._w = config._w || {};
+	        callback(input, config._w, config, token);
+	    });
+	}
+
+	function addTimeToArrayFromToken(token, input, config) {
+	    if (input != null && hasOwnProp(tokens, token)) {
+	        tokens[token](input, config._a, config, token);
+	    }
+	}
+
+	var YEAR = 0;
+	var MONTH = 1;
+	var DATE = 2;
+	var HOUR = 3;
+	var MINUTE = 4;
+	var SECOND = 5;
+	var MILLISECOND = 6;
+	var WEEK = 7;
+	var WEEKDAY = 8;
+
+	var indexOf;
+
+	if (Array.prototype.indexOf) {
+	    indexOf = Array.prototype.indexOf;
+	} else {
+	    indexOf = function (o) {
+	        // I know
+	        var i;
+	        for (i = 0; i < this.length; ++i) {
+	            if (this[i] === o) {
+	                return i;
+	            }
+	        }
+	        return -1;
+	    };
+	}
+
+	var indexOf$1 = indexOf;
+
+	function daysInMonth(year, month) {
+	    return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+	}
+
+	// FORMATTING
+
+	addFormatToken('M', ['MM', 2], 'Mo', function () {
+	    return this.month() + 1;
+	});
+
+	addFormatToken('MMM', 0, 0, function (format) {
+	    return this.localeData().monthsShort(this, format);
+	});
+
+	addFormatToken('MMMM', 0, 0, function (format) {
+	    return this.localeData().months(this, format);
+	});
+
+	// ALIASES
+
+	addUnitAlias('month', 'M');
+
+	// PRIORITY
+
+	addUnitPriority('month', 8);
+
+	// PARSING
+
+	addRegexToken('M',    match1to2);
+	addRegexToken('MM',   match1to2, match2);
+	addRegexToken('MMM',  function (isStrict, locale) {
+	    return locale.monthsShortRegex(isStrict);
+	});
+	addRegexToken('MMMM', function (isStrict, locale) {
+	    return locale.monthsRegex(isStrict);
+	});
+
+	addParseToken(['M', 'MM'], function (input, array) {
+	    array[MONTH] = toInt(input) - 1;
+	});
+
+	addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
+	    var month = config._locale.monthsParse(input, token, config._strict);
+	    // if we didn't find a month name, mark the date as invalid.
+	    if (month != null) {
+	        array[MONTH] = month;
+	    } else {
+	        getParsingFlags(config).invalidMonth = input;
+	    }
+	});
+
+	// LOCALES
+
+	var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
+	var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
+	function localeMonths (m, format) {
+	    if (!m) {
+	        return isArray(this._months) ? this._months :
+	            this._months['standalone'];
+	    }
+	    return isArray(this._months) ? this._months[m.month()] :
+	        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
+	}
+
+	var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
+	function localeMonthsShort (m, format) {
+	    if (!m) {
+	        return isArray(this._monthsShort) ? this._monthsShort :
+	            this._monthsShort['standalone'];
+	    }
+	    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
+	        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
+	}
+
+	function handleStrictParse(monthName, format, strict) {
+	    var i, ii, mom, llc = monthName.toLocaleLowerCase();
+	    if (!this._monthsParse) {
+	        // this is not used
+	        this._monthsParse = [];
+	        this._longMonthsParse = [];
+	        this._shortMonthsParse = [];
+	        for (i = 0; i < 12; ++i) {
+	            mom = createUTC([2000, i]);
+	            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
+	            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
+	        }
+	    }
+
+	    if (strict) {
+	        if (format === 'MMM') {
+	            ii = indexOf$1.call(this._shortMonthsParse, llc);
+	            return ii !== -1 ? ii : null;
+	        } else {
+	            ii = indexOf$1.call(this._longMonthsParse, llc);
+	            return ii !== -1 ? ii : null;
+	        }
+	    } else {
+	        if (format === 'MMM') {
+	            ii = indexOf$1.call(this._shortMonthsParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._longMonthsParse, llc);
+	            return ii !== -1 ? ii : null;
+	        } else {
+	            ii = indexOf$1.call(this._longMonthsParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._shortMonthsParse, llc);
+	            return ii !== -1 ? ii : null;
+	        }
+	    }
+	}
+
+	function localeMonthsParse (monthName, format, strict) {
+	    var i, mom, regex;
+
+	    if (this._monthsParseExact) {
+	        return handleStrictParse.call(this, monthName, format, strict);
+	    }
+
+	    if (!this._monthsParse) {
+	        this._monthsParse = [];
+	        this._longMonthsParse = [];
+	        this._shortMonthsParse = [];
+	    }
+
+	    // TODO: add sorting
+	    // Sorting makes sure if one month (or abbr) is a prefix of another
+	    // see sorting in computeMonthsParse
+	    for (i = 0; i < 12; i++) {
+	        // make the regex if we don't have it already
+	        mom = createUTC([2000, i]);
+	        if (strict && !this._longMonthsParse[i]) {
+	            this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
+	            this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
+	        }
+	        if (!strict && !this._monthsParse[i]) {
+	            regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+	            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+	        }
+	        // test the regex
+	        if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
+	            return i;
+	        } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
+	            return i;
+	        } else if (!strict && this._monthsParse[i].test(monthName)) {
+	            return i;
+	        }
+	    }
+	}
+
+	// MOMENTS
+
+	function setMonth (mom, value) {
+	    var dayOfMonth;
+
+	    if (!mom.isValid()) {
+	        // No op
+	        return mom;
+	    }
+
+	    if (typeof value === 'string') {
+	        if (/^\d+$/.test(value)) {
+	            value = toInt(value);
+	        } else {
+	            value = mom.localeData().monthsParse(value);
+	            // TODO: Another silent failure?
+	            if (!isNumber(value)) {
+	                return mom;
+	            }
+	        }
+	    }
+
+	    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
+	    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+	    return mom;
+	}
+
+	function getSetMonth (value) {
+	    if (value != null) {
+	        setMonth(this, value);
+	        hooks.updateOffset(this, true);
+	        return this;
+	    } else {
+	        return get(this, 'Month');
+	    }
+	}
+
+	function getDaysInMonth () {
+	    return daysInMonth(this.year(), this.month());
+	}
+
+	var defaultMonthsShortRegex = matchWord;
+	function monthsShortRegex (isStrict) {
+	    if (this._monthsParseExact) {
+	        if (!hasOwnProp(this, '_monthsRegex')) {
+	            computeMonthsParse.call(this);
+	        }
+	        if (isStrict) {
+	            return this._monthsShortStrictRegex;
+	        } else {
+	            return this._monthsShortRegex;
+	        }
+	    } else {
+	        if (!hasOwnProp(this, '_monthsShortRegex')) {
+	            this._monthsShortRegex = defaultMonthsShortRegex;
+	        }
+	        return this._monthsShortStrictRegex && isStrict ?
+	            this._monthsShortStrictRegex : this._monthsShortRegex;
+	    }
+	}
+
+	var defaultMonthsRegex = matchWord;
+	function monthsRegex (isStrict) {
+	    if (this._monthsParseExact) {
+	        if (!hasOwnProp(this, '_monthsRegex')) {
+	            computeMonthsParse.call(this);
+	        }
+	        if (isStrict) {
+	            return this._monthsStrictRegex;
+	        } else {
+	            return this._monthsRegex;
+	        }
+	    } else {
+	        if (!hasOwnProp(this, '_monthsRegex')) {
+	            this._monthsRegex = defaultMonthsRegex;
+	        }
+	        return this._monthsStrictRegex && isStrict ?
+	            this._monthsStrictRegex : this._monthsRegex;
+	    }
+	}
+
+	function computeMonthsParse () {
+	    function cmpLenRev(a, b) {
+	        return b.length - a.length;
+	    }
+
+	    var shortPieces = [], longPieces = [], mixedPieces = [],
+	        i, mom;
+	    for (i = 0; i < 12; i++) {
+	        // make the regex if we don't have it already
+	        mom = createUTC([2000, i]);
+	        shortPieces.push(this.monthsShort(mom, ''));
+	        longPieces.push(this.months(mom, ''));
+	        mixedPieces.push(this.months(mom, ''));
+	        mixedPieces.push(this.monthsShort(mom, ''));
+	    }
+	    // Sorting makes sure if one month (or abbr) is a prefix of another it
+	    // will match the longer piece.
+	    shortPieces.sort(cmpLenRev);
+	    longPieces.sort(cmpLenRev);
+	    mixedPieces.sort(cmpLenRev);
+	    for (i = 0; i < 12; i++) {
+	        shortPieces[i] = regexEscape(shortPieces[i]);
+	        longPieces[i] = regexEscape(longPieces[i]);
+	    }
+	    for (i = 0; i < 24; i++) {
+	        mixedPieces[i] = regexEscape(mixedPieces[i]);
+	    }
+
+	    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+	    this._monthsShortRegex = this._monthsRegex;
+	    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
+	    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
+	}
+
+	// FORMATTING
+
+	addFormatToken('Y', 0, 0, function () {
+	    var y = this.year();
+	    return y <= 9999 ? '' + y : '+' + y;
+	});
+
+	addFormatToken(0, ['YY', 2], 0, function () {
+	    return this.year() % 100;
+	});
+
+	addFormatToken(0, ['YYYY',   4],       0, 'year');
+	addFormatToken(0, ['YYYYY',  5],       0, 'year');
+	addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+
+	// ALIASES
+
+	addUnitAlias('year', 'y');
+
+	// PRIORITIES
+
+	addUnitPriority('year', 1);
+
+	// PARSING
+
+	addRegexToken('Y',      matchSigned);
+	addRegexToken('YY',     match1to2, match2);
+	addRegexToken('YYYY',   match1to4, match4);
+	addRegexToken('YYYYY',  match1to6, match6);
+	addRegexToken('YYYYYY', match1to6, match6);
+
+	addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+	addParseToken('YYYY', function (input, array) {
+	    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+	});
+	addParseToken('YY', function (input, array) {
+	    array[YEAR] = hooks.parseTwoDigitYear(input);
+	});
+	addParseToken('Y', function (input, array) {
+	    array[YEAR] = parseInt(input, 10);
+	});
+
+	// HELPERS
+
+	function daysInYear(year) {
+	    return isLeapYear(year) ? 366 : 365;
+	}
+
+	function isLeapYear(year) {
+	    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+	}
+
+	// HOOKS
+
+	hooks.parseTwoDigitYear = function (input) {
+	    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+	};
+
+	// MOMENTS
+
+	var getSetYear = makeGetSet('FullYear', true);
+
+	function getIsLeapYear () {
+	    return isLeapYear(this.year());
+	}
+
+	function createDate (y, m, d, h, M, s, ms) {
+	    // can't just apply() to create a date:
+	    // https://stackoverflow.com/q/181348
+	    var date = new Date(y, m, d, h, M, s, ms);
+
+	    // the date constructor remaps years 0-99 to 1900-1999
+	    if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
+	        date.setFullYear(y);
+	    }
+	    return date;
+	}
+
+	function createUTCDate (y) {
+	    var date = new Date(Date.UTC.apply(null, arguments));
+
+	    // the Date.UTC function remaps years 0-99 to 1900-1999
+	    if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
+	        date.setUTCFullYear(y);
+	    }
+	    return date;
+	}
+
+	// start-of-first-week - start-of-year
+	function firstWeekOffset(year, dow, doy) {
+	    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+	        fwd = 7 + dow - doy,
+	        // first-week day local weekday -- which local weekday is fwd
+	        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+
+	    return -fwdlw + fwd - 1;
+	}
+
+	// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+	function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+	    var localWeekday = (7 + weekday - dow) % 7,
+	        weekOffset = firstWeekOffset(year, dow, doy),
+	        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
+	        resYear, resDayOfYear;
+
+	    if (dayOfYear <= 0) {
+	        resYear = year - 1;
+	        resDayOfYear = daysInYear(resYear) + dayOfYear;
+	    } else if (dayOfYear > daysInYear(year)) {
+	        resYear = year + 1;
+	        resDayOfYear = dayOfYear - daysInYear(year);
+	    } else {
+	        resYear = year;
+	        resDayOfYear = dayOfYear;
+	    }
+
+	    return {
+	        year: resYear,
+	        dayOfYear: resDayOfYear
+	    };
+	}
+
+	function weekOfYear(mom, dow, doy) {
+	    var weekOffset = firstWeekOffset(mom.year(), dow, doy),
+	        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
+	        resWeek, resYear;
+
+	    if (week < 1) {
+	        resYear = mom.year() - 1;
+	        resWeek = week + weeksInYear(resYear, dow, doy);
+	    } else if (week > weeksInYear(mom.year(), dow, doy)) {
+	        resWeek = week - weeksInYear(mom.year(), dow, doy);
+	        resYear = mom.year() + 1;
+	    } else {
+	        resYear = mom.year();
+	        resWeek = week;
+	    }
+
+	    return {
+	        week: resWeek,
+	        year: resYear
+	    };
+	}
+
+	function weeksInYear(year, dow, doy) {
+	    var weekOffset = firstWeekOffset(year, dow, doy),
+	        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+	    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+	}
+
+	// FORMATTING
+
+	addFormatToken('w', ['ww', 2], 'wo', 'week');
+	addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
+
+	// ALIASES
+
+	addUnitAlias('week', 'w');
+	addUnitAlias('isoWeek', 'W');
+
+	// PRIORITIES
+
+	addUnitPriority('week', 5);
+	addUnitPriority('isoWeek', 5);
+
+	// PARSING
+
+	addRegexToken('w',  match1to2);
+	addRegexToken('ww', match1to2, match2);
+	addRegexToken('W',  match1to2);
+	addRegexToken('WW', match1to2, match2);
+
+	addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
+	    week[token.substr(0, 1)] = toInt(input);
+	});
+
+	// HELPERS
+
+	// LOCALES
+
+	function localeWeek (mom) {
+	    return weekOfYear(mom, this._week.dow, this._week.doy).week;
+	}
+
+	var defaultLocaleWeek = {
+	    dow : 0, // Sunday is the first day of the week.
+	    doy : 6  // The week that contains Jan 1st is the first week of the year.
+	};
+
+	function localeFirstDayOfWeek () {
+	    return this._week.dow;
+	}
+
+	function localeFirstDayOfYear () {
+	    return this._week.doy;
+	}
+
+	// MOMENTS
+
+	function getSetWeek (input) {
+	    var week = this.localeData().week(this);
+	    return input == null ? week : this.add((input - week) * 7, 'd');
+	}
+
+	function getSetISOWeek (input) {
+	    var week = weekOfYear(this, 1, 4).week;
+	    return input == null ? week : this.add((input - week) * 7, 'd');
+	}
+
+	// FORMATTING
+
+	addFormatToken('d', 0, 'do', 'day');
+
+	addFormatToken('dd', 0, 0, function (format) {
+	    return this.localeData().weekdaysMin(this, format);
+	});
+
+	addFormatToken('ddd', 0, 0, function (format) {
+	    return this.localeData().weekdaysShort(this, format);
+	});
+
+	addFormatToken('dddd', 0, 0, function (format) {
+	    return this.localeData().weekdays(this, format);
+	});
+
+	addFormatToken('e', 0, 0, 'weekday');
+	addFormatToken('E', 0, 0, 'isoWeekday');
+
+	// ALIASES
+
+	addUnitAlias('day', 'd');
+	addUnitAlias('weekday', 'e');
+	addUnitAlias('isoWeekday', 'E');
+
+	// PRIORITY
+	addUnitPriority('day', 11);
+	addUnitPriority('weekday', 11);
+	addUnitPriority('isoWeekday', 11);
+
+	// PARSING
+
+	addRegexToken('d',    match1to2);
+	addRegexToken('e',    match1to2);
+	addRegexToken('E',    match1to2);
+	addRegexToken('dd',   function (isStrict, locale) {
+	    return locale.weekdaysMinRegex(isStrict);
+	});
+	addRegexToken('ddd',   function (isStrict, locale) {
+	    return locale.weekdaysShortRegex(isStrict);
+	});
+	addRegexToken('dddd',   function (isStrict, locale) {
+	    return locale.weekdaysRegex(isStrict);
+	});
+
+	addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
+	    var weekday = config._locale.weekdaysParse(input, token, config._strict);
+	    // if we didn't get a weekday name, mark the date as invalid
+	    if (weekday != null) {
+	        week.d = weekday;
+	    } else {
+	        getParsingFlags(config).invalidWeekday = input;
+	    }
+	});
+
+	addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
+	    week[token] = toInt(input);
+	});
+
+	// HELPERS
+
+	function parseWeekday(input, locale) {
+	    if (typeof input !== 'string') {
+	        return input;
+	    }
+
+	    if (!isNaN(input)) {
+	        return parseInt(input, 10);
+	    }
+
+	    input = locale.weekdaysParse(input);
+	    if (typeof input === 'number') {
+	        return input;
+	    }
+
+	    return null;
+	}
+
+	function parseIsoWeekday(input, locale) {
+	    if (typeof input === 'string') {
+	        return locale.weekdaysParse(input) % 7 || 7;
+	    }
+	    return isNaN(input) ? null : input;
+	}
+
+	// LOCALES
+
+	var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
+	function localeWeekdays (m, format) {
+	    if (!m) {
+	        return isArray(this._weekdays) ? this._weekdays :
+	            this._weekdays['standalone'];
+	    }
+	    return isArray(this._weekdays) ? this._weekdays[m.day()] :
+	        this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
+	}
+
+	var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
+	function localeWeekdaysShort (m) {
+	    return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
+	}
+
+	var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
+	function localeWeekdaysMin (m) {
+	    return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
+	}
+
+	function handleStrictParse$1(weekdayName, format, strict) {
+	    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
+	    if (!this._weekdaysParse) {
+	        this._weekdaysParse = [];
+	        this._shortWeekdaysParse = [];
+	        this._minWeekdaysParse = [];
+
+	        for (i = 0; i < 7; ++i) {
+	            mom = createUTC([2000, 1]).day(i);
+	            this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
+	            this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
+	            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
+	        }
+	    }
+
+	    if (strict) {
+	        if (format === 'dddd') {
+	            ii = indexOf$1.call(this._weekdaysParse, llc);
+	            return ii !== -1 ? ii : null;
+	        } else if (format === 'ddd') {
+	            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+	            return ii !== -1 ? ii : null;
+	        } else {
+	            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+	            return ii !== -1 ? ii : null;
+	        }
+	    } else {
+	        if (format === 'dddd') {
+	            ii = indexOf$1.call(this._weekdaysParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+	            return ii !== -1 ? ii : null;
+	        } else if (format === 'ddd') {
+	            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._weekdaysParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+	            return ii !== -1 ? ii : null;
+	        } else {
+	            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._weekdaysParse, llc);
+	            if (ii !== -1) {
+	                return ii;
+	            }
+	            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+	            return ii !== -1 ? ii : null;
+	        }
+	    }
+	}
+
+	function localeWeekdaysParse (weekdayName, format, strict) {
+	    var i, mom, regex;
+
+	    if (this._weekdaysParseExact) {
+	        return handleStrictParse$1.call(this, weekdayName, format, strict);
+	    }
+
+	    if (!this._weekdaysParse) {
+	        this._weekdaysParse = [];
+	        this._minWeekdaysParse = [];
+	        this._shortWeekdaysParse = [];
+	        this._fullWeekdaysParse = [];
+	    }
+
+	    for (i = 0; i < 7; i++) {
+	        // make the regex if we don't have it already
+
+	        mom = createUTC([2000, 1]).day(i);
+	        if (strict && !this._fullWeekdaysParse[i]) {
+	            this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
+	            this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
+	            this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
+	        }
+	        if (!this._weekdaysParse[i]) {
+	            regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
+	            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
+	        }
+	        // test the regex
+	        if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
+	            return i;
+	        } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
+	            return i;
+	        } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
+	            return i;
+	        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
+	            return i;
+	        }
+	    }
+	}
+
+	// MOMENTS
+
+	function getSetDayOfWeek (input) {
+	    if (!this.isValid()) {
+	        return input != null ? this : NaN;
+	    }
+	    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+	    if (input != null) {
+	        input = parseWeekday(input, this.localeData());
+	        return this.add(input - day, 'd');
+	    } else {
+	        return day;
+	    }
+	}
+
+	function getSetLocaleDayOfWeek (input) {
+	    if (!this.isValid()) {
+	        return input != null ? this : NaN;
+	    }
+	    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+	    return input == null ? weekday : this.add(input - weekday, 'd');
+	}
+
+	function getSetISODayOfWeek (input) {
+	    if (!this.isValid()) {
+	        return input != null ? this : NaN;
+	    }
+
+	    // behaves the same as moment#day except
+	    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
+	    // as a setter, sunday should belong to the previous week.
+
+	    if (input != null) {
+	        var weekday = parseIsoWeekday(input, this.localeData());
+	        return this.day(this.day() % 7 ? weekday : weekday - 7);
+	    } else {
+	        return this.day() || 7;
+	    }
+	}
+
+	var defaultWeekdaysRegex = matchWord;
+	function weekdaysRegex (isStrict) {
+	    if (this._weekdaysParseExact) {
+	        if (!hasOwnProp(this, '_weekdaysRegex')) {
+	            computeWeekdaysParse.call(this);
+	        }
+	        if (isStrict) {
+	            return this._weekdaysStrictRegex;
+	        } else {
+	            return this._weekdaysRegex;
+	        }
+	    } else {
+	        if (!hasOwnProp(this, '_weekdaysRegex')) {
+	            this._weekdaysRegex = defaultWeekdaysRegex;
+	        }
+	        return this._weekdaysStrictRegex && isStrict ?
+	            this._weekdaysStrictRegex : this._weekdaysRegex;
+	    }
+	}
+
+	var defaultWeekdaysShortRegex = matchWord;
+	function weekdaysShortRegex (isStrict) {
+	    if (this._weekdaysParseExact) {
+	        if (!hasOwnProp(this, '_weekdaysRegex')) {
+	            computeWeekdaysParse.call(this);
+	        }
+	        if (isStrict) {
+	            return this._weekdaysShortStrictRegex;
+	        } else {
+	            return this._weekdaysShortRegex;
+	        }
+	    } else {
+	        if (!hasOwnProp(this, '_weekdaysShortRegex')) {
+	            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
+	        }
+	        return this._weekdaysShortStrictRegex && isStrict ?
+	            this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
+	    }
+	}
+
+	var defaultWeekdaysMinRegex = matchWord;
+	function weekdaysMinRegex (isStrict) {
+	    if (this._weekdaysParseExact) {
+	        if (!hasOwnProp(this, '_weekdaysRegex')) {
+	            computeWeekdaysParse.call(this);
+	        }
+	        if (isStrict) {
+	            return this._weekdaysMinStrictRegex;
+	        } else {
+	            return this._weekdaysMinRegex;
+	        }
+	    } else {
+	        if (!hasOwnProp(this, '_weekdaysMinRegex')) {
+	            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
+	        }
+	        return this._weekdaysMinStrictRegex && isStrict ?
+	            this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
+	    }
+	}
+
+
+	function computeWeekdaysParse () {
+	    function cmpLenRev(a, b) {
+	        return b.length - a.length;
+	    }
+
+	    var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
+	        i, mom, minp, shortp, longp;
+	    for (i = 0; i < 7; i++) {
+	        // make the regex if we don't have it already
+	        mom = createUTC([2000, 1]).day(i);
+	        minp = this.weekdaysMin(mom, '');
+	        shortp = this.weekdaysShort(mom, '');
+	        longp = this.weekdays(mom, '');
+	        minPieces.push(minp);
+	        shortPieces.push(shortp);
+	        longPieces.push(longp);
+	        mixedPieces.push(minp);
+	        mixedPieces.push(shortp);
+	        mixedPieces.push(longp);
+	    }
+	    // Sorting makes sure if one weekday (or abbr) is a prefix of another it
+	    // will match the longer piece.
+	    minPieces.sort(cmpLenRev);
+	    shortPieces.sort(cmpLenRev);
+	    longPieces.sort(cmpLenRev);
+	    mixedPieces.sort(cmpLenRev);
+	    for (i = 0; i < 7; i++) {
+	        shortPieces[i] = regexEscape(shortPieces[i]);
+	        longPieces[i] = regexEscape(longPieces[i]);
+	        mixedPieces[i] = regexEscape(mixedPieces[i]);
+	    }
+
+	    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+	    this._weekdaysShortRegex = this._weekdaysRegex;
+	    this._weekdaysMinRegex = this._weekdaysRegex;
+
+	    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
+	    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
+	    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
+	}
+
+	// FORMATTING
+
+	function hFormat() {
+	    return this.hours() % 12 || 12;
+	}
+
+	function kFormat() {
+	    return this.hours() || 24;
+	}
+
+	addFormatToken('H', ['HH', 2], 0, 'hour');
+	addFormatToken('h', ['hh', 2], 0, hFormat);
+	addFormatToken('k', ['kk', 2], 0, kFormat);
+
+	addFormatToken('hmm', 0, 0, function () {
+	    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
+	});
+
+	addFormatToken('hmmss', 0, 0, function () {
+	    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
+	        zeroFill(this.seconds(), 2);
+	});
+
+	addFormatToken('Hmm', 0, 0, function () {
+	    return '' + this.hours() + zeroFill(this.minutes(), 2);
+	});
+
+	addFormatToken('Hmmss', 0, 0, function () {
+	    return '' + this.hours() + zeroFill(this.minutes(), 2) +
+	        zeroFill(this.seconds(), 2);
+	});
+
+	function meridiem (token, lowercase) {
+	    addFormatToken(token, 0, 0, function () {
+	        return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
+	    });
+	}
+
+	meridiem('a', true);
+	meridiem('A', false);
+
+	// ALIASES
+
+	addUnitAlias('hour', 'h');
+
+	// PRIORITY
+	addUnitPriority('hour', 13);
+
+	// PARSING
+
+	function matchMeridiem (isStrict, locale) {
+	    return locale._meridiemParse;
+	}
+
+	addRegexToken('a',  matchMeridiem);
+	addRegexToken('A',  matchMeridiem);
+	addRegexToken('H',  match1to2);
+	addRegexToken('h',  match1to2);
+	addRegexToken('k',  match1to2);
+	addRegexToken('HH', match1to2, match2);
+	addRegexToken('hh', match1to2, match2);
+	addRegexToken('kk', match1to2, match2);
+
+	addRegexToken('hmm', match3to4);
+	addRegexToken('hmmss', match5to6);
+	addRegexToken('Hmm', match3to4);
+	addRegexToken('Hmmss', match5to6);
+
+	addParseToken(['H', 'HH'], HOUR);
+	addParseToken(['k', 'kk'], function (input, array, config) {
+	    var kInput = toInt(input);
+	    array[HOUR] = kInput === 24 ? 0 : kInput;
+	});
+	addParseToken(['a', 'A'], function (input, array, config) {
+	    config._isPm = config._locale.isPM(input);
+	    config._meridiem = input;
+	});
+	addParseToken(['h', 'hh'], function (input, array, config) {
+	    array[HOUR] = toInt(input);
+	    getParsingFlags(config).bigHour = true;
+	});
+	addParseToken('hmm', function (input, array, config) {
+	    var pos = input.length - 2;
+	    array[HOUR] = toInt(input.substr(0, pos));
+	    array[MINUTE] = toInt(input.substr(pos));
+	    getParsingFlags(config).bigHour = true;
+	});
+	addParseToken('hmmss', function (input, array, config) {
+	    var pos1 = input.length - 4;
+	    var pos2 = input.length - 2;
+	    array[HOUR] = toInt(input.substr(0, pos1));
+	    array[MINUTE] = toInt(input.substr(pos1, 2));
+	    array[SECOND] = toInt(input.substr(pos2));
+	    getParsingFlags(config).bigHour = true;
+	});
+	addParseToken('Hmm', function (input, array, config) {
+	    var pos = input.length - 2;
+	    array[HOUR] = toInt(input.substr(0, pos));
+	    array[MINUTE] = toInt(input.substr(pos));
+	});
+	addParseToken('Hmmss', function (input, array, config) {
+	    var pos1 = input.length - 4;
+	    var pos2 = input.length - 2;
+	    array[HOUR] = toInt(input.substr(0, pos1));
+	    array[MINUTE] = toInt(input.substr(pos1, 2));
+	    array[SECOND] = toInt(input.substr(pos2));
+	});
+
+	// LOCALES
+
+	function localeIsPM (input) {
+	    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
+	    // Using charAt should be more compatible.
+	    return ((input + '').toLowerCase().charAt(0) === 'p');
+	}
+
+	var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
+	function localeMeridiem (hours, minutes, isLower) {
+	    if (hours > 11) {
+	        return isLower ? 'pm' : 'PM';
+	    } else {
+	        return isLower ? 'am' : 'AM';
+	    }
+	}
+
+
+	// MOMENTS
+
+	// Setting the hour should keep the time, because the user explicitly
+	// specified which hour he wants. So trying to maintain the same hour (in
+	// a new timezone) makes sense. Adding/subtracting hours does not follow
+	// this rule.
+	var getSetHour = makeGetSet('Hours', true);
+
+	// months
+	// week
+	// weekdays
+	// meridiem
+	var baseConfig = {
+	    calendar: defaultCalendar,
+	    longDateFormat: defaultLongDateFormat,
+	    invalidDate: defaultInvalidDate,
+	    ordinal: defaultOrdinal,
+	    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+	    relativeTime: defaultRelativeTime,
+
+	    months: defaultLocaleMonths,
+	    monthsShort: defaultLocaleMonthsShort,
+
+	    week: defaultLocaleWeek,
+
+	    weekdays: defaultLocaleWeekdays,
+	    weekdaysMin: defaultLocaleWeekdaysMin,
+	    weekdaysShort: defaultLocaleWeekdaysShort,
+
+	    meridiemParse: defaultLocaleMeridiemParse
+	};
+
+	// internal storage for locale config files
+	var locales = {};
+	var localeFamilies = {};
+	var globalLocale;
+
+	function normalizeLocale(key) {
+	    return key ? key.toLowerCase().replace('_', '-') : key;
+	}
+
+	// pick the locale from the array
+	// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+	// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
+	function chooseLocale(names) {
+	    var i = 0, j, next, locale, split;
+
+	    while (i < names.length) {
+	        split = normalizeLocale(names[i]).split('-');
+	        j = split.length;
+	        next = normalizeLocale(names[i + 1]);
+	        next = next ? next.split('-') : null;
+	        while (j > 0) {
+	            locale = loadLocale(split.slice(0, j).join('-'));
+	            if (locale) {
+	                return locale;
+	            }
+	            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
+	                //the next array item is better than a shallower substring of this one
+	                break;
+	            }
+	            j--;
+	        }
+	        i++;
+	    }
+	    return null;
+	}
+
+	function loadLocale(name) {
+	    var oldLocale = null;
+	    // TODO: Find a better way to register and load all the locales in Node
+	    if (!locales[name] && (typeof module !== 'undefined') &&
+	            module && module.exports) {
+	        try {
+	            oldLocale = globalLocale._abbr;
+	            __webpack_require__(45)("./" + name);
+	            // because defineLocale currently also sets the global locale, we
+	            // want to undo that for lazy loaded locales
+	            getSetGlobalLocale(oldLocale);
+	        } catch (e) { }
+	    }
+	    return locales[name];
+	}
+
+	// This function will load locale and then set the global locale.  If
+	// no arguments are passed in, it will simply return the current global
+	// locale key.
+	function getSetGlobalLocale (key, values) {
+	    var data;
+	    if (key) {
+	        if (isUndefined(values)) {
+	            data = getLocale(key);
+	        }
+	        else {
+	            data = defineLocale(key, values);
+	        }
+
+	        if (data) {
+	            // moment.duration._locale = moment._locale = data;
+	            globalLocale = data;
+	        }
+	    }
+
+	    return globalLocale._abbr;
+	}
+
+	function defineLocale (name, config) {
+	    if (config !== null) {
+	        var parentConfig = baseConfig;
+	        config.abbr = name;
+	        if (locales[name] != null) {
+	            deprecateSimple('defineLocaleOverride',
+	                    'use moment.updateLocale(localeName, config) to change ' +
+	                    'an existing locale. moment.defineLocale(localeName, ' +
+	                    'config) should only be used for creating a new locale ' +
+	                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
+	            parentConfig = locales[name]._config;
+	        } else if (config.parentLocale != null) {
+	            if (locales[config.parentLocale] != null) {
+	                parentConfig = locales[config.parentLocale]._config;
+	            } else {
+	                if (!localeFamilies[config.parentLocale]) {
+	                    localeFamilies[config.parentLocale] = [];
+	                }
+	                localeFamilies[config.parentLocale].push({
+	                    name: name,
+	                    config: config
+	                });
+	                return null;
+	            }
+	        }
+	        locales[name] = new Locale(mergeConfigs(parentConfig, config));
+
+	        if (localeFamilies[name]) {
+	            localeFamilies[name].forEach(function (x) {
+	                defineLocale(x.name, x.config);
+	            });
+	        }
+
+	        // backwards compat for now: also set the locale
+	        // make sure we set the locale AFTER all child locales have been
+	        // created, so we won't end up with the child locale set.
+	        getSetGlobalLocale(name);
+
+
+	        return locales[name];
+	    } else {
+	        // useful for testing
+	        delete locales[name];
+	        return null;
+	    }
+	}
+
+	function updateLocale(name, config) {
+	    if (config != null) {
+	        var locale, parentConfig = baseConfig;
+	        // MERGE
+	        if (locales[name] != null) {
+	            parentConfig = locales[name]._config;
+	        }
+	        config = mergeConfigs(parentConfig, config);
+	        locale = new Locale(config);
+	        locale.parentLocale = locales[name];
+	        locales[name] = locale;
+
+	        // backwards compat for now: also set the locale
+	        getSetGlobalLocale(name);
+	    } else {
+	        // pass null for config to unupdate, useful for tests
+	        if (locales[name] != null) {
+	            if (locales[name].parentLocale != null) {
+	                locales[name] = locales[name].parentLocale;
+	            } else if (locales[name] != null) {
+	                delete locales[name];
+	            }
+	        }
+	    }
+	    return locales[name];
+	}
+
+	// returns locale data
+	function getLocale (key) {
+	    var locale;
+
+	    if (key && key._locale && key._locale._abbr) {
+	        key = key._locale._abbr;
+	    }
+
+	    if (!key) {
+	        return globalLocale;
+	    }
+
+	    if (!isArray(key)) {
+	        //short-circuit everything else
+	        locale = loadLocale(key);
+	        if (locale) {
+	            return locale;
+	        }
+	        key = [key];
+	    }
+
+	    return chooseLocale(key);
+	}
+
+	function listLocales() {
+	    return keys$1(locales);
+	}
+
+	function checkOverflow (m) {
+	    var overflow;
+	    var a = m._a;
+
+	    if (a && getParsingFlags(m).overflow === -2) {
+	        overflow =
+	            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
+	            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
+	            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
+	            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
+	            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
+	            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
+	            -1;
+
+	        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+	            overflow = DATE;
+	        }
+	        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
+	            overflow = WEEK;
+	        }
+	        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
+	            overflow = WEEKDAY;
+	        }
+
+	        getParsingFlags(m).overflow = overflow;
+	    }
+
+	    return m;
+	}
+
+	// iso 8601 regex
+	// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
+	var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+	var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+
+	var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
+
+	var isoDates = [
+	    ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
+	    ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
+	    ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
+	    ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
+	    ['YYYY-DDD', /\d{4}-\d{3}/],
+	    ['YYYY-MM', /\d{4}-\d\d/, false],
+	    ['YYYYYYMMDD', /[+-]\d{10}/],
+	    ['YYYYMMDD', /\d{8}/],
+	    // YYYYMM is NOT allowed by the standard
+	    ['GGGG[W]WWE', /\d{4}W\d{3}/],
+	    ['GGGG[W]WW', /\d{4}W\d{2}/, false],
+	    ['YYYYDDD', /\d{7}/]
+	];
+
+	// iso time formats and regexes
+	var isoTimes = [
+	    ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
+	    ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
+	    ['HH:mm:ss', /\d\d:\d\d:\d\d/],
+	    ['HH:mm', /\d\d:\d\d/],
+	    ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
+	    ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
+	    ['HHmmss', /\d\d\d\d\d\d/],
+	    ['HHmm', /\d\d\d\d/],
+	    ['HH', /\d\d/]
+	];
+
+	var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
+
+	// date from iso format
+	function configFromISO(config) {
+	    var i, l,
+	        string = config._i,
+	        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
+	        allowTime, dateFormat, timeFormat, tzFormat;
+
+	    if (match) {
+	        getParsingFlags(config).iso = true;
+
+	        for (i = 0, l = isoDates.length; i < l; i++) {
+	            if (isoDates[i][1].exec(match[1])) {
+	                dateFormat = isoDates[i][0];
+	                allowTime = isoDates[i][2] !== false;
+	                break;
+	            }
+	        }
+	        if (dateFormat == null) {
+	            config._isValid = false;
+	            return;
+	        }
+	        if (match[3]) {
+	            for (i = 0, l = isoTimes.length; i < l; i++) {
+	                if (isoTimes[i][1].exec(match[3])) {
+	                    // match[2] should be 'T' or space
+	                    timeFormat = (match[2] || ' ') + isoTimes[i][0];
+	                    break;
+	                }
+	            }
+	            if (timeFormat == null) {
+	                config._isValid = false;
+	                return;
+	            }
+	        }
+	        if (!allowTime && timeFormat != null) {
+	            config._isValid = false;
+	            return;
+	        }
+	        if (match[4]) {
+	            if (tzRegex.exec(match[4])) {
+	                tzFormat = 'Z';
+	            } else {
+	                config._isValid = false;
+	                return;
+	            }
+	        }
+	        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
+	        configFromStringAndFormat(config);
+	    } else {
+	        config._isValid = false;
+	    }
+	}
+
+	// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
+	var basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d?\d\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?:\d\d)?\d\d\s)(\d\d:\d\d)(\:\d\d)?(\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\d{4}))$/;
+
+	// date and time from ref 2822 format
+	function configFromRFC2822(config) {
+	    var string, match, dayFormat,
+	        dateFormat, timeFormat, tzFormat;
+	    var timezones = {
+	        ' GMT': ' +0000',
+	        ' EDT': ' -0400',
+	        ' EST': ' -0500',
+	        ' CDT': ' -0500',
+	        ' CST': ' -0600',
+	        ' MDT': ' -0600',
+	        ' MST': ' -0700',
+	        ' PDT': ' -0700',
+	        ' PST': ' -0800'
+	    };
+	    var military = 'YXWVUTSRQPONZABCDEFGHIKLM';
+	    var timezone, timezoneIndex;
+
+	    string = config._i
+	        .replace(/\([^\)]*\)|[\n\t]/g, ' ') // Remove comments and folding whitespace
+	        .replace(/(\s\s+)/g, ' ') // Replace multiple-spaces with a single space
+	        .replace(/^\s|\s$/g, ''); // Remove leading and trailing spaces
+	    match = basicRfcRegex.exec(string);
+
+	    if (match) {
+	        dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';
+	        dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');
+	        timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');
+
+	        // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
+	        if (match[1]) { // day of week given
+	            var momentDate = new Date(match[2]);
+	            var momentDay = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][momentDate.getDay()];
+
+	            if (match[1].substr(0,3) !== momentDay) {
+	                getParsingFlags(config).weekdayMismatch = true;
+	                config._isValid = false;
+	                return;
+	            }
+	        }
+
+	        switch (match[5].length) {
+	            case 2: // military
+	                if (timezoneIndex === 0) {
+	                    timezone = ' +0000';
+	                } else {
+	                    timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;
+	                    timezone = ((timezoneIndex < 0) ? ' -' : ' +') +
+	                        (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';
+	                }
+	                break;
+	            case 4: // Zone
+	                timezone = timezones[match[5]];
+	                break;
+	            default: // UT or +/-9999
+	                timezone = timezones[' GMT'];
+	        }
+	        match[5] = timezone;
+	        config._i = match.splice(1).join('');
+	        tzFormat = ' ZZ';
+	        config._f = dayFormat + dateFormat + timeFormat + tzFormat;
+	        configFromStringAndFormat(config);
+	        getParsingFlags(config).rfc2822 = true;
+	    } else {
+	        config._isValid = false;
+	    }
+	}
+
+	// date from iso format or fallback
+	function configFromString(config) {
+	    var matched = aspNetJsonRegex.exec(config._i);
+
+	    if (matched !== null) {
+	        config._d = new Date(+matched[1]);
+	        return;
+	    }
+
+	    configFromISO(config);
+	    if (config._isValid === false) {
+	        delete config._isValid;
+	    } else {
+	        return;
+	    }
+
+	    configFromRFC2822(config);
+	    if (config._isValid === false) {
+	        delete config._isValid;
+	    } else {
+	        return;
+	    }
+
+	    // Final attempt, use Input Fallback
+	    hooks.createFromInputFallback(config);
+	}
+
+	hooks.createFromInputFallback = deprecate(
+	    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
+	    'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
+	    'discouraged and will be removed in an upcoming major release. Please refer to ' +
+	    'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
+	    function (config) {
+	        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+	    }
+	);
+
+	// Pick the first defined of two or three arguments.
+	function defaults(a, b, c) {
+	    if (a != null) {
+	        return a;
+	    }
+	    if (b != null) {
+	        return b;
+	    }
+	    return c;
+	}
+
+	function currentDateArray(config) {
+	    // hooks is actually the exported moment object
+	    var nowValue = new Date(hooks.now());
+	    if (config._useUTC) {
+	        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
+	    }
+	    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
+	}
+
+	// convert an array to a date.
+	// the array should mirror the parameters below
+	// note: all values past the year are optional and will default to the lowest possible value.
+	// [year, month, day , hour, minute, second, millisecond]
+	function configFromArray (config) {
+	    var i, date, input = [], currentDate, yearToUse;
+
+	    if (config._d) {
+	        return;
+	    }
+
+	    currentDate = currentDateArray(config);
+
+	    //compute day of the year from weeks and weekdays
+	    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+	        dayOfYearFromWeekInfo(config);
+	    }
+
+	    //if the day of the year is set, figure out what it is
+	    if (config._dayOfYear != null) {
+	        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+
+	        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
+	            getParsingFlags(config)._overflowDayOfYear = true;
+	        }
+
+	        date = createUTCDate(yearToUse, 0, config._dayOfYear);
+	        config._a[MONTH] = date.getUTCMonth();
+	        config._a[DATE] = date.getUTCDate();
+	    }
+
+	    // Default to current date.
+	    // * if no year, month, day of month are given, default to today
+	    // * if day of month is given, default month and year
+	    // * if month is given, default only year
+	    // * if year is given, don't default anything
+	    for (i = 0; i < 3 && config._a[i] == null; ++i) {
+	        config._a[i] = input[i] = currentDate[i];
+	    }
+
+	    // Zero out whatever was not defaulted, including time
+	    for (; i < 7; i++) {
+	        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+	    }
+
+	    // Check for 24:00:00.000
+	    if (config._a[HOUR] === 24 &&
+	            config._a[MINUTE] === 0 &&
+	            config._a[SECOND] === 0 &&
+	            config._a[MILLISECOND] === 0) {
+	        config._nextDay = true;
+	        config._a[HOUR] = 0;
+	    }
+
+	    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
+	    // Apply timezone offset from input. The actual utcOffset can be changed
+	    // with parseZone.
+	    if (config._tzm != null) {
+	        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+	    }
+
+	    if (config._nextDay) {
+	        config._a[HOUR] = 24;
+	    }
+	}
+
+	function dayOfYearFromWeekInfo(config) {
+	    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
+
+	    w = config._w;
+	    if (w.GG != null || w.W != null || w.E != null) {
+	        dow = 1;
+	        doy = 4;
+
+	        // TODO: We need to take the current isoWeekYear, but that depends on
+	        // how we interpret now (local, utc, fixed offset). So create
+	        // a now version of current config (take local/utc/offset flags, and
+	        // create now).
+	        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
+	        week = defaults(w.W, 1);
+	        weekday = defaults(w.E, 1);
+	        if (weekday < 1 || weekday > 7) {
+	            weekdayOverflow = true;
+	        }
+	    } else {
+	        dow = config._locale._week.dow;
+	        doy = config._locale._week.doy;
+
+	        var curWeek = weekOfYear(createLocal(), dow, doy);
+
+	        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
+
+	        // Default to current week.
+	        week = defaults(w.w, curWeek.week);
+
+	        if (w.d != null) {
+	            // weekday -- low day numbers are considered next week
+	            weekday = w.d;
+	            if (weekday < 0 || weekday > 6) {
+	                weekdayOverflow = true;
+	            }
+	        } else if (w.e != null) {
+	            // local weekday -- counting starts from begining of week
+	            weekday = w.e + dow;
+	            if (w.e < 0 || w.e > 6) {
+	                weekdayOverflow = true;
+	            }
+	        } else {
+	            // default to begining of week
+	            weekday = dow;
+	        }
+	    }
+	    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
+	        getParsingFlags(config)._overflowWeeks = true;
+	    } else if (weekdayOverflow != null) {
+	        getParsingFlags(config)._overflowWeekday = true;
+	    } else {
+	        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
+	        config._a[YEAR] = temp.year;
+	        config._dayOfYear = temp.dayOfYear;
+	    }
+	}
+
+	// constant that refers to the ISO standard
+	hooks.ISO_8601 = function () {};
+
+	// constant that refers to the RFC 2822 form
+	hooks.RFC_2822 = function () {};
+
+	// date from string and format string
+	function configFromStringAndFormat(config) {
+	    // TODO: Move this to another part of the creation flow to prevent circular deps
+	    if (config._f === hooks.ISO_8601) {
+	        configFromISO(config);
+	        return;
+	    }
+	    if (config._f === hooks.RFC_2822) {
+	        configFromRFC2822(config);
+	        return;
+	    }
+	    config._a = [];
+	    getParsingFlags(config).empty = true;
+
+	    // This array is used to make a Date, either with `new Date` or `Date.UTC`
+	    var string = '' + config._i,
+	        i, parsedInput, tokens, token, skipped,
+	        stringLength = string.length,
+	        totalParsedInputLength = 0;
+
+	    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
+
+	    for (i = 0; i < tokens.length; i++) {
+	        token = tokens[i];
+	        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
+	        // console.log('token', token, 'parsedInput', parsedInput,
+	        //         'regex', getParseRegexForToken(token, config));
+	        if (parsedInput) {
+	            skipped = string.substr(0, string.indexOf(parsedInput));
+	            if (skipped.length > 0) {
+	                getParsingFlags(config).unusedInput.push(skipped);
+	            }
+	            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
+	            totalParsedInputLength += parsedInput.length;
+	        }
+	        // don't parse if it's not a known token
+	        if (formatTokenFunctions[token]) {
+	            if (parsedInput) {
+	                getParsingFlags(config).empty = false;
+	            }
+	            else {
+	                getParsingFlags(config).unusedTokens.push(token);
+	            }
+	            addTimeToArrayFromToken(token, parsedInput, config);
+	        }
+	        else if (config._strict && !parsedInput) {
+	            getParsingFlags(config).unusedTokens.push(token);
+	        }
+	    }
+
+	    // add remaining unparsed input length to the string
+	    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
+	    if (string.length > 0) {
+	        getParsingFlags(config).unusedInput.push(string);
+	    }
+
+	    // clear _12h flag if hour is <= 12
+	    if (config._a[HOUR] <= 12 &&
+	        getParsingFlags(config).bigHour === true &&
+	        config._a[HOUR] > 0) {
+	        getParsingFlags(config).bigHour = undefined;
+	    }
+
+	    getParsingFlags(config).parsedDateParts = config._a.slice(0);
+	    getParsingFlags(config).meridiem = config._meridiem;
+	    // handle meridiem
+	    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
+
+	    configFromArray(config);
+	    checkOverflow(config);
+	}
+
+
+	function meridiemFixWrap (locale, hour, meridiem) {
+	    var isPm;
+
+	    if (meridiem == null) {
+	        // nothing to do
+	        return hour;
+	    }
+	    if (locale.meridiemHour != null) {
+	        return locale.meridiemHour(hour, meridiem);
+	    } else if (locale.isPM != null) {
+	        // Fallback
+	        isPm = locale.isPM(meridiem);
+	        if (isPm && hour < 12) {
+	            hour += 12;
+	        }
+	        if (!isPm && hour === 12) {
+	            hour = 0;
+	        }
+	        return hour;
+	    } else {
+	        // this is not supposed to happen
+	        return hour;
+	    }
+	}
+
+	// date from string and array of format strings
+	function configFromStringAndArray(config) {
+	    var tempConfig,
+	        bestMoment,
+
+	        scoreToBeat,
+	        i,
+	        currentScore;
+
+	    if (config._f.length === 0) {
+	        getParsingFlags(config).invalidFormat = true;
+	        config._d = new Date(NaN);
+	        return;
+	    }
+
+	    for (i = 0; i < config._f.length; i++) {
+	        currentScore = 0;
+	        tempConfig = copyConfig({}, config);
+	        if (config._useUTC != null) {
+	            tempConfig._useUTC = config._useUTC;
+	        }
+	        tempConfig._f = config._f[i];
+	        configFromStringAndFormat(tempConfig);
+
+	        if (!isValid(tempConfig)) {
+	            continue;
+	        }
+
+	        // if there is any input that was not parsed add a penalty for that format
+	        currentScore += getParsingFlags(tempConfig).charsLeftOver;
+
+	        //or tokens
+	        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
+
+	        getParsingFlags(tempConfig).score = currentScore;
+
+	        if (scoreToBeat == null || currentScore < scoreToBeat) {
+	            scoreToBeat = currentScore;
+	            bestMoment = tempConfig;
+	        }
+	    }
+
+	    extend(config, bestMoment || tempConfig);
+	}
+
+	function configFromObject(config) {
+	    if (config._d) {
+	        return;
+	    }
+
+	    var i = normalizeObjectUnits(config._i);
+	    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
+	        return obj && parseInt(obj, 10);
+	    });
+
+	    configFromArray(config);
+	}
+
+	function createFromConfig (config) {
+	    var res = new Moment(checkOverflow(prepareConfig(config)));
+	    if (res._nextDay) {
+	        // Adding is smart enough around DST
+	        res.add(1, 'd');
+	        res._nextDay = undefined;
+	    }
+
+	    return res;
+	}
+
+	function prepareConfig (config) {
+	    var input = config._i,
+	        format = config._f;
+
+	    config._locale = config._locale || getLocale(config._l);
+
+	    if (input === null || (format === undefined && input === '')) {
+	        return createInvalid({nullInput: true});
+	    }
+
+	    if (typeof input === 'string') {
+	        config._i = input = config._locale.preparse(input);
+	    }
+
+	    if (isMoment(input)) {
+	        return new Moment(checkOverflow(input));
+	    } else if (isDate(input)) {
+	        config._d = input;
+	    } else if (isArray(format)) {
+	        configFromStringAndArray(config);
+	    } else if (format) {
+	        configFromStringAndFormat(config);
+	    }  else {
+	        configFromInput(config);
+	    }
+
+	    if (!isValid(config)) {
+	        config._d = null;
+	    }
+
+	    return config;
+	}
+
+	function configFromInput(config) {
+	    var input = config._i;
+	    if (isUndefined(input)) {
+	        config._d = new Date(hooks.now());
+	    } else if (isDate(input)) {
+	        config._d = new Date(input.valueOf());
+	    } else if (typeof input === 'string') {
+	        configFromString(config);
+	    } else if (isArray(input)) {
+	        config._a = map(input.slice(0), function (obj) {
+	            return parseInt(obj, 10);
+	        });
+	        configFromArray(config);
+	    } else if (isObject(input)) {
+	        configFromObject(config);
+	    } else if (isNumber(input)) {
+	        // from milliseconds
+	        config._d = new Date(input);
+	    } else {
+	        hooks.createFromInputFallback(config);
+	    }
+	}
+
+	function createLocalOrUTC (input, format, locale, strict, isUTC) {
+	    var c = {};
+
+	    if (locale === true || locale === false) {
+	        strict = locale;
+	        locale = undefined;
+	    }
+
+	    if ((isObject(input) && isObjectEmpty(input)) ||
+	            (isArray(input) && input.length === 0)) {
+	        input = undefined;
+	    }
+	    // object construction must be done this way.
+	    // https://github.com/moment/moment/issues/1423
+	    c._isAMomentObject = true;
+	    c._useUTC = c._isUTC = isUTC;
+	    c._l = locale;
+	    c._i = input;
+	    c._f = format;
+	    c._strict = strict;
+
+	    return createFromConfig(c);
+	}
+
+	function createLocal (input, format, locale, strict) {
+	    return createLocalOrUTC(input, format, locale, strict, false);
+	}
+
+	var prototypeMin = deprecate(
+	    'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
+	    function () {
+	        var other = createLocal.apply(null, arguments);
+	        if (this.isValid() && other.isValid()) {
+	            return other < this ? this : other;
+	        } else {
+	            return createInvalid();
+	        }
+	    }
+	);
+
+	var prototypeMax = deprecate(
+	    'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
+	    function () {
+	        var other = createLocal.apply(null, arguments);
+	        if (this.isValid() && other.isValid()) {
+	            return other > this ? this : other;
+	        } else {
+	            return createInvalid();
+	        }
+	    }
+	);
+
+	// Pick a moment m from moments so that m[fn](other) is true for all
+	// other. This relies on the function fn to be transitive.
+	//
+	// moments should either be an array of moment objects or an array, whose
+	// first element is an array of moment objects.
+	function pickBy(fn, moments) {
+	    var res, i;
+	    if (moments.length === 1 && isArray(moments[0])) {
+	        moments = moments[0];
+	    }
+	    if (!moments.length) {
+	        return createLocal();
+	    }
+	    res = moments[0];
+	    for (i = 1; i < moments.length; ++i) {
+	        if (!moments[i].isValid() || moments[i][fn](res)) {
+	            res = moments[i];
+	        }
+	    }
+	    return res;
+	}
+
+	// TODO: Use [].sort instead?
+	function min () {
+	    var args = [].slice.call(arguments, 0);
+
+	    return pickBy('isBefore', args);
+	}
+
+	function max () {
+	    var args = [].slice.call(arguments, 0);
+
+	    return pickBy('isAfter', args);
+	}
+
+	var now = function () {
+	    return Date.now ? Date.now() : +(new Date());
+	};
+
+	var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
+
+	function isDurationValid(m) {
+	    for (var key in m) {
+	        if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
+	            return false;
+	        }
+	    }
+
+	    var unitHasDecimal = false;
+	    for (var i = 0; i < ordering.length; ++i) {
+	        if (m[ordering[i]]) {
+	            if (unitHasDecimal) {
+	                return false; // only allow non-integers for smallest unit
+	            }
+	            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
+	                unitHasDecimal = true;
+	            }
+	        }
+	    }
+
+	    return true;
+	}
+
+	function isValid$1() {
+	    return this._isValid;
+	}
+
+	function createInvalid$1() {
+	    return createDuration(NaN);
+	}
+
+	function Duration (duration) {
+	    var normalizedInput = normalizeObjectUnits(duration),
+	        years = normalizedInput.year || 0,
+	        quarters = normalizedInput.quarter || 0,
+	        months = normalizedInput.month || 0,
+	        weeks = normalizedInput.week || 0,
+	        days = normalizedInput.day || 0,
+	        hours = normalizedInput.hour || 0,
+	        minutes = normalizedInput.minute || 0,
+	        seconds = normalizedInput.second || 0,
+	        milliseconds = normalizedInput.millisecond || 0;
+
+	    this._isValid = isDurationValid(normalizedInput);
+
+	    // representation for dateAddRemove
+	    this._milliseconds = +milliseconds +
+	        seconds * 1e3 + // 1000
+	        minutes * 6e4 + // 1000 * 60
+	        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
+	    // Because of dateAddRemove treats 24 hours as different from a
+	    // day when working around DST, we need to store them separately
+	    this._days = +days +
+	        weeks * 7;
+	    // It is impossible translate months into days without knowing
+	    // which months you are are talking about, so we have to store
+	    // it separately.
+	    this._months = +months +
+	        quarters * 3 +
+	        years * 12;
+
+	    this._data = {};
+
+	    this._locale = getLocale();
+
+	    this._bubble();
+	}
+
+	function isDuration (obj) {
+	    return obj instanceof Duration;
+	}
+
+	function absRound (number) {
+	    if (number < 0) {
+	        return Math.round(-1 * number) * -1;
+	    } else {
+	        return Math.round(number);
+	    }
+	}
+
+	// FORMATTING
+
+	function offset (token, separator) {
+	    addFormatToken(token, 0, 0, function () {
+	        var offset = this.utcOffset();
+	        var sign = '+';
+	        if (offset < 0) {
+	            offset = -offset;
+	            sign = '-';
+	        }
+	        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
+	    });
+	}
+
+	offset('Z', ':');
+	offset('ZZ', '');
+
+	// PARSING
+
+	addRegexToken('Z',  matchShortOffset);
+	addRegexToken('ZZ', matchShortOffset);
+	addParseToken(['Z', 'ZZ'], function (input, array, config) {
+	    config._useUTC = true;
+	    config._tzm = offsetFromString(matchShortOffset, input);
+	});
+
+	// HELPERS
+
+	// timezone chunker
+	// '+10:00' > ['10',  '00']
+	// '-1530'  > ['-15', '30']
+	var chunkOffset = /([\+\-]|\d\d)/gi;
+
+	function offsetFromString(matcher, string) {
+	    var matches = (string || '').match(matcher);
+
+	    if (matches === null) {
+	        return null;
+	    }
+
+	    var chunk   = matches[matches.length - 1] || [];
+	    var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
+	    var minutes = +(parts[1] * 60) + toInt(parts[2]);
+
+	    return minutes === 0 ?
+	      0 :
+	      parts[0] === '+' ? minutes : -minutes;
+	}
+
+	// Return a moment from input, that is local/utc/zone equivalent to model.
+	function cloneWithOffset(input, model) {
+	    var res, diff;
+	    if (model._isUTC) {
+	        res = model.clone();
+	        diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
+	        // Use low-level api, because this fn is low-level api.
+	        res._d.setTime(res._d.valueOf() + diff);
+	        hooks.updateOffset(res, false);
+	        return res;
+	    } else {
+	        return createLocal(input).local();
+	    }
+	}
+
+	function getDateOffset (m) {
+	    // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+	    // https://github.com/moment/moment/pull/1871
+	    return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
+	}
+
+	// HOOKS
+
+	// This function will be called whenever a moment is mutated.
+	// It is intended to keep the offset in sync with the timezone.
+	hooks.updateOffset = function () {};
+
+	// MOMENTS
+
+	// keepLocalTime = true means only change the timezone, without
+	// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
+	// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
+	// +0200, so we adjust the time as needed, to be valid.
+	//
+	// Keeping the time actually adds/subtracts (one hour)
+	// from the actual represented time. That is why we call updateOffset
+	// a second time. In case it wants us to change the offset again
+	// _changeInProgress == true case, then we have to adjust, because
+	// there is no such time in the given timezone.
+	function getSetOffset (input, keepLocalTime, keepMinutes) {
+	    var offset = this._offset || 0,
+	        localAdjust;
+	    if (!this.isValid()) {
+	        return input != null ? this : NaN;
+	    }
+	    if (input != null) {
+	        if (typeof input === 'string') {
+	            input = offsetFromString(matchShortOffset, input);
+	            if (input === null) {
+	                return this;
+	            }
+	        } else if (Math.abs(input) < 16 && !keepMinutes) {
+	            input = input * 60;
+	        }
+	        if (!this._isUTC && keepLocalTime) {
+	            localAdjust = getDateOffset(this);
+	        }
+	        this._offset = input;
+	        this._isUTC = true;
+	        if (localAdjust != null) {
+	            this.add(localAdjust, 'm');
+	        }
+	        if (offset !== input) {
+	            if (!keepLocalTime || this._changeInProgress) {
+	                addSubtract(this, createDuration(input - offset, 'm'), 1, false);
+	            } else if (!this._changeInProgress) {
+	                this._changeInProgress = true;
+	                hooks.updateOffset(this, true);
+	                this._changeInProgress = null;
+	            }
+	        }
+	        return this;
+	    } else {
+	        return this._isUTC ? offset : getDateOffset(this);
+	    }
+	}
+
+	function getSetZone (input, keepLocalTime) {
+	    if (input != null) {
+	        if (typeof input !== 'string') {
+	            input = -input;
+	        }
+
+	        this.utcOffset(input, keepLocalTime);
+
+	        return this;
+	    } else {
+	        return -this.utcOffset();
+	    }
+	}
+
+	function setOffsetToUTC (keepLocalTime) {
+	    return this.utcOffset(0, keepLocalTime);
+	}
+
+	function setOffsetToLocal (keepLocalTime) {
+	    if (this._isUTC) {
+	        this.utcOffset(0, keepLocalTime);
+	        this._isUTC = false;
+
+	        if (keepLocalTime) {
+	            this.subtract(getDateOffset(this), 'm');
+	        }
+	    }
+	    return this;
+	}
+
+	function setOffsetToParsedOffset () {
+	    if (this._tzm != null) {
+	        this.utcOffset(this._tzm, false, true);
+	    } else if (typeof this._i === 'string') {
+	        var tZone = offsetFromString(matchOffset, this._i);
+	        if (tZone != null) {
+	            this.utcOffset(tZone);
+	        }
+	        else {
+	            this.utcOffset(0, true);
+	        }
+	    }
+	    return this;
+	}
+
+	function hasAlignedHourOffset (input) {
+	    if (!this.isValid()) {
+	        return false;
+	    }
+	    input = input ? createLocal(input).utcOffset() : 0;
+
+	    return (this.utcOffset() - input) % 60 === 0;
+	}
+
+	function isDaylightSavingTime () {
+	    return (
+	        this.utcOffset() > this.clone().month(0).utcOffset() ||
+	        this.utcOffset() > this.clone().month(5).utcOffset()
+	    );
+	}
+
+	function isDaylightSavingTimeShifted () {
+	    if (!isUndefined(this._isDSTShifted)) {
+	        return this._isDSTShifted;
+	    }
+
+	    var c = {};
+
+	    copyConfig(c, this);
+	    c = prepareConfig(c);
+
+	    if (c._a) {
+	        var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+	        this._isDSTShifted = this.isValid() &&
+	            compareArrays(c._a, other.toArray()) > 0;
+	    } else {
+	        this._isDSTShifted = false;
+	    }
+
+	    return this._isDSTShifted;
+	}
+
+	function isLocal () {
+	    return this.isValid() ? !this._isUTC : false;
+	}
+
+	function isUtcOffset () {
+	    return this.isValid() ? this._isUTC : false;
+	}
+
+	function isUtc () {
+	    return this.isValid() ? this._isUTC && this._offset === 0 : false;
+	}
+
+	// ASP.NET json date format regex
+	var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
+
+	// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+	// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+	// and further modified to allow for strings containing both week and day
+	var isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
+
+	function createDuration (input, key) {
+	    var duration = input,
+	        // matching against regexp is expensive, do it on demand
+	        match = null,
+	        sign,
+	        ret,
+	        diffRes;
+
+	    if (isDuration(input)) {
+	        duration = {
+	            ms : input._milliseconds,
+	            d  : input._days,
+	            M  : input._months
+	        };
+	    } else if (isNumber(input)) {
+	        duration = {};
+	        if (key) {
+	            duration[key] = input;
+	        } else {
+	            duration.milliseconds = input;
+	        }
+	    } else if (!!(match = aspNetRegex.exec(input))) {
+	        sign = (match[1] === '-') ? -1 : 1;
+	        duration = {
+	            y  : 0,
+	            d  : toInt(match[DATE])                         * sign,
+	            h  : toInt(match[HOUR])                         * sign,
+	            m  : toInt(match[MINUTE])                       * sign,
+	            s  : toInt(match[SECOND])                       * sign,
+	            ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
+	        };
+	    } else if (!!(match = isoRegex.exec(input))) {
+	        sign = (match[1] === '-') ? -1 : 1;
+	        duration = {
+	            y : parseIso(match[2], sign),
+	            M : parseIso(match[3], sign),
+	            w : parseIso(match[4], sign),
+	            d : parseIso(match[5], sign),
+	            h : parseIso(match[6], sign),
+	            m : parseIso(match[7], sign),
+	            s : parseIso(match[8], sign)
+	        };
+	    } else if (duration == null) {// checks for null or undefined
+	        duration = {};
+	    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
+	        diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
+
+	        duration = {};
+	        duration.ms = diffRes.milliseconds;
+	        duration.M = diffRes.months;
+	    }
+
+	    ret = new Duration(duration);
+
+	    if (isDuration(input) && hasOwnProp(input, '_locale')) {
+	        ret._locale = input._locale;
+	    }
+
+	    return ret;
+	}
+
+	createDuration.fn = Duration.prototype;
+	createDuration.invalid = createInvalid$1;
+
+	function parseIso (inp, sign) {
+	    // We'd normally use ~~inp for this, but unfortunately it also
+	    // converts floats to ints.
+	    // inp may be undefined, so careful calling replace on it.
+	    var res = inp && parseFloat(inp.replace(',', '.'));
+	    // apply sign while we're at it
+	    return (isNaN(res) ? 0 : res) * sign;
+	}
+
+	function positiveMomentsDifference(base, other) {
+	    var res = {milliseconds: 0, months: 0};
+
+	    res.months = other.month() - base.month() +
+	        (other.year() - base.year()) * 12;
+	    if (base.clone().add(res.months, 'M').isAfter(other)) {
+	        --res.months;
+	    }
+
+	    res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
+
+	    return res;
+	}
+
+	function momentsDifference(base, other) {
+	    var res;
+	    if (!(base.isValid() && other.isValid())) {
+	        return {milliseconds: 0, months: 0};
+	    }
+
+	    other = cloneWithOffset(other, base);
+	    if (base.isBefore(other)) {
+	        res = positiveMomentsDifference(base, other);
+	    } else {
+	        res = positiveMomentsDifference(other, base);
+	        res.milliseconds = -res.milliseconds;
+	        res.months = -res.months;
+	    }
+
+	    return res;
+	}
+
+	// TODO: remove 'name' arg after deprecation is removed
+	function createAdder(direction, name) {
+	    return function (val, period) {
+	        var dur, tmp;
+	        //invert the arguments, but complain about it
+	        if (period !== null && !isNaN(+period)) {
+	            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
+	            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
+	            tmp = val; val = period; period = tmp;
+	        }
+
+	        val = typeof val === 'string' ? +val : val;
+	        dur = createDuration(val, period);
+	        addSubtract(this, dur, direction);
+	        return this;
+	    };
+	}
+
+	function addSubtract (mom, duration, isAdding, updateOffset) {
+	    var milliseconds = duration._milliseconds,
+	        days = absRound(duration._days),
+	        months = absRound(duration._months);
+
+	    if (!mom.isValid()) {
+	        // No op
+	        return;
+	    }
+
+	    updateOffset = updateOffset == null ? true : updateOffset;
+
+	    if (milliseconds) {
+	        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
+	    }
+	    if (days) {
+	        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
+	    }
+	    if (months) {
+	        setMonth(mom, get(mom, 'Month') + months * isAdding);
+	    }
+	    if (updateOffset) {
+	        hooks.updateOffset(mom, days || months);
+	    }
+	}
+
+	var add      = createAdder(1, 'add');
+	var subtract = createAdder(-1, 'subtract');
+
+	function getCalendarFormat(myMoment, now) {
+	    var diff = myMoment.diff(now, 'days', true);
+	    return diff < -6 ? 'sameElse' :
+	            diff < -1 ? 'lastWeek' :
+	            diff < 0 ? 'lastDay' :
+	            diff < 1 ? 'sameDay' :
+	            diff < 2 ? 'nextDay' :
+	            diff < 7 ? 'nextWeek' : 'sameElse';
+	}
+
+	function calendar$1 (time, formats) {
+	    // We want to compare the start of today, vs this.
+	    // Getting start-of-today depends on whether we're local/utc/offset or not.
+	    var now = time || createLocal(),
+	        sod = cloneWithOffset(now, this).startOf('day'),
+	        format = hooks.calendarFormat(this, sod) || 'sameElse';
+
+	    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
+
+	    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
+	}
+
+	function clone () {
+	    return new Moment(this);
+	}
+
+	function isAfter (input, units) {
+	    var localInput = isMoment(input) ? input : createLocal(input);
+	    if (!(this.isValid() && localInput.isValid())) {
+	        return false;
+	    }
+	    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
+	    if (units === 'millisecond') {
+	        return this.valueOf() > localInput.valueOf();
+	    } else {
+	        return localInput.valueOf() < this.clone().startOf(units).valueOf();
+	    }
+	}
+
+	function isBefore (input, units) {
+	    var localInput = isMoment(input) ? input : createLocal(input);
+	    if (!(this.isValid() && localInput.isValid())) {
+	        return false;
+	    }
+	    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
+	    if (units === 'millisecond') {
+	        return this.valueOf() < localInput.valueOf();
+	    } else {
+	        return this.clone().endOf(units).valueOf() < localInput.valueOf();
+	    }
+	}
+
+	function isBetween (from, to, units, inclusivity) {
+	    inclusivity = inclusivity || '()';
+	    return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
+	        (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
+	}
+
+	function isSame (input, units) {
+	    var localInput = isMoment(input) ? input : createLocal(input),
+	        inputMs;
+	    if (!(this.isValid() && localInput.isValid())) {
+	        return false;
+	    }
+	    units = normalizeUnits(units || 'millisecond');
+	    if (units === 'millisecond') {
+	        return this.valueOf() === localInput.valueOf();
+	    } else {
+	        inputMs = localInput.valueOf();
+	        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
+	    }
+	}
+
+	function isSameOrAfter (input, units) {
+	    return this.isSame(input, units) || this.isAfter(input,units);
+	}
+
+	function isSameOrBefore (input, units) {
+	    return this.isSame(input, units) || this.isBefore(input,units);
+	}
+
+	function diff (input, units, asFloat) {
+	    var that,
+	        zoneDelta,
+	        delta, output;
+
+	    if (!this.isValid()) {
+	        return NaN;
+	    }
+
+	    that = cloneWithOffset(input, this);
+
+	    if (!that.isValid()) {
+	        return NaN;
+	    }
+
+	    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
+
+	    units = normalizeUnits(units);
+
+	    if (units === 'year' || units === 'month' || units === 'quarter') {
+	        output = monthDiff(this, that);
+	        if (units === 'quarter') {
+	            output = output / 3;
+	        } else if (units === 'year') {
+	            output = output / 12;
+	        }
+	    } else {
+	        delta = this - that;
+	        output = units === 'second' ? delta / 1e3 : // 1000
+	            units === 'minute' ? delta / 6e4 : // 1000 * 60
+	            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
+	            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
+	            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
+	            delta;
+	    }
+	    return asFloat ? output : absFloor(output);
+	}
+
+	function monthDiff (a, b) {
+	    // difference in months
+	    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
+	        // b is in (anchor - 1 month, anchor + 1 month)
+	        anchor = a.clone().add(wholeMonthDiff, 'months'),
+	        anchor2, adjust;
+
+	    if (b - anchor < 0) {
+	        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
+	        // linear across the month
+	        adjust = (b - anchor) / (anchor - anchor2);
+	    } else {
+	        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
+	        // linear across the month
+	        adjust = (b - anchor) / (anchor2 - anchor);
+	    }
+
+	    //check for negative zero, return zero if negative zero
+	    return -(wholeMonthDiff + adjust) || 0;
+	}
+
+	hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
+	hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
+
+	function toString () {
+	    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
+	}
+
+	function toISOString() {
+	    if (!this.isValid()) {
+	        return null;
+	    }
+	    var m = this.clone().utc();
+	    if (m.year() < 0 || m.year() > 9999) {
+	        return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+	    }
+	    if (isFunction(Date.prototype.toISOString)) {
+	        // native implementation is ~50x faster, use it when we can
+	        return this.toDate().toISOString();
+	    }
+	    return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+	}
+
+	/**
+	 * Return a human readable representation of a moment that can
+	 * also be evaluated to get a new moment which is the same
+	 *
+	 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
+	 */
+	function inspect () {
+	    if (!this.isValid()) {
+	        return 'moment.invalid(/* ' + this._i + ' */)';
+	    }
+	    var func = 'moment';
+	    var zone = '';
+	    if (!this.isLocal()) {
+	        func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
+	        zone = 'Z';
+	    }
+	    var prefix = '[' + func + '("]';
+	    var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
+	    var datetime = '-MM-DD[T]HH:mm:ss.SSS';
+	    var suffix = zone + '[")]';
+
+	    return this.format(prefix + year + datetime + suffix);
+	}
+
+	function format (inputString) {
+	    if (!inputString) {
+	        inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
+	    }
+	    var output = formatMoment(this, inputString);
+	    return this.localeData().postformat(output);
+	}
+
+	function from (time, withoutSuffix) {
+	    if (this.isValid() &&
+	            ((isMoment(time) && time.isValid()) ||
+	             createLocal(time).isValid())) {
+	        return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
+	    } else {
+	        return this.localeData().invalidDate();
+	    }
+	}
+
+	function fromNow (withoutSuffix) {
+	    return this.from(createLocal(), withoutSuffix);
+	}
+
+	function to (time, withoutSuffix) {
+	    if (this.isValid() &&
+	            ((isMoment(time) && time.isValid()) ||
+	             createLocal(time).isValid())) {
+	        return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
+	    } else {
+	        return this.localeData().invalidDate();
+	    }
+	}
+
+	function toNow (withoutSuffix) {
+	    return this.to(createLocal(), withoutSuffix);
+	}
+
+	// If passed a locale key, it will set the locale for this
+	// instance.  Otherwise, it will return the locale configuration
+	// variables for this instance.
+	function locale (key) {
+	    var newLocaleData;
+
+	    if (key === undefined) {
+	        return this._locale._abbr;
+	    } else {
+	        newLocaleData = getLocale(key);
+	        if (newLocaleData != null) {
+	            this._locale = newLocaleData;
+	        }
+	        return this;
+	    }
+	}
+
+	var lang = deprecate(
+	    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
+	    function (key) {
+	        if (key === undefined) {
+	            return this.localeData();
+	        } else {
+	            return this.locale(key);
+	        }
+	    }
+	);
+
+	function localeData () {
+	    return this._locale;
+	}
+
+	function startOf (units) {
+	    units = normalizeUnits(units);
+	    // the following switch intentionally omits break keywords
+	    // to utilize falling through the cases.
+	    switch (units) {
+	        case 'year':
+	            this.month(0);
+	            /* falls through */
+	        case 'quarter':
+	        case 'month':
+	            this.date(1);
+	            /* falls through */
+	        case 'week':
+	        case 'isoWeek':
+	        case 'day':
+	        case 'date':
+	            this.hours(0);
+	            /* falls through */
+	        case 'hour':
+	            this.minutes(0);
+	            /* falls through */
+	        case 'minute':
+	            this.seconds(0);
+	            /* falls through */
+	        case 'second':
+	            this.milliseconds(0);
+	    }
+
+	    // weeks are a special case
+	    if (units === 'week') {
+	        this.weekday(0);
+	    }
+	    if (units === 'isoWeek') {
+	        this.isoWeekday(1);
+	    }
+
+	    // quarters are also special
+	    if (units === 'quarter') {
+	        this.month(Math.floor(this.month() / 3) * 3);
+	    }
+
+	    return this;
+	}
+
+	function endOf (units) {
+	    units = normalizeUnits(units);
+	    if (units === undefined || units === 'millisecond') {
+	        return this;
+	    }
+
+	    // 'date' is an alias for 'day', so it should be considered as such.
+	    if (units === 'date') {
+	        units = 'day';
+	    }
+
+	    return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
+	}
+
+	function valueOf () {
+	    return this._d.valueOf() - ((this._offset || 0) * 60000);
+	}
+
+	function unix () {
+	    return Math.floor(this.valueOf() / 1000);
+	}
+
+	function toDate () {
+	    return new Date(this.valueOf());
+	}
+
+	function toArray () {
+	    var m = this;
+	    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
+	}
+
+	function toObject () {
+	    var m = this;
+	    return {
+	        years: m.year(),
+	        months: m.month(),
+	        date: m.date(),
+	        hours: m.hours(),
+	        minutes: m.minutes(),
+	        seconds: m.seconds(),
+	        milliseconds: m.milliseconds()
+	    };
+	}
+
+	function toJSON () {
+	    // new Date(NaN).toJSON() === null
+	    return this.isValid() ? this.toISOString() : null;
+	}
+
+	function isValid$2 () {
+	    return isValid(this);
+	}
+
+	function parsingFlags () {
+	    return extend({}, getParsingFlags(this));
+	}
+
+	function invalidAt () {
+	    return getParsingFlags(this).overflow;
+	}
+
+	function creationData() {
+	    return {
+	        input: this._i,
+	        format: this._f,
+	        locale: this._locale,
+	        isUTC: this._isUTC,
+	        strict: this._strict
+	    };
+	}
+
+	// FORMATTING
+
+	addFormatToken(0, ['gg', 2], 0, function () {
+	    return this.weekYear() % 100;
+	});
+
+	addFormatToken(0, ['GG', 2], 0, function () {
+	    return this.isoWeekYear() % 100;
+	});
+
+	function addWeekYearFormatToken (token, getter) {
+	    addFormatToken(0, [token, token.length], 0, getter);
+	}
+
+	addWeekYearFormatToken('gggg',     'weekYear');
+	addWeekYearFormatToken('ggggg',    'weekYear');
+	addWeekYearFormatToken('GGGG',  'isoWeekYear');
+	addWeekYearFormatToken('GGGGG', 'isoWeekYear');
+
+	// ALIASES
+
+	addUnitAlias('weekYear', 'gg');
+	addUnitAlias('isoWeekYear', 'GG');
+
+	// PRIORITY
+
+	addUnitPriority('weekYear', 1);
+	addUnitPriority('isoWeekYear', 1);
+
+
+	// PARSING
+
+	addRegexToken('G',      matchSigned);
+	addRegexToken('g',      matchSigned);
+	addRegexToken('GG',     match1to2, match2);
+	addRegexToken('gg',     match1to2, match2);
+	addRegexToken('GGGG',   match1to4, match4);
+	addRegexToken('gggg',   match1to4, match4);
+	addRegexToken('GGGGG',  match1to6, match6);
+	addRegexToken('ggggg',  match1to6, match6);
+
+	addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
+	    week[token.substr(0, 2)] = toInt(input);
+	});
+
+	addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
+	    week[token] = hooks.parseTwoDigitYear(input);
+	});
+
+	// MOMENTS
+
+	function getSetWeekYear (input) {
+	    return getSetWeekYearHelper.call(this,
+	            input,
+	            this.week(),
+	            this.weekday(),
+	            this.localeData()._week.dow,
+	            this.localeData()._week.doy);
+	}
+
+	function getSetISOWeekYear (input) {
+	    return getSetWeekYearHelper.call(this,
+	            input, this.isoWeek(), this.isoWeekday(), 1, 4);
+	}
+
+	function getISOWeeksInYear () {
+	    return weeksInYear(this.year(), 1, 4);
+	}
+
+	function getWeeksInYear () {
+	    var weekInfo = this.localeData()._week;
+	    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
+	}
+
+	function getSetWeekYearHelper(input, week, weekday, dow, doy) {
+	    var weeksTarget;
+	    if (input == null) {
+	        return weekOfYear(this, dow, doy).year;
+	    } else {
+	        weeksTarget = weeksInYear(input, dow, doy);
+	        if (week > weeksTarget) {
+	            week = weeksTarget;
+	        }
+	        return setWeekAll.call(this, input, week, weekday, dow, doy);
+	    }
+	}
+
+	function setWeekAll(weekYear, week, weekday, dow, doy) {
+	    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
+	        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
+
+	    this.year(date.getUTCFullYear());
+	    this.month(date.getUTCMonth());
+	    this.date(date.getUTCDate());
+	    return this;
+	}
+
+	// FORMATTING
+
+	addFormatToken('Q', 0, 'Qo', 'quarter');
+
+	// ALIASES
+
+	addUnitAlias('quarter', 'Q');
+
+	// PRIORITY
+
+	addUnitPriority('quarter', 7);
+
+	// PARSING
+
+	addRegexToken('Q', match1);
+	addParseToken('Q', function (input, array) {
+	    array[MONTH] = (toInt(input) - 1) * 3;
+	});
+
+	// MOMENTS
+
+	function getSetQuarter (input) {
+	    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
+	}
+
+	// FORMATTING
+
+	addFormatToken('D', ['DD', 2], 'Do', 'date');
+
+	// ALIASES
+
+	addUnitAlias('date', 'D');
+
+	// PRIOROITY
+	addUnitPriority('date', 9);
+
+	// PARSING
+
+	addRegexToken('D',  match1to2);
+	addRegexToken('DD', match1to2, match2);
+	addRegexToken('Do', function (isStrict, locale) {
+	    // TODO: Remove "ordinalParse" fallback in next major release.
+	    return isStrict ?
+	      (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
+	      locale._dayOfMonthOrdinalParseLenient;
+	});
+
+	addParseToken(['D', 'DD'], DATE);
+	addParseToken('Do', function (input, array) {
+	    array[DATE] = toInt(input.match(match1to2)[0], 10);
+	});
+
+	// MOMENTS
+
+	var getSetDayOfMonth = makeGetSet('Date', true);
+
+	// FORMATTING
+
+	addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
+
+	// ALIASES
+
+	addUnitAlias('dayOfYear', 'DDD');
+
+	// PRIORITY
+	addUnitPriority('dayOfYear', 4);
+
+	// PARSING
+
+	addRegexToken('DDD',  match1to3);
+	addRegexToken('DDDD', match3);
+	addParseToken(['DDD', 'DDDD'], function (input, array, config) {
+	    config._dayOfYear = toInt(input);
+	});
+
+	// HELPERS
+
+	// MOMENTS
+
+	function getSetDayOfYear (input) {
+	    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
+	    return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
+	}
+
+	// FORMATTING
+
+	addFormatToken('m', ['mm', 2], 0, 'minute');
+
+	// ALIASES
+
+	addUnitAlias('minute', 'm');
+
+	// PRIORITY
+
+	addUnitPriority('minute', 14);
+
+	// PARSING
+
+	addRegexToken('m',  match1to2);
+	addRegexToken('mm', match1to2, match2);
+	addParseToken(['m', 'mm'], MINUTE);
+
+	// MOMENTS
+
+	var getSetMinute = makeGetSet('Minutes', false);
+
+	// FORMATTING
+
+	addFormatToken('s', ['ss', 2], 0, 'second');
+
+	// ALIASES
+
+	addUnitAlias('second', 's');
+
+	// PRIORITY
+
+	addUnitPriority('second', 15);
+
+	// PARSING
+
+	addRegexToken('s',  match1to2);
+	addRegexToken('ss', match1to2, match2);
+	addParseToken(['s', 'ss'], SECOND);
+
+	// MOMENTS
+
+	var getSetSecond = makeGetSet('Seconds', false);
+
+	// FORMATTING
+
+	addFormatToken('S', 0, 0, function () {
+	    return ~~(this.millisecond() / 100);
+	});
+
+	addFormatToken(0, ['SS', 2], 0, function () {
+	    return ~~(this.millisecond() / 10);
+	});
+
+	addFormatToken(0, ['SSS', 3], 0, 'millisecond');
+	addFormatToken(0, ['SSSS', 4], 0, function () {
+	    return this.millisecond() * 10;
+	});
+	addFormatToken(0, ['SSSSS', 5], 0, function () {
+	    return this.millisecond() * 100;
+	});
+	addFormatToken(0, ['SSSSSS', 6], 0, function () {
+	    return this.millisecond() * 1000;
+	});
+	addFormatToken(0, ['SSSSSSS', 7], 0, function () {
+	    return this.millisecond() * 10000;
+	});
+	addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
+	    return this.millisecond() * 100000;
+	});
+	addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
+	    return this.millisecond() * 1000000;
+	});
+
+
+	// ALIASES
+
+	addUnitAlias('millisecond', 'ms');
+
+	// PRIORITY
+
+	addUnitPriority('millisecond', 16);
+
+	// PARSING
+
+	addRegexToken('S',    match1to3, match1);
+	addRegexToken('SS',   match1to3, match2);
+	addRegexToken('SSS',  match1to3, match3);
+
+	var token;
+	for (token = 'SSSS'; token.length <= 9; token += 'S') {
+	    addRegexToken(token, matchUnsigned);
+	}
+
+	function parseMs(input, array) {
+	    array[MILLISECOND] = toInt(('0.' + input) * 1000);
+	}
+
+	for (token = 'S'; token.length <= 9; token += 'S') {
+	    addParseToken(token, parseMs);
+	}
+	// MOMENTS
+
+	var getSetMillisecond = makeGetSet('Milliseconds', false);
+
+	// FORMATTING
+
+	addFormatToken('z',  0, 0, 'zoneAbbr');
+	addFormatToken('zz', 0, 0, 'zoneName');
+
+	// MOMENTS
+
+	function getZoneAbbr () {
+	    return this._isUTC ? 'UTC' : '';
+	}
+
+	function getZoneName () {
+	    return this._isUTC ? 'Coordinated Universal Time' : '';
+	}
+
+	var proto = Moment.prototype;
+
+	proto.add               = add;
+	proto.calendar          = calendar$1;
+	proto.clone             = clone;
+	proto.diff              = diff;
+	proto.endOf             = endOf;
+	proto.format            = format;
+	proto.from              = from;
+	proto.fromNow           = fromNow;
+	proto.to                = to;
+	proto.toNow             = toNow;
+	proto.get               = stringGet;
+	proto.invalidAt         = invalidAt;
+	proto.isAfter           = isAfter;
+	proto.isBefore          = isBefore;
+	proto.isBetween         = isBetween;
+	proto.isSame            = isSame;
+	proto.isSameOrAfter     = isSameOrAfter;
+	proto.isSameOrBefore    = isSameOrBefore;
+	proto.isValid           = isValid$2;
+	proto.lang              = lang;
+	proto.locale            = locale;
+	proto.localeData        = localeData;
+	proto.max               = prototypeMax;
+	proto.min               = prototypeMin;
+	proto.parsingFlags      = parsingFlags;
+	proto.set               = stringSet;
+	proto.startOf           = startOf;
+	proto.subtract          = subtract;
+	proto.toArray           = toArray;
+	proto.toObject          = toObject;
+	proto.toDate            = toDate;
+	proto.toISOString       = toISOString;
+	proto.inspect           = inspect;
+	proto.toJSON            = toJSON;
+	proto.toString          = toString;
+	proto.unix              = unix;
+	proto.valueOf           = valueOf;
+	proto.creationData      = creationData;
+
+	// Year
+	proto.year       = getSetYear;
+	proto.isLeapYear = getIsLeapYear;
+
+	// Week Year
+	proto.weekYear    = getSetWeekYear;
+	proto.isoWeekYear = getSetISOWeekYear;
+
+	// Quarter
+	proto.quarter = proto.quarters = getSetQuarter;
+
+	// Month
+	proto.month       = getSetMonth;
+	proto.daysInMonth = getDaysInMonth;
+
+	// Week
+	proto.week           = proto.weeks        = getSetWeek;
+	proto.isoWeek        = proto.isoWeeks     = getSetISOWeek;
+	proto.weeksInYear    = getWeeksInYear;
+	proto.isoWeeksInYear = getISOWeeksInYear;
+
+	// Day
+	proto.date       = getSetDayOfMonth;
+	proto.day        = proto.days             = getSetDayOfWeek;
+	proto.weekday    = getSetLocaleDayOfWeek;
+	proto.isoWeekday = getSetISODayOfWeek;
+	proto.dayOfYear  = getSetDayOfYear;
+
+	// Hour
+	proto.hour = proto.hours = getSetHour;
+
+	// Minute
+	proto.minute = proto.minutes = getSetMinute;
+
+	// Second
+	proto.second = proto.seconds = getSetSecond;
+
+	// Millisecond
+	proto.millisecond = proto.milliseconds = getSetMillisecond;
+
+	// Offset
+	proto.utcOffset            = getSetOffset;
+	proto.utc                  = setOffsetToUTC;
+	proto.local                = setOffsetToLocal;
+	proto.parseZone            = setOffsetToParsedOffset;
+	proto.hasAlignedHourOffset = hasAlignedHourOffset;
+	proto.isDST                = isDaylightSavingTime;
+	proto.isLocal              = isLocal;
+	proto.isUtcOffset          = isUtcOffset;
+	proto.isUtc                = isUtc;
+	proto.isUTC                = isUtc;
+
+	// Timezone
+	proto.zoneAbbr = getZoneAbbr;
+	proto.zoneName = getZoneName;
+
+	// Deprecations
+	proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
+	proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
+	proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
+	proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
+	proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
+
+	function createUnix (input) {
+	    return createLocal(input * 1000);
+	}
+
+	function createInZone () {
+	    return createLocal.apply(null, arguments).parseZone();
+	}
+
+	function preParsePostFormat (string) {
+	    return string;
+	}
+
+	var proto$1 = Locale.prototype;
+
+	proto$1.calendar        = calendar;
+	proto$1.longDateFormat  = longDateFormat;
+	proto$1.invalidDate     = invalidDate;
+	proto$1.ordinal         = ordinal;
+	proto$1.preparse        = preParsePostFormat;
+	proto$1.postformat      = preParsePostFormat;
+	proto$1.relativeTime    = relativeTime;
+	proto$1.pastFuture      = pastFuture;
+	proto$1.set             = set;
+
+	// Month
+	proto$1.months            =        localeMonths;
+	proto$1.monthsShort       =        localeMonthsShort;
+	proto$1.monthsParse       =        localeMonthsParse;
+	proto$1.monthsRegex       = monthsRegex;
+	proto$1.monthsShortRegex  = monthsShortRegex;
+
+	// Week
+	proto$1.week = localeWeek;
+	proto$1.firstDayOfYear = localeFirstDayOfYear;
+	proto$1.firstDayOfWeek = localeFirstDayOfWeek;
+
+	// Day of Week
+	proto$1.weekdays       =        localeWeekdays;
+	proto$1.weekdaysMin    =        localeWeekdaysMin;
+	proto$1.weekdaysShort  =        localeWeekdaysShort;
+	proto$1.weekdaysParse  =        localeWeekdaysParse;
+
+	proto$1.weekdaysRegex       =        weekdaysRegex;
+	proto$1.weekdaysShortRegex  =        weekdaysShortRegex;
+	proto$1.weekdaysMinRegex    =        weekdaysMinRegex;
+
+	// Hours
+	proto$1.isPM = localeIsPM;
+	proto$1.meridiem = localeMeridiem;
+
+	function get$1 (format, index, field, setter) {
+	    var locale = getLocale();
+	    var utc = createUTC().set(setter, index);
+	    return locale[field](utc, format);
+	}
+
+	function listMonthsImpl (format, index, field) {
+	    if (isNumber(format)) {
+	        index = format;
+	        format = undefined;
+	    }
+
+	    format = format || '';
+
+	    if (index != null) {
+	        return get$1(format, index, field, 'month');
+	    }
+
+	    var i;
+	    var out = [];
+	    for (i = 0; i < 12; i++) {
+	        out[i] = get$1(format, i, field, 'month');
+	    }
+	    return out;
+	}
+
+	// ()
+	// (5)
+	// (fmt, 5)
+	// (fmt)
+	// (true)
+	// (true, 5)
+	// (true, fmt, 5)
+	// (true, fmt)
+	function listWeekdaysImpl (localeSorted, format, index, field) {
+	    if (typeof localeSorted === 'boolean') {
+	        if (isNumber(format)) {
+	            index = format;
+	            format = undefined;
+	        }
+
+	        format = format || '';
+	    } else {
+	        format = localeSorted;
+	        index = format;
+	        localeSorted = false;
+
+	        if (isNumber(format)) {
+	            index = format;
+	            format = undefined;
+	        }
+
+	        format = format || '';
+	    }
+
+	    var locale = getLocale(),
+	        shift = localeSorted ? locale._week.dow : 0;
+
+	    if (index != null) {
+	        return get$1(format, (index + shift) % 7, field, 'day');
+	    }
+
+	    var i;
+	    var out = [];
+	    for (i = 0; i < 7; i++) {
+	        out[i] = get$1(format, (i + shift) % 7, field, 'day');
+	    }
+	    return out;
+	}
+
+	function listMonths (format, index) {
+	    return listMonthsImpl(format, index, 'months');
+	}
+
+	function listMonthsShort (format, index) {
+	    return listMonthsImpl(format, index, 'monthsShort');
+	}
+
+	function listWeekdays (localeSorted, format, index) {
+	    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
+	}
+
+	function listWeekdaysShort (localeSorted, format, index) {
+	    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
+	}
+
+	function listWeekdaysMin (localeSorted, format, index) {
+	    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
+	}
+
+	getSetGlobalLocale('en', {
+	    dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (toInt(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    }
+	});
+
+	// Side effect imports
+	hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
+	hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
+
+	var mathAbs = Math.abs;
+
+	function abs () {
+	    var data           = this._data;
+
+	    this._milliseconds = mathAbs(this._milliseconds);
+	    this._days         = mathAbs(this._days);
+	    this._months       = mathAbs(this._months);
+
+	    data.milliseconds  = mathAbs(data.milliseconds);
+	    data.seconds       = mathAbs(data.seconds);
+	    data.minutes       = mathAbs(data.minutes);
+	    data.hours         = mathAbs(data.hours);
+	    data.months        = mathAbs(data.months);
+	    data.years         = mathAbs(data.years);
+
+	    return this;
+	}
+
+	function addSubtract$1 (duration, input, value, direction) {
+	    var other = createDuration(input, value);
+
+	    duration._milliseconds += direction * other._milliseconds;
+	    duration._days         += direction * other._days;
+	    duration._months       += direction * other._months;
+
+	    return duration._bubble();
+	}
+
+	// supports only 2.0-style add(1, 's') or add(duration)
+	function add$1 (input, value) {
+	    return addSubtract$1(this, input, value, 1);
+	}
+
+	// supports only 2.0-style subtract(1, 's') or subtract(duration)
+	function subtract$1 (input, value) {
+	    return addSubtract$1(this, input, value, -1);
+	}
+
+	function absCeil (number) {
+	    if (number < 0) {
+	        return Math.floor(number);
+	    } else {
+	        return Math.ceil(number);
+	    }
+	}
+
+	function bubble () {
+	    var milliseconds = this._milliseconds;
+	    var days         = this._days;
+	    var months       = this._months;
+	    var data         = this._data;
+	    var seconds, minutes, hours, years, monthsFromDays;
+
+	    // if we have a mix of positive and negative values, bubble down first
+	    // check: https://github.com/moment/moment/issues/2166
+	    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
+	            (milliseconds <= 0 && days <= 0 && months <= 0))) {
+	        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
+	        days = 0;
+	        months = 0;
+	    }
+
+	    // The following code bubbles up values, see the tests for
+	    // examples of what that means.
+	    data.milliseconds = milliseconds % 1000;
+
+	    seconds           = absFloor(milliseconds / 1000);
+	    data.seconds      = seconds % 60;
+
+	    minutes           = absFloor(seconds / 60);
+	    data.minutes      = minutes % 60;
+
+	    hours             = absFloor(minutes / 60);
+	    data.hours        = hours % 24;
+
+	    days += absFloor(hours / 24);
+
+	    // convert days to months
+	    monthsFromDays = absFloor(daysToMonths(days));
+	    months += monthsFromDays;
+	    days -= absCeil(monthsToDays(monthsFromDays));
+
+	    // 12 months -> 1 year
+	    years = absFloor(months / 12);
+	    months %= 12;
+
+	    data.days   = days;
+	    data.months = months;
+	    data.years  = years;
+
+	    return this;
+	}
+
+	function daysToMonths (days) {
+	    // 400 years have 146097 days (taking into account leap year rules)
+	    // 400 years have 12 months === 4800
+	    return days * 4800 / 146097;
+	}
+
+	function monthsToDays (months) {
+	    // the reverse of daysToMonths
+	    return months * 146097 / 4800;
+	}
+
+	function as (units) {
+	    if (!this.isValid()) {
+	        return NaN;
+	    }
+	    var days;
+	    var months;
+	    var milliseconds = this._milliseconds;
+
+	    units = normalizeUnits(units);
+
+	    if (units === 'month' || units === 'year') {
+	        days   = this._days   + milliseconds / 864e5;
+	        months = this._months + daysToMonths(days);
+	        return units === 'month' ? months : months / 12;
+	    } else {
+	        // handle milliseconds separately because of floating point math errors (issue #1867)
+	        days = this._days + Math.round(monthsToDays(this._months));
+	        switch (units) {
+	            case 'week'   : return days / 7     + milliseconds / 6048e5;
+	            case 'day'    : return days         + milliseconds / 864e5;
+	            case 'hour'   : return days * 24    + milliseconds / 36e5;
+	            case 'minute' : return days * 1440  + milliseconds / 6e4;
+	            case 'second' : return days * 86400 + milliseconds / 1000;
+	            // Math.floor prevents floating point math errors here
+	            case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
+	            default: throw new Error('Unknown unit ' + units);
+	        }
+	    }
+	}
+
+	// TODO: Use this.as('ms')?
+	function valueOf$1 () {
+	    if (!this.isValid()) {
+	        return NaN;
+	    }
+	    return (
+	        this._milliseconds +
+	        this._days * 864e5 +
+	        (this._months % 12) * 2592e6 +
+	        toInt(this._months / 12) * 31536e6
+	    );
+	}
+
+	function makeAs (alias) {
+	    return function () {
+	        return this.as(alias);
+	    };
+	}
+
+	var asMilliseconds = makeAs('ms');
+	var asSeconds      = makeAs('s');
+	var asMinutes      = makeAs('m');
+	var asHours        = makeAs('h');
+	var asDays         = makeAs('d');
+	var asWeeks        = makeAs('w');
+	var asMonths       = makeAs('M');
+	var asYears        = makeAs('y');
+
+	function get$2 (units) {
+	    units = normalizeUnits(units);
+	    return this.isValid() ? this[units + 's']() : NaN;
+	}
+
+	function makeGetter(name) {
+	    return function () {
+	        return this.isValid() ? this._data[name] : NaN;
+	    };
+	}
+
+	var milliseconds = makeGetter('milliseconds');
+	var seconds      = makeGetter('seconds');
+	var minutes      = makeGetter('minutes');
+	var hours        = makeGetter('hours');
+	var days         = makeGetter('days');
+	var months       = makeGetter('months');
+	var years        = makeGetter('years');
+
+	function weeks () {
+	    return absFloor(this.days() / 7);
+	}
+
+	var round = Math.round;
+	var thresholds = {
+	    ss: 44,         // a few seconds to seconds
+	    s : 45,         // seconds to minute
+	    m : 45,         // minutes to hour
+	    h : 22,         // hours to day
+	    d : 26,         // days to month
+	    M : 11          // months to year
+	};
+
+	// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+	function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
+	    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+	}
+
+	function relativeTime$1 (posNegDuration, withoutSuffix, locale) {
+	    var duration = createDuration(posNegDuration).abs();
+	    var seconds  = round(duration.as('s'));
+	    var minutes  = round(duration.as('m'));
+	    var hours    = round(duration.as('h'));
+	    var days     = round(duration.as('d'));
+	    var months   = round(duration.as('M'));
+	    var years    = round(duration.as('y'));
+
+	    var a = seconds <= thresholds.ss && ['s', seconds]  ||
+	            seconds < thresholds.s   && ['ss', seconds] ||
+	            minutes <= 1             && ['m']           ||
+	            minutes < thresholds.m   && ['mm', minutes] ||
+	            hours   <= 1             && ['h']           ||
+	            hours   < thresholds.h   && ['hh', hours]   ||
+	            days    <= 1             && ['d']           ||
+	            days    < thresholds.d   && ['dd', days]    ||
+	            months  <= 1             && ['M']           ||
+	            months  < thresholds.M   && ['MM', months]  ||
+	            years   <= 1             && ['y']           || ['yy', years];
+
+	    a[2] = withoutSuffix;
+	    a[3] = +posNegDuration > 0;
+	    a[4] = locale;
+	    return substituteTimeAgo.apply(null, a);
+	}
+
+	// This function allows you to set the rounding function for relative time strings
+	function getSetRelativeTimeRounding (roundingFunction) {
+	    if (roundingFunction === undefined) {
+	        return round;
+	    }
+	    if (typeof(roundingFunction) === 'function') {
+	        round = roundingFunction;
+	        return true;
+	    }
+	    return false;
+	}
+
+	// This function allows you to set a threshold for relative time strings
+	function getSetRelativeTimeThreshold (threshold, limit) {
+	    if (thresholds[threshold] === undefined) {
+	        return false;
+	    }
+	    if (limit === undefined) {
+	        return thresholds[threshold];
+	    }
+	    thresholds[threshold] = limit;
+	    if (threshold === 's') {
+	        thresholds.ss = limit - 1;
+	    }
+	    return true;
+	}
+
+	function humanize (withSuffix) {
+	    if (!this.isValid()) {
+	        return this.localeData().invalidDate();
+	    }
+
+	    var locale = this.localeData();
+	    var output = relativeTime$1(this, !withSuffix, locale);
+
+	    if (withSuffix) {
+	        output = locale.pastFuture(+this, output);
+	    }
+
+	    return locale.postformat(output);
+	}
+
+	var abs$1 = Math.abs;
+
+	function toISOString$1() {
+	    // for ISO strings we do not use the normal bubbling rules:
+	    //  * milliseconds bubble up until they become hours
+	    //  * days do not bubble at all
+	    //  * months bubble up until they become years
+	    // This is because there is no context-free conversion between hours and days
+	    // (think of clock changes)
+	    // and also not between days and months (28-31 days per month)
+	    if (!this.isValid()) {
+	        return this.localeData().invalidDate();
+	    }
+
+	    var seconds = abs$1(this._milliseconds) / 1000;
+	    var days         = abs$1(this._days);
+	    var months       = abs$1(this._months);
+	    var minutes, hours, years;
+
+	    // 3600 seconds -> 60 minutes -> 1 hour
+	    minutes           = absFloor(seconds / 60);
+	    hours             = absFloor(minutes / 60);
+	    seconds %= 60;
+	    minutes %= 60;
+
+	    // 12 months -> 1 year
+	    years  = absFloor(months / 12);
+	    months %= 12;
+
+
+	    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+	    var Y = years;
+	    var M = months;
+	    var D = days;
+	    var h = hours;
+	    var m = minutes;
+	    var s = seconds;
+	    var total = this.asSeconds();
+
+	    if (!total) {
+	        // this is the same as C#'s (Noda) and python (isodate)...
+	        // but not other JS (goog.date)
+	        return 'P0D';
+	    }
+
+	    return (total < 0 ? '-' : '') +
+	        'P' +
+	        (Y ? Y + 'Y' : '') +
+	        (M ? M + 'M' : '') +
+	        (D ? D + 'D' : '') +
+	        ((h || m || s) ? 'T' : '') +
+	        (h ? h + 'H' : '') +
+	        (m ? m + 'M' : '') +
+	        (s ? s + 'S' : '');
+	}
+
+	var proto$2 = Duration.prototype;
+
+	proto$2.isValid        = isValid$1;
+	proto$2.abs            = abs;
+	proto$2.add            = add$1;
+	proto$2.subtract       = subtract$1;
+	proto$2.as             = as;
+	proto$2.asMilliseconds = asMilliseconds;
+	proto$2.asSeconds      = asSeconds;
+	proto$2.asMinutes      = asMinutes;
+	proto$2.asHours        = asHours;
+	proto$2.asDays         = asDays;
+	proto$2.asWeeks        = asWeeks;
+	proto$2.asMonths       = asMonths;
+	proto$2.asYears        = asYears;
+	proto$2.valueOf        = valueOf$1;
+	proto$2._bubble        = bubble;
+	proto$2.get            = get$2;
+	proto$2.milliseconds   = milliseconds;
+	proto$2.seconds        = seconds;
+	proto$2.minutes        = minutes;
+	proto$2.hours          = hours;
+	proto$2.days           = days;
+	proto$2.weeks          = weeks;
+	proto$2.months         = months;
+	proto$2.years          = years;
+	proto$2.humanize       = humanize;
+	proto$2.toISOString    = toISOString$1;
+	proto$2.toString       = toISOString$1;
+	proto$2.toJSON         = toISOString$1;
+	proto$2.locale         = locale;
+	proto$2.localeData     = localeData;
+
+	// Deprecations
+	proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
+	proto$2.lang = lang;
+
+	// Side effect imports
+
+	// FORMATTING
+
+	addFormatToken('X', 0, 0, 'unix');
+	addFormatToken('x', 0, 0, 'valueOf');
+
+	// PARSING
+
+	addRegexToken('x', matchSigned);
+	addRegexToken('X', matchTimestamp);
+	addParseToken('X', function (input, array, config) {
+	    config._d = new Date(parseFloat(input, 10) * 1000);
+	});
+	addParseToken('x', function (input, array, config) {
+	    config._d = new Date(toInt(input));
+	});
+
+	// Side effect imports
+
+
+	hooks.version = '2.18.1';
+
+	setHookCallback(createLocal);
+
+	hooks.fn                    = proto;
+	hooks.min                   = min;
+	hooks.max                   = max;
+	hooks.now                   = now;
+	hooks.utc                   = createUTC;
+	hooks.unix                  = createUnix;
+	hooks.months                = listMonths;
+	hooks.isDate                = isDate;
+	hooks.locale                = getSetGlobalLocale;
+	hooks.invalid               = createInvalid;
+	hooks.duration              = createDuration;
+	hooks.isMoment              = isMoment;
+	hooks.weekdays              = listWeekdays;
+	hooks.parseZone             = createInZone;
+	hooks.localeData            = getLocale;
+	hooks.isDuration            = isDuration;
+	hooks.monthsShort           = listMonthsShort;
+	hooks.weekdaysMin           = listWeekdaysMin;
+	hooks.defineLocale          = defineLocale;
+	hooks.updateLocale          = updateLocale;
+	hooks.locales               = listLocales;
+	hooks.weekdaysShort         = listWeekdaysShort;
+	hooks.normalizeUnits        = normalizeUnits;
+	hooks.relativeTimeRounding = getSetRelativeTimeRounding;
+	hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
+	hooks.calendarFormat        = getCalendarFormat;
+	hooks.prototype             = proto;
+
+	return hooks;
+
+	})));
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(44)(module)))
+
+/***/ },
+/* 44 */
+/***/ function(module, exports) {
+
+	module.exports = function(module) {
+		if(!module.webpackPolyfill) {
+			module.deprecate = function() {};
+			module.paths = [];
+			// module.parent = undefined by default
+			module.children = [];
+			module.webpackPolyfill = 1;
+		}
+		return module;
+	}
+
+
+/***/ },
+/* 45 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var map = {
+		"./af": 46,
+		"./af.js": 46,
+		"./ar": 47,
+		"./ar-dz": 48,
+		"./ar-dz.js": 48,
+		"./ar-kw": 49,
+		"./ar-kw.js": 49,
+		"./ar-ly": 50,
+		"./ar-ly.js": 50,
+		"./ar-ma": 51,
+		"./ar-ma.js": 51,
+		"./ar-sa": 52,
+		"./ar-sa.js": 52,
+		"./ar-tn": 53,
+		"./ar-tn.js": 53,
+		"./ar.js": 47,
+		"./az": 54,
+		"./az.js": 54,
+		"./be": 55,
+		"./be.js": 55,
+		"./bg": 56,
+		"./bg.js": 56,
+		"./bn": 57,
+		"./bn.js": 57,
+		"./bo": 58,
+		"./bo.js": 58,
+		"./br": 59,
+		"./br.js": 59,
+		"./bs": 60,
+		"./bs.js": 60,
+		"./ca": 61,
+		"./ca.js": 61,
+		"./cs": 62,
+		"./cs.js": 62,
+		"./cv": 63,
+		"./cv.js": 63,
+		"./cy": 64,
+		"./cy.js": 64,
+		"./da": 65,
+		"./da.js": 65,
+		"./de": 66,
+		"./de-at": 67,
+		"./de-at.js": 67,
+		"./de-ch": 68,
+		"./de-ch.js": 68,
+		"./de.js": 66,
+		"./dv": 69,
+		"./dv.js": 69,
+		"./el": 70,
+		"./el.js": 70,
+		"./en-au": 71,
+		"./en-au.js": 71,
+		"./en-ca": 72,
+		"./en-ca.js": 72,
+		"./en-gb": 73,
+		"./en-gb.js": 73,
+		"./en-ie": 74,
+		"./en-ie.js": 74,
+		"./en-nz": 75,
+		"./en-nz.js": 75,
+		"./eo": 76,
+		"./eo.js": 76,
+		"./es": 77,
+		"./es-do": 78,
+		"./es-do.js": 78,
+		"./es.js": 77,
+		"./et": 79,
+		"./et.js": 79,
+		"./eu": 80,
+		"./eu.js": 80,
+		"./fa": 81,
+		"./fa.js": 81,
+		"./fi": 82,
+		"./fi.js": 82,
+		"./fo": 83,
+		"./fo.js": 83,
+		"./fr": 84,
+		"./fr-ca": 85,
+		"./fr-ca.js": 85,
+		"./fr-ch": 86,
+		"./fr-ch.js": 86,
+		"./fr.js": 84,
+		"./fy": 87,
+		"./fy.js": 87,
+		"./gd": 88,
+		"./gd.js": 88,
+		"./gl": 89,
+		"./gl.js": 89,
+		"./gom-latn": 90,
+		"./gom-latn.js": 90,
+		"./he": 91,
+		"./he.js": 91,
+		"./hi": 92,
+		"./hi.js": 92,
+		"./hr": 93,
+		"./hr.js": 93,
+		"./hu": 94,
+		"./hu.js": 94,
+		"./hy-am": 95,
+		"./hy-am.js": 95,
+		"./id": 96,
+		"./id.js": 96,
+		"./is": 97,
+		"./is.js": 97,
+		"./it": 98,
+		"./it.js": 98,
+		"./ja": 99,
+		"./ja.js": 99,
+		"./jv": 100,
+		"./jv.js": 100,
+		"./ka": 101,
+		"./ka.js": 101,
+		"./kk": 102,
+		"./kk.js": 102,
+		"./km": 103,
+		"./km.js": 103,
+		"./kn": 104,
+		"./kn.js": 104,
+		"./ko": 105,
+		"./ko.js": 105,
+		"./ky": 106,
+		"./ky.js": 106,
+		"./lb": 107,
+		"./lb.js": 107,
+		"./lo": 108,
+		"./lo.js": 108,
+		"./lt": 109,
+		"./lt.js": 109,
+		"./lv": 110,
+		"./lv.js": 110,
+		"./me": 111,
+		"./me.js": 111,
+		"./mi": 112,
+		"./mi.js": 112,
+		"./mk": 113,
+		"./mk.js": 113,
+		"./ml": 114,
+		"./ml.js": 114,
+		"./mr": 115,
+		"./mr.js": 115,
+		"./ms": 116,
+		"./ms-my": 117,
+		"./ms-my.js": 117,
+		"./ms.js": 116,
+		"./my": 118,
+		"./my.js": 118,
+		"./nb": 119,
+		"./nb.js": 119,
+		"./ne": 120,
+		"./ne.js": 120,
+		"./nl": 121,
+		"./nl-be": 122,
+		"./nl-be.js": 122,
+		"./nl.js": 121,
+		"./nn": 123,
+		"./nn.js": 123,
+		"./pa-in": 124,
+		"./pa-in.js": 124,
+		"./pl": 125,
+		"./pl.js": 125,
+		"./pt": 126,
+		"./pt-br": 127,
+		"./pt-br.js": 127,
+		"./pt.js": 126,
+		"./ro": 128,
+		"./ro.js": 128,
+		"./ru": 129,
+		"./ru.js": 129,
+		"./sd": 130,
+		"./sd.js": 130,
+		"./se": 131,
+		"./se.js": 131,
+		"./si": 132,
+		"./si.js": 132,
+		"./sk": 133,
+		"./sk.js": 133,
+		"./sl": 134,
+		"./sl.js": 134,
+		"./sq": 135,
+		"./sq.js": 135,
+		"./sr": 136,
+		"./sr-cyrl": 137,
+		"./sr-cyrl.js": 137,
+		"./sr.js": 136,
+		"./ss": 138,
+		"./ss.js": 138,
+		"./sv": 139,
+		"./sv.js": 139,
+		"./sw": 140,
+		"./sw.js": 140,
+		"./ta": 141,
+		"./ta.js": 141,
+		"./te": 142,
+		"./te.js": 142,
+		"./tet": 143,
+		"./tet.js": 143,
+		"./th": 144,
+		"./th.js": 144,
+		"./tl-ph": 145,
+		"./tl-ph.js": 145,
+		"./tlh": 146,
+		"./tlh.js": 146,
+		"./tr": 147,
+		"./tr.js": 147,
+		"./tzl": 148,
+		"./tzl.js": 148,
+		"./tzm": 149,
+		"./tzm-latn": 150,
+		"./tzm-latn.js": 150,
+		"./tzm.js": 149,
+		"./uk": 151,
+		"./uk.js": 151,
+		"./ur": 152,
+		"./ur.js": 152,
+		"./uz": 153,
+		"./uz-latn": 154,
+		"./uz-latn.js": 154,
+		"./uz.js": 153,
+		"./vi": 155,
+		"./vi.js": 155,
+		"./x-pseudo": 156,
+		"./x-pseudo.js": 156,
+		"./yo": 157,
+		"./yo.js": 157,
+		"./zh-cn": 158,
+		"./zh-cn.js": 158,
+		"./zh-hk": 159,
+		"./zh-hk.js": 159,
+		"./zh-tw": 160,
+		"./zh-tw.js": 160
+	};
+	function webpackContext(req) {
+		return __webpack_require__(webpackContextResolve(req));
+	};
+	function webpackContextResolve(req) {
+		return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
+	};
+	webpackContext.keys = function webpackContextKeys() {
+		return Object.keys(map);
+	};
+	webpackContext.resolve = webpackContextResolve;
+	module.exports = webpackContext;
+	webpackContext.id = 45;
+
+
+/***/ },
+/* 46 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Afrikaans [af]
+	//! author : Werner Mollentze : https://github.com/wernerm
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var af = moment.defineLocale('af', {
+	    months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
+	    monthsShort : 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
+	    weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
+	    weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
+	    weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
+	    meridiemParse: /vm|nm/i,
+	    isPM : function (input) {
+	        return /^nm$/i.test(input);
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 12) {
+	            return isLower ? 'vm' : 'VM';
+	        } else {
+	            return isLower ? 'nm' : 'NM';
+	        }
+	    },
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Vandag om] LT',
+	        nextDay : '[Môre om] LT',
+	        nextWeek : 'dddd [om] LT',
+	        lastDay : '[Gister om] LT',
+	        lastWeek : '[Laas] dddd [om] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'oor %s',
+	        past : '%s gelede',
+	        s : '\'n paar sekondes',
+	        m : '\'n minuut',
+	        mm : '%d minute',
+	        h : '\'n uur',
+	        hh : '%d ure',
+	        d : '\'n dag',
+	        dd : '%d dae',
+	        M : '\'n maand',
+	        MM : '%d maande',
+	        y : '\'n jaar',
+	        yy : '%d jaar'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+	    ordinal : function (number) {
+	        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
+	    },
+	    week : {
+	        dow : 1, // Maandag is die eerste dag van die week.
+	        doy : 4  // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
+	    }
+	});
+
+	return af;
+
+	})));
+
+
+/***/ },
+/* 47 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Arabic [ar]
+	//! author : Abdel Said: https://github.com/abdelsaid
+	//! author : Ahmed Elkhatib
+	//! author : forabi https://github.com/forabi
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '١',
+	    '2': '٢',
+	    '3': '٣',
+	    '4': '٤',
+	    '5': '٥',
+	    '6': '٦',
+	    '7': '٧',
+	    '8': '٨',
+	    '9': '٩',
+	    '0': '٠'
+	};
+	var numberMap = {
+	    '١': '1',
+	    '٢': '2',
+	    '٣': '3',
+	    '٤': '4',
+	    '٥': '5',
+	    '٦': '6',
+	    '٧': '7',
+	    '٨': '8',
+	    '٩': '9',
+	    '٠': '0'
+	};
+	var pluralForm = function (n) {
+	    return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
+	};
+	var plurals = {
+	    s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
+	    m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
+	    h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
+	    d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
+	    M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
+	    y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
+	};
+	var pluralize = function (u) {
+	    return function (number, withoutSuffix, string, isFuture) {
+	        var f = pluralForm(number),
+	            str = plurals[u][pluralForm(number)];
+	        if (f === 2) {
+	            str = str[withoutSuffix ? 0 : 1];
+	        }
+	        return str.replace(/%d/i, number);
+	    };
+	};
+	var months = [
+	    'كانون الثاني يناير',
+	    'شباط فبراير',
+	    'آذار مارس',
+	    'نيسان أبريل',
+	    'أيار مايو',
+	    'حزيران يونيو',
+	    'تموز يوليو',
+	    'آب أغسطس',
+	    'أيلول سبتمبر',
+	    'تشرين الأول أكتوبر',
+	    'تشرين الثاني نوفمبر',
+	    'كانون الأول ديسمبر'
+	];
+
+	var ar = moment.defineLocale('ar', {
+	    months : months,
+	    monthsShort : months,
+	    weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+	    weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+	    weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'D/\u200FM/\u200FYYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /ص|م/,
+	    isPM : function (input) {
+	        return 'م' === input;
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'ص';
+	        } else {
+	            return 'م';
+	        }
+	    },
+	    calendar : {
+	        sameDay: '[اليوم عند الساعة] LT',
+	        nextDay: '[غدًا عند الساعة] LT',
+	        nextWeek: 'dddd [عند الساعة] LT',
+	        lastDay: '[أمس عند الساعة] LT',
+	        lastWeek: 'dddd [عند الساعة] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'بعد %s',
+	        past : 'منذ %s',
+	        s : pluralize('s'),
+	        m : pluralize('m'),
+	        mm : pluralize('m'),
+	        h : pluralize('h'),
+	        hh : pluralize('h'),
+	        d : pluralize('d'),
+	        dd : pluralize('d'),
+	        M : pluralize('M'),
+	        MM : pluralize('M'),
+	        y : pluralize('y'),
+	        yy : pluralize('y')
+	    },
+	    preparse: function (string) {
+	        return string.replace(/\u200f/g, '').replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
+	            return numberMap[match];
+	        }).replace(/،/g, ',');
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        }).replace(/,/g, '،');
+	    },
+	    week : {
+	        dow : 6, // Saturday is the first day of the week.
+	        doy : 12  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return ar;
+
+	})));
+
+
+/***/ },
+/* 48 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Arabic (Algeria) [ar-dz]
+	//! author : Noureddine LOUAHEDJ : https://github.com/noureddineme
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var arDz = moment.defineLocale('ar-dz', {
+	    months : 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
+	    monthsShort : 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
+	    weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+	    weekdaysShort : 'احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
+	    weekdaysMin : 'أح_إث_ثلا_أر_خم_جم_سب'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[اليوم على الساعة] LT',
+	        nextDay: '[غدا على الساعة] LT',
+	        nextWeek: 'dddd [على الساعة] LT',
+	        lastDay: '[أمس على الساعة] LT',
+	        lastWeek: 'dddd [على الساعة] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'في %s',
+	        past : 'منذ %s',
+	        s : 'ثوان',
+	        m : 'دقيقة',
+	        mm : '%d دقائق',
+	        h : 'ساعة',
+	        hh : '%d ساعات',
+	        d : 'يوم',
+	        dd : '%d أيام',
+	        M : 'شهر',
+	        MM : '%d أشهر',
+	        y : 'سنة',
+	        yy : '%d سنوات'
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 4  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return arDz;
+
+	})));
+
+
+/***/ },
+/* 49 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Arabic (Kuwait) [ar-kw]
+	//! author : Nusret Parlak: https://github.com/nusretparlak
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var arKw = moment.defineLocale('ar-kw', {
+	    months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
+	    monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
+	    weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+	    weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
+	    weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[اليوم على الساعة] LT',
+	        nextDay: '[غدا على الساعة] LT',
+	        nextWeek: 'dddd [على الساعة] LT',
+	        lastDay: '[أمس على الساعة] LT',
+	        lastWeek: 'dddd [على الساعة] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'في %s',
+	        past : 'منذ %s',
+	        s : 'ثوان',
+	        m : 'دقيقة',
+	        mm : '%d دقائق',
+	        h : 'ساعة',
+	        hh : '%d ساعات',
+	        d : 'يوم',
+	        dd : '%d أيام',
+	        M : 'شهر',
+	        MM : '%d أشهر',
+	        y : 'سنة',
+	        yy : '%d سنوات'
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 12  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return arKw;
+
+	})));
+
+
+/***/ },
+/* 50 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Arabic (Lybia) [ar-ly]
+	//! author : Ali Hmer: https://github.com/kikoanis
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '1',
+	    '2': '2',
+	    '3': '3',
+	    '4': '4',
+	    '5': '5',
+	    '6': '6',
+	    '7': '7',
+	    '8': '8',
+	    '9': '9',
+	    '0': '0'
+	};
+	var pluralForm = function (n) {
+	    return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
+	};
+	var plurals = {
+	    s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
+	    m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
+	    h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
+	    d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
+	    M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
+	    y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
+	};
+	var pluralize = function (u) {
+	    return function (number, withoutSuffix, string, isFuture) {
+	        var f = pluralForm(number),
+	            str = plurals[u][pluralForm(number)];
+	        if (f === 2) {
+	            str = str[withoutSuffix ? 0 : 1];
+	        }
+	        return str.replace(/%d/i, number);
+	    };
+	};
+	var months = [
+	    'يناير',
+	    'فبراير',
+	    'مارس',
+	    'أبريل',
+	    'مايو',
+	    'يونيو',
+	    'يوليو',
+	    'أغسطس',
+	    'سبتمبر',
+	    'أكتوبر',
+	    'نوفمبر',
+	    'ديسمبر'
+	];
+
+	var arLy = moment.defineLocale('ar-ly', {
+	    months : months,
+	    monthsShort : months,
+	    weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+	    weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+	    weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'D/\u200FM/\u200FYYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /ص|م/,
+	    isPM : function (input) {
+	        return 'م' === input;
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'ص';
+	        } else {
+	            return 'م';
+	        }
+	    },
+	    calendar : {
+	        sameDay: '[اليوم عند الساعة] LT',
+	        nextDay: '[غدًا عند الساعة] LT',
+	        nextWeek: 'dddd [عند الساعة] LT',
+	        lastDay: '[أمس عند الساعة] LT',
+	        lastWeek: 'dddd [عند الساعة] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'بعد %s',
+	        past : 'منذ %s',
+	        s : pluralize('s'),
+	        m : pluralize('m'),
+	        mm : pluralize('m'),
+	        h : pluralize('h'),
+	        hh : pluralize('h'),
+	        d : pluralize('d'),
+	        dd : pluralize('d'),
+	        M : pluralize('M'),
+	        MM : pluralize('M'),
+	        y : pluralize('y'),
+	        yy : pluralize('y')
+	    },
+	    preparse: function (string) {
+	        return string.replace(/\u200f/g, '').replace(/،/g, ',');
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        }).replace(/,/g, '،');
+	    },
+	    week : {
+	        dow : 6, // Saturday is the first day of the week.
+	        doy : 12  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return arLy;
+
+	})));
+
+
+/***/ },
+/* 51 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Arabic (Morocco) [ar-ma]
+	//! author : ElFadili Yassine : https://github.com/ElFadiliY
+	//! author : Abdel Said : https://github.com/abdelsaid
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var arMa = moment.defineLocale('ar-ma', {
+	    months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
+	    monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
+	    weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+	    weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
+	    weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[اليوم على الساعة] LT',
+	        nextDay: '[غدا على الساعة] LT',
+	        nextWeek: 'dddd [على الساعة] LT',
+	        lastDay: '[أمس على الساعة] LT',
+	        lastWeek: 'dddd [على الساعة] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'في %s',
+	        past : 'منذ %s',
+	        s : 'ثوان',
+	        m : 'دقيقة',
+	        mm : '%d دقائق',
+	        h : 'ساعة',
+	        hh : '%d ساعات',
+	        d : 'يوم',
+	        dd : '%d أيام',
+	        M : 'شهر',
+	        MM : '%d أشهر',
+	        y : 'سنة',
+	        yy : '%d سنوات'
+	    },
+	    week : {
+	        dow : 6, // Saturday is the first day of the week.
+	        doy : 12  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return arMa;
+
+	})));
+
+
+/***/ },
+/* 52 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Arabic (Saudi Arabia) [ar-sa]
+	//! author : Suhail Alkowaileet : https://github.com/xsoh
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '١',
+	    '2': '٢',
+	    '3': '٣',
+	    '4': '٤',
+	    '5': '٥',
+	    '6': '٦',
+	    '7': '٧',
+	    '8': '٨',
+	    '9': '٩',
+	    '0': '٠'
+	};
+	var numberMap = {
+	    '١': '1',
+	    '٢': '2',
+	    '٣': '3',
+	    '٤': '4',
+	    '٥': '5',
+	    '٦': '6',
+	    '٧': '7',
+	    '٨': '8',
+	    '٩': '9',
+	    '٠': '0'
+	};
+
+	var arSa = moment.defineLocale('ar-sa', {
+	    months : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
+	    monthsShort : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
+	    weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+	    weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+	    weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /ص|م/,
+	    isPM : function (input) {
+	        return 'م' === input;
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'ص';
+	        } else {
+	            return 'م';
+	        }
+	    },
+	    calendar : {
+	        sameDay: '[اليوم على الساعة] LT',
+	        nextDay: '[غدا على الساعة] LT',
+	        nextWeek: 'dddd [على الساعة] LT',
+	        lastDay: '[أمس على الساعة] LT',
+	        lastWeek: 'dddd [على الساعة] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'في %s',
+	        past : 'منذ %s',
+	        s : 'ثوان',
+	        m : 'دقيقة',
+	        mm : '%d دقائق',
+	        h : 'ساعة',
+	        hh : '%d ساعات',
+	        d : 'يوم',
+	        dd : '%d أيام',
+	        M : 'شهر',
+	        MM : '%d أشهر',
+	        y : 'سنة',
+	        yy : '%d سنوات'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
+	            return numberMap[match];
+	        }).replace(/،/g, ',');
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        }).replace(/,/g, '،');
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return arSa;
+
+	})));
+
+
+/***/ },
+/* 53 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale  :  Arabic (Tunisia) [ar-tn]
+	//! author : Nader Toukabri : https://github.com/naderio
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var arTn = moment.defineLocale('ar-tn', {
+	    months: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
+	    monthsShort: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
+	    weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+	    weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+	    weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat: {
+	        LT: 'HH:mm',
+	        LTS: 'HH:mm:ss',
+	        L: 'DD/MM/YYYY',
+	        LL: 'D MMMM YYYY',
+	        LLL: 'D MMMM YYYY HH:mm',
+	        LLLL: 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar: {
+	        sameDay: '[اليوم على الساعة] LT',
+	        nextDay: '[غدا على الساعة] LT',
+	        nextWeek: 'dddd [على الساعة] LT',
+	        lastDay: '[أمس على الساعة] LT',
+	        lastWeek: 'dddd [على الساعة] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime: {
+	        future: 'في %s',
+	        past: 'منذ %s',
+	        s: 'ثوان',
+	        m: 'دقيقة',
+	        mm: '%d دقائق',
+	        h: 'ساعة',
+	        hh: '%d ساعات',
+	        d: 'يوم',
+	        dd: '%d أيام',
+	        M: 'شهر',
+	        MM: '%d أشهر',
+	        y: 'سنة',
+	        yy: '%d سنوات'
+	    },
+	    week: {
+	        dow: 1, // Monday is the first day of the week.
+	        doy: 4 // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return arTn;
+
+	})));
+
+
+/***/ },
+/* 54 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Azerbaijani [az]
+	//! author : topchiyev : https://github.com/topchiyev
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var suffixes = {
+	    1: '-inci',
+	    5: '-inci',
+	    8: '-inci',
+	    70: '-inci',
+	    80: '-inci',
+	    2: '-nci',
+	    7: '-nci',
+	    20: '-nci',
+	    50: '-nci',
+	    3: '-üncü',
+	    4: '-üncü',
+	    100: '-üncü',
+	    6: '-ncı',
+	    9: '-uncu',
+	    10: '-uncu',
+	    30: '-uncu',
+	    60: '-ıncı',
+	    90: '-ıncı'
+	};
+
+	var az = moment.defineLocale('az', {
+	    months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
+	    monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
+	    weekdays : 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
+	    weekdaysShort : 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
+	    weekdaysMin : 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[bugün saat] LT',
+	        nextDay : '[sabah saat] LT',
+	        nextWeek : '[gələn həftə] dddd [saat] LT',
+	        lastDay : '[dünən] LT',
+	        lastWeek : '[keçən həftə] dddd [saat] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s sonra',
+	        past : '%s əvvəl',
+	        s : 'birneçə saniyyə',
+	        m : 'bir dəqiqə',
+	        mm : '%d dəqiqə',
+	        h : 'bir saat',
+	        hh : '%d saat',
+	        d : 'bir gün',
+	        dd : '%d gün',
+	        M : 'bir ay',
+	        MM : '%d ay',
+	        y : 'bir il',
+	        yy : '%d il'
+	    },
+	    meridiemParse: /gecə|səhər|gündüz|axşam/,
+	    isPM : function (input) {
+	        return /^(gündüz|axşam)$/.test(input);
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'gecə';
+	        } else if (hour < 12) {
+	            return 'səhər';
+	        } else if (hour < 17) {
+	            return 'gündüz';
+	        } else {
+	            return 'axşam';
+	        }
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
+	    ordinal : function (number) {
+	        if (number === 0) {  // special case for zero
+	            return number + '-ıncı';
+	        }
+	        var a = number % 10,
+	            b = number % 100 - a,
+	            c = number >= 100 ? 100 : null;
+	        return number + (suffixes[a] || suffixes[b] || suffixes[c]);
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return az;
+
+	})));
+
+
+/***/ },
+/* 55 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Belarusian [be]
+	//! author : Dmitry Demidov : https://github.com/demidov91
+	//! author: Praleska: http://praleska.pro/
+	//! Author : Menelion Elensúle : https://github.com/Oire
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function plural(word, num) {
+	    var forms = word.split('_');
+	    return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
+	}
+	function relativeTimeWithPlural(number, withoutSuffix, key) {
+	    var format = {
+	        'mm': withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
+	        'hh': withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
+	        'dd': 'дзень_дні_дзён',
+	        'MM': 'месяц_месяцы_месяцаў',
+	        'yy': 'год_гады_гадоў'
+	    };
+	    if (key === 'm') {
+	        return withoutSuffix ? 'хвіліна' : 'хвіліну';
+	    }
+	    else if (key === 'h') {
+	        return withoutSuffix ? 'гадзіна' : 'гадзіну';
+	    }
+	    else {
+	        return number + ' ' + plural(format[key], +number);
+	    }
+	}
+
+	var be = moment.defineLocale('be', {
+	    months : {
+	        format: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_'),
+	        standalone: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_')
+	    },
+	    monthsShort : 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split('_'),
+	    weekdays : {
+	        format: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_'),
+	        standalone: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
+	        isFormat: /\[ ?[Вв] ?(?:мінулую|наступную)? ?\] ?dddd/
+	    },
+	    weekdaysShort : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
+	    weekdaysMin : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY г.',
+	        LLL : 'D MMMM YYYY г., HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY г., HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Сёння ў] LT',
+	        nextDay: '[Заўтра ў] LT',
+	        lastDay: '[Учора ў] LT',
+	        nextWeek: function () {
+	            return '[У] dddd [ў] LT';
+	        },
+	        lastWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                case 3:
+	                case 5:
+	                case 6:
+	                    return '[У мінулую] dddd [ў] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                    return '[У мінулы] dddd [ў] LT';
+	            }
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'праз %s',
+	        past : '%s таму',
+	        s : 'некалькі секунд',
+	        m : relativeTimeWithPlural,
+	        mm : relativeTimeWithPlural,
+	        h : relativeTimeWithPlural,
+	        hh : relativeTimeWithPlural,
+	        d : 'дзень',
+	        dd : relativeTimeWithPlural,
+	        M : 'месяц',
+	        MM : relativeTimeWithPlural,
+	        y : 'год',
+	        yy : relativeTimeWithPlural
+	    },
+	    meridiemParse: /ночы|раніцы|дня|вечара/,
+	    isPM : function (input) {
+	        return /^(дня|вечара)$/.test(input);
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'ночы';
+	        } else if (hour < 12) {
+	            return 'раніцы';
+	        } else if (hour < 17) {
+	            return 'дня';
+	        } else {
+	            return 'вечара';
+	        }
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(і|ы|га)/,
+	    ordinal: function (number, period) {
+	        switch (period) {
+	            case 'M':
+	            case 'd':
+	            case 'DDD':
+	            case 'w':
+	            case 'W':
+	                return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-і' : number + '-ы';
+	            case 'D':
+	                return number + '-га';
+	            default:
+	                return number;
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return be;
+
+	})));
+
+
+/***/ },
+/* 56 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Bulgarian [bg]
+	//! author : Krasen Borisov : https://github.com/kraz
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var bg = moment.defineLocale('bg', {
+	    months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
+	    monthsShort : 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
+	    weekdays : 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
+	    weekdaysShort : 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
+	    weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'D.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY H:mm',
+	        LLLL : 'dddd, D MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Днес в] LT',
+	        nextDay : '[Утре в] LT',
+	        nextWeek : 'dddd [в] LT',
+	        lastDay : '[Вчера в] LT',
+	        lastWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                case 3:
+	                case 6:
+	                    return '[В изминалата] dddd [в] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[В изминалия] dddd [в] LT';
+	            }
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'след %s',
+	        past : 'преди %s',
+	        s : 'няколко секунди',
+	        m : 'минута',
+	        mm : '%d минути',
+	        h : 'час',
+	        hh : '%d часа',
+	        d : 'ден',
+	        dd : '%d дни',
+	        M : 'месец',
+	        MM : '%d месеца',
+	        y : 'година',
+	        yy : '%d години'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
+	    ordinal : function (number) {
+	        var lastDigit = number % 10,
+	            last2Digits = number % 100;
+	        if (number === 0) {
+	            return number + '-ев';
+	        } else if (last2Digits === 0) {
+	            return number + '-ен';
+	        } else if (last2Digits > 10 && last2Digits < 20) {
+	            return number + '-ти';
+	        } else if (lastDigit === 1) {
+	            return number + '-ви';
+	        } else if (lastDigit === 2) {
+	            return number + '-ри';
+	        } else if (lastDigit === 7 || lastDigit === 8) {
+	            return number + '-ми';
+	        } else {
+	            return number + '-ти';
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return bg;
+
+	})));
+
+
+/***/ },
+/* 57 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Bengali [bn]
+	//! author : Kaushik Gandhi : https://github.com/kaushikgandhi
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '১',
+	    '2': '২',
+	    '3': '৩',
+	    '4': '৪',
+	    '5': '৫',
+	    '6': '৬',
+	    '7': '৭',
+	    '8': '৮',
+	    '9': '৯',
+	    '0': '০'
+	};
+	var numberMap = {
+	    '১': '1',
+	    '২': '2',
+	    '৩': '3',
+	    '৪': '4',
+	    '৫': '5',
+	    '৬': '6',
+	    '৭': '7',
+	    '৮': '8',
+	    '৯': '9',
+	    '০': '0'
+	};
+
+	var bn = moment.defineLocale('bn', {
+	    months : 'জানুয়ারী_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split('_'),
+	    monthsShort : 'জানু_ফেব_মার্চ_এপ্র_মে_জুন_জুল_আগ_সেপ্ট_অক্টো_নভে_ডিসে'.split('_'),
+	    weekdays : 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split('_'),
+	    weekdaysShort : 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
+	    weekdaysMin : 'রবি_সোম_মঙ্গ_বুধ_বৃহঃ_শুক্র_শনি'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm সময়',
+	        LTS : 'A h:mm:ss সময়',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm সময়',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm সময়'
+	    },
+	    calendar : {
+	        sameDay : '[আজ] LT',
+	        nextDay : '[আগামীকাল] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[গতকাল] LT',
+	        lastWeek : '[গত] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s পরে',
+	        past : '%s আগে',
+	        s : 'কয়েক সেকেন্ড',
+	        m : 'এক মিনিট',
+	        mm : '%d মিনিট',
+	        h : 'এক ঘন্টা',
+	        hh : '%d ঘন্টা',
+	        d : 'এক দিন',
+	        dd : '%d দিন',
+	        M : 'এক মাস',
+	        MM : '%d মাস',
+	        y : 'এক বছর',
+	        yy : '%d বছর'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    meridiemParse: /রাত|সকাল|দুপুর|বিকাল|রাত/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if ((meridiem === 'রাত' && hour >= 4) ||
+	                (meridiem === 'দুপুর' && hour < 5) ||
+	                meridiem === 'বিকাল') {
+	            return hour + 12;
+	        } else {
+	            return hour;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'রাত';
+	        } else if (hour < 10) {
+	            return 'সকাল';
+	        } else if (hour < 17) {
+	            return 'দুপুর';
+	        } else if (hour < 20) {
+	            return 'বিকাল';
+	        } else {
+	            return 'রাত';
+	        }
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return bn;
+
+	})));
+
+
+/***/ },
+/* 58 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Tibetan [bo]
+	//! author : Thupten N. Chakrishar : https://github.com/vajradog
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '༡',
+	    '2': '༢',
+	    '3': '༣',
+	    '4': '༤',
+	    '5': '༥',
+	    '6': '༦',
+	    '7': '༧',
+	    '8': '༨',
+	    '9': '༩',
+	    '0': '༠'
+	};
+	var numberMap = {
+	    '༡': '1',
+	    '༢': '2',
+	    '༣': '3',
+	    '༤': '4',
+	    '༥': '5',
+	    '༦': '6',
+	    '༧': '7',
+	    '༨': '8',
+	    '༩': '9',
+	    '༠': '0'
+	};
+
+	var bo = moment.defineLocale('bo', {
+	    months : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
+	    monthsShort : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
+	    weekdays : 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
+	    weekdaysShort : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
+	    weekdaysMin : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm',
+	        LTS : 'A h:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm'
+	    },
+	    calendar : {
+	        sameDay : '[དི་རིང] LT',
+	        nextDay : '[སང་ཉིན] LT',
+	        nextWeek : '[བདུན་ཕྲག་རྗེས་མ], LT',
+	        lastDay : '[ཁ་སང] LT',
+	        lastWeek : '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s ལ་',
+	        past : '%s སྔན་ལ',
+	        s : 'ལམ་སང',
+	        m : 'སྐར་མ་གཅིག',
+	        mm : '%d སྐར་མ',
+	        h : 'ཆུ་ཚོད་གཅིག',
+	        hh : '%d ཆུ་ཚོད',
+	        d : 'ཉིན་གཅིག',
+	        dd : '%d ཉིན་',
+	        M : 'ཟླ་བ་གཅིག',
+	        MM : '%d ཟླ་བ',
+	        y : 'ལོ་གཅིག',
+	        yy : '%d ལོ'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    meridiemParse: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if ((meridiem === 'མཚན་མོ' && hour >= 4) ||
+	                (meridiem === 'ཉིན་གུང' && hour < 5) ||
+	                meridiem === 'དགོང་དག') {
+	            return hour + 12;
+	        } else {
+	            return hour;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'མཚན་མོ';
+	        } else if (hour < 10) {
+	            return 'ཞོགས་ཀས';
+	        } else if (hour < 17) {
+	            return 'ཉིན་གུང';
+	        } else if (hour < 20) {
+	            return 'དགོང་དག';
+	        } else {
+	            return 'མཚན་མོ';
+	        }
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return bo;
+
+	})));
+
+
+/***/ },
+/* 59 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Breton [br]
+	//! author : Jean-Baptiste Le Duigou : https://github.com/jbleduigou
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function relativeTimeWithMutation(number, withoutSuffix, key) {
+	    var format = {
+	        'mm': 'munutenn',
+	        'MM': 'miz',
+	        'dd': 'devezh'
+	    };
+	    return number + ' ' + mutation(format[key], number);
+	}
+	function specialMutationForYears(number) {
+	    switch (lastNumber(number)) {
+	        case 1:
+	        case 3:
+	        case 4:
+	        case 5:
+	        case 9:
+	            return number + ' bloaz';
+	        default:
+	            return number + ' vloaz';
+	    }
+	}
+	function lastNumber(number) {
+	    if (number > 9) {
+	        return lastNumber(number % 10);
+	    }
+	    return number;
+	}
+	function mutation(text, number) {
+	    if (number === 2) {
+	        return softMutation(text);
+	    }
+	    return text;
+	}
+	function softMutation(text) {
+	    var mutationTable = {
+	        'm': 'v',
+	        'b': 'v',
+	        'd': 'z'
+	    };
+	    if (mutationTable[text.charAt(0)] === undefined) {
+	        return text;
+	    }
+	    return mutationTable[text.charAt(0)] + text.substring(1);
+	}
+
+	var br = moment.defineLocale('br', {
+	    months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
+	    monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
+	    weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
+	    weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
+	    weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'h[e]mm A',
+	        LTS : 'h[e]mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D [a viz] MMMM YYYY',
+	        LLL : 'D [a viz] MMMM YYYY h[e]mm A',
+	        LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A'
+	    },
+	    calendar : {
+	        sameDay : '[Hiziv da] LT',
+	        nextDay : '[Warc\'hoazh da] LT',
+	        nextWeek : 'dddd [da] LT',
+	        lastDay : '[Dec\'h da] LT',
+	        lastWeek : 'dddd [paset da] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'a-benn %s',
+	        past : '%s \'zo',
+	        s : 'un nebeud segondennoù',
+	        m : 'ur vunutenn',
+	        mm : relativeTimeWithMutation,
+	        h : 'un eur',
+	        hh : '%d eur',
+	        d : 'un devezh',
+	        dd : relativeTimeWithMutation,
+	        M : 'ur miz',
+	        MM : relativeTimeWithMutation,
+	        y : 'ur bloaz',
+	        yy : specialMutationForYears
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(añ|vet)/,
+	    ordinal : function (number) {
+	        var output = (number === 1) ? 'añ' : 'vet';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return br;
+
+	})));
+
+
+/***/ },
+/* 60 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Bosnian [bs]
+	//! author : Nedim Cholich : https://github.com/frontyard
+	//! based on (hr) translation by Bojan Marković
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function translate(number, withoutSuffix, key) {
+	    var result = number + ' ';
+	    switch (key) {
+	        case 'm':
+	            return withoutSuffix ? 'jedna minuta' : 'jedne minute';
+	        case 'mm':
+	            if (number === 1) {
+	                result += 'minuta';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'minute';
+	            } else {
+	                result += 'minuta';
+	            }
+	            return result;
+	        case 'h':
+	            return withoutSuffix ? 'jedan sat' : 'jednog sata';
+	        case 'hh':
+	            if (number === 1) {
+	                result += 'sat';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'sata';
+	            } else {
+	                result += 'sati';
+	            }
+	            return result;
+	        case 'dd':
+	            if (number === 1) {
+	                result += 'dan';
+	            } else {
+	                result += 'dana';
+	            }
+	            return result;
+	        case 'MM':
+	            if (number === 1) {
+	                result += 'mjesec';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'mjeseca';
+	            } else {
+	                result += 'mjeseci';
+	            }
+	            return result;
+	        case 'yy':
+	            if (number === 1) {
+	                result += 'godina';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'godine';
+	            } else {
+	                result += 'godina';
+	            }
+	            return result;
+	    }
+	}
+
+	var bs = moment.defineLocale('bs', {
+	    months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
+	    monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
+	    weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
+	    weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY H:mm',
+	        LLLL : 'dddd, D. MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay  : '[danas u] LT',
+	        nextDay  : '[sutra u] LT',
+	        nextWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[u] [nedjelju] [u] LT';
+	                case 3:
+	                    return '[u] [srijedu] [u] LT';
+	                case 6:
+	                    return '[u] [subotu] [u] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[u] dddd [u] LT';
+	            }
+	        },
+	        lastDay  : '[jučer u] LT',
+	        lastWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                case 3:
+	                    return '[prošlu] dddd [u] LT';
+	                case 6:
+	                    return '[prošle] [subote] [u] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[prošli] dddd [u] LT';
+	            }
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'za %s',
+	        past   : 'prije %s',
+	        s      : 'par sekundi',
+	        m      : translate,
+	        mm     : translate,
+	        h      : translate,
+	        hh     : translate,
+	        d      : 'dan',
+	        dd     : translate,
+	        M      : 'mjesec',
+	        MM     : translate,
+	        y      : 'godinu',
+	        yy     : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return bs;
+
+	})));
+
+
+/***/ },
+/* 61 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Catalan [ca]
+	//! author : Juan G. Hurtado : https://github.com/juanghurtado
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var ca = moment.defineLocale('ca', {
+	    months : {
+	        standalone: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
+	        format: 'de gener_de febrer_de març_d\'abril_de maig_de juny_de juliol_d\'agost_de setembre_d\'octubre_de novembre_de desembre'.split('_'),
+	        isFormat: /D[oD]?(\s)+MMMM/
+	    },
+	    monthsShort : 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
+	    weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
+	    weekdaysMin : 'Dg_Dl_Dt_Dc_Dj_Dv_Ds'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : '[el] D MMMM [de] YYYY',
+	        ll : 'D MMM YYYY',
+	        LLL : '[el] D MMMM [de] YYYY [a les] H:mm',
+	        lll : 'D MMM YYYY, H:mm',
+	        LLLL : '[el] dddd D MMMM [de] YYYY [a les] H:mm',
+	        llll : 'ddd D MMM YYYY, H:mm'
+	    },
+	    calendar : {
+	        sameDay : function () {
+	            return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
+	        },
+	        nextDay : function () {
+	            return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
+	        },
+	        nextWeek : function () {
+	            return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
+	        },
+	        lastDay : function () {
+	            return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
+	        },
+	        lastWeek : function () {
+	            return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'd\'aquí %s',
+	        past : 'fa %s',
+	        s : 'uns segons',
+	        m : 'un minut',
+	        mm : '%d minuts',
+	        h : 'una hora',
+	        hh : '%d hores',
+	        d : 'un dia',
+	        dd : '%d dies',
+	        M : 'un mes',
+	        MM : '%d mesos',
+	        y : 'un any',
+	        yy : '%d anys'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(r|n|t|è|a)/,
+	    ordinal : function (number, period) {
+	        var output = (number === 1) ? 'r' :
+	            (number === 2) ? 'n' :
+	            (number === 3) ? 'r' :
+	            (number === 4) ? 't' : 'è';
+	        if (period === 'w' || period === 'W') {
+	            output = 'a';
+	        }
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return ca;
+
+	})));
+
+
+/***/ },
+/* 62 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Czech [cs]
+	//! author : petrbela : https://github.com/petrbela
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var months = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_');
+	var monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_');
+	function plural(n) {
+	    return (n > 1) && (n < 5) && (~~(n / 10) !== 1);
+	}
+	function translate(number, withoutSuffix, key, isFuture) {
+	    var result = number + ' ';
+	    switch (key) {
+	        case 's':  // a few seconds / in a few seconds / a few seconds ago
+	            return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
+	        case 'm':  // a minute / in a minute / a minute ago
+	            return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
+	        case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'minuty' : 'minut');
+	            } else {
+	                return result + 'minutami';
+	            }
+	            break;
+	        case 'h':  // an hour / in an hour / an hour ago
+	            return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
+	        case 'hh': // 9 hours / in 9 hours / 9 hours ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'hodiny' : 'hodin');
+	            } else {
+	                return result + 'hodinami';
+	            }
+	            break;
+	        case 'd':  // a day / in a day / a day ago
+	            return (withoutSuffix || isFuture) ? 'den' : 'dnem';
+	        case 'dd': // 9 days / in 9 days / 9 days ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'dny' : 'dní');
+	            } else {
+	                return result + 'dny';
+	            }
+	            break;
+	        case 'M':  // a month / in a month / a month ago
+	            return (withoutSuffix || isFuture) ? 'měsíc' : 'měsícem';
+	        case 'MM': // 9 months / in 9 months / 9 months ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'měsíce' : 'měsíců');
+	            } else {
+	                return result + 'měsíci';
+	            }
+	            break;
+	        case 'y':  // a year / in a year / a year ago
+	            return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
+	        case 'yy': // 9 years / in 9 years / 9 years ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'roky' : 'let');
+	            } else {
+	                return result + 'lety';
+	            }
+	            break;
+	    }
+	}
+
+	var cs = moment.defineLocale('cs', {
+	    months : months,
+	    monthsShort : monthsShort,
+	    monthsParse : (function (months, monthsShort) {
+	        var i, _monthsParse = [];
+	        for (i = 0; i < 12; i++) {
+	            // use custom parser to solve problem with July (červenec)
+	            _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
+	        }
+	        return _monthsParse;
+	    }(months, monthsShort)),
+	    shortMonthsParse : (function (monthsShort) {
+	        var i, _shortMonthsParse = [];
+	        for (i = 0; i < 12; i++) {
+	            _shortMonthsParse[i] = new RegExp('^' + monthsShort[i] + '$', 'i');
+	        }
+	        return _shortMonthsParse;
+	    }(monthsShort)),
+	    longMonthsParse : (function (months) {
+	        var i, _longMonthsParse = [];
+	        for (i = 0; i < 12; i++) {
+	            _longMonthsParse[i] = new RegExp('^' + months[i] + '$', 'i');
+	        }
+	        return _longMonthsParse;
+	    }(months)),
+	    weekdays : 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
+	    weekdaysShort : 'ne_po_út_st_čt_pá_so'.split('_'),
+	    weekdaysMin : 'ne_po_út_st_čt_pá_so'.split('_'),
+	    longDateFormat : {
+	        LT: 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY H:mm',
+	        LLLL : 'dddd D. MMMM YYYY H:mm',
+	        l : 'D. M. YYYY'
+	    },
+	    calendar : {
+	        sameDay: '[dnes v] LT',
+	        nextDay: '[zítra v] LT',
+	        nextWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[v neděli v] LT';
+	                case 1:
+	                case 2:
+	                    return '[v] dddd [v] LT';
+	                case 3:
+	                    return '[ve středu v] LT';
+	                case 4:
+	                    return '[ve čtvrtek v] LT';
+	                case 5:
+	                    return '[v pátek v] LT';
+	                case 6:
+	                    return '[v sobotu v] LT';
+	            }
+	        },
+	        lastDay: '[včera v] LT',
+	        lastWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[minulou neděli v] LT';
+	                case 1:
+	                case 2:
+	                    return '[minulé] dddd [v] LT';
+	                case 3:
+	                    return '[minulou středu v] LT';
+	                case 4:
+	                case 5:
+	                    return '[minulý] dddd [v] LT';
+	                case 6:
+	                    return '[minulou sobotu v] LT';
+	            }
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'za %s',
+	        past : 'před %s',
+	        s : translate,
+	        m : translate,
+	        mm : translate,
+	        h : translate,
+	        hh : translate,
+	        d : translate,
+	        dd : translate,
+	        M : translate,
+	        MM : translate,
+	        y : translate,
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return cs;
+
+	})));
+
+
+/***/ },
+/* 63 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Chuvash [cv]
+	//! author : Anatoly Mironov : https://github.com/mirontoli
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var cv = moment.defineLocale('cv', {
+	    months : 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split('_'),
+	    monthsShort : 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
+	    weekdays : 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split('_'),
+	    weekdaysShort : 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
+	    weekdaysMin : 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD-MM-YYYY',
+	        LL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
+	        LLL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
+	        LLLL : 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Паян] LT [сехетре]',
+	        nextDay: '[Ыран] LT [сехетре]',
+	        lastDay: '[Ӗнер] LT [сехетре]',
+	        nextWeek: '[Ҫитес] dddd LT [сехетре]',
+	        lastWeek: '[Иртнӗ] dddd LT [сехетре]',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : function (output) {
+	            var affix = /сехет$/i.exec(output) ? 'рен' : /ҫул$/i.exec(output) ? 'тан' : 'ран';
+	            return output + affix;
+	        },
+	        past : '%s каялла',
+	        s : 'пӗр-ик ҫеккунт',
+	        m : 'пӗр минут',
+	        mm : '%d минут',
+	        h : 'пӗр сехет',
+	        hh : '%d сехет',
+	        d : 'пӗр кун',
+	        dd : '%d кун',
+	        M : 'пӗр уйӑх',
+	        MM : '%d уйӑх',
+	        y : 'пӗр ҫул',
+	        yy : '%d ҫул'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-мӗш/,
+	    ordinal : '%d-мӗш',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return cv;
+
+	})));
+
+
+/***/ },
+/* 64 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Welsh [cy]
+	//! author : Robert Allen : https://github.com/robgallen
+	//! author : https://github.com/ryangreaves
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var cy = moment.defineLocale('cy', {
+	    months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
+	    monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
+	    weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
+	    weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
+	    weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    // time formats are the same as en-gb
+	    longDateFormat: {
+	        LT: 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L: 'DD/MM/YYYY',
+	        LL: 'D MMMM YYYY',
+	        LLL: 'D MMMM YYYY HH:mm',
+	        LLLL: 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar: {
+	        sameDay: '[Heddiw am] LT',
+	        nextDay: '[Yfory am] LT',
+	        nextWeek: 'dddd [am] LT',
+	        lastDay: '[Ddoe am] LT',
+	        lastWeek: 'dddd [diwethaf am] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime: {
+	        future: 'mewn %s',
+	        past: '%s yn ôl',
+	        s: 'ychydig eiliadau',
+	        m: 'munud',
+	        mm: '%d munud',
+	        h: 'awr',
+	        hh: '%d awr',
+	        d: 'diwrnod',
+	        dd: '%d diwrnod',
+	        M: 'mis',
+	        MM: '%d mis',
+	        y: 'blwyddyn',
+	        yy: '%d flynedd'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
+	    // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
+	    ordinal: function (number) {
+	        var b = number,
+	            output = '',
+	            lookup = [
+	                '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
+	                'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
+	            ];
+	        if (b > 20) {
+	            if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
+	                output = 'fed'; // not 30ain, 70ain or 90ain
+	            } else {
+	                output = 'ain';
+	            }
+	        } else if (b > 0) {
+	            output = lookup[b];
+	        }
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return cy;
+
+	})));
+
+
+/***/ },
+/* 65 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Danish [da]
+	//! author : Ulrik Nielsen : https://github.com/mrbase
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var da = moment.defineLocale('da', {
+	    months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
+	    monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
+	    weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
+	    weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'),
+	    weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY HH:mm',
+	        LLLL : 'dddd [d.] D. MMMM YYYY [kl.] HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[i dag kl.] LT',
+	        nextDay : '[i morgen kl.] LT',
+	        nextWeek : 'på dddd [kl.] LT',
+	        lastDay : '[i går kl.] LT',
+	        lastWeek : '[i] dddd[s kl.] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'om %s',
+	        past : '%s siden',
+	        s : 'få sekunder',
+	        m : 'et minut',
+	        mm : '%d minutter',
+	        h : 'en time',
+	        hh : '%d timer',
+	        d : 'en dag',
+	        dd : '%d dage',
+	        M : 'en måned',
+	        MM : '%d måneder',
+	        y : 'et år',
+	        yy : '%d år'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return da;
+
+	})));
+
+
+/***/ },
+/* 66 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : German [de]
+	//! author : lluchs : https://github.com/lluchs
+	//! author: Menelion Elensúle: https://github.com/Oire
+	//! author : Mikolaj Dadela : https://github.com/mik01aj
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var format = {
+	        'm': ['eine Minute', 'einer Minute'],
+	        'h': ['eine Stunde', 'einer Stunde'],
+	        'd': ['ein Tag', 'einem Tag'],
+	        'dd': [number + ' Tage', number + ' Tagen'],
+	        'M': ['ein Monat', 'einem Monat'],
+	        'MM': [number + ' Monate', number + ' Monaten'],
+	        'y': ['ein Jahr', 'einem Jahr'],
+	        'yy': [number + ' Jahre', number + ' Jahren']
+	    };
+	    return withoutSuffix ? format[key][0] : format[key][1];
+	}
+
+	var de = moment.defineLocale('de', {
+	    months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
+	    monthsShort : 'Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
+	    weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
+	    weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT: 'HH:mm',
+	        LTS: 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D. MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[heute um] LT [Uhr]',
+	        sameElse: 'L',
+	        nextDay: '[morgen um] LT [Uhr]',
+	        nextWeek: 'dddd [um] LT [Uhr]',
+	        lastDay: '[gestern um] LT [Uhr]',
+	        lastWeek: '[letzten] dddd [um] LT [Uhr]'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : 'vor %s',
+	        s : 'ein paar Sekunden',
+	        m : processRelativeTime,
+	        mm : '%d Minuten',
+	        h : processRelativeTime,
+	        hh : '%d Stunden',
+	        d : processRelativeTime,
+	        dd : processRelativeTime,
+	        M : processRelativeTime,
+	        MM : processRelativeTime,
+	        y : processRelativeTime,
+	        yy : processRelativeTime
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return de;
+
+	})));
+
+
+/***/ },
+/* 67 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : German (Austria) [de-at]
+	//! author : lluchs : https://github.com/lluchs
+	//! author: Menelion Elensúle: https://github.com/Oire
+	//! author : Martin Groller : https://github.com/MadMG
+	//! author : Mikolaj Dadela : https://github.com/mik01aj
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var format = {
+	        'm': ['eine Minute', 'einer Minute'],
+	        'h': ['eine Stunde', 'einer Stunde'],
+	        'd': ['ein Tag', 'einem Tag'],
+	        'dd': [number + ' Tage', number + ' Tagen'],
+	        'M': ['ein Monat', 'einem Monat'],
+	        'MM': [number + ' Monate', number + ' Monaten'],
+	        'y': ['ein Jahr', 'einem Jahr'],
+	        'yy': [number + ' Jahre', number + ' Jahren']
+	    };
+	    return withoutSuffix ? format[key][0] : format[key][1];
+	}
+
+	var deAt = moment.defineLocale('de-at', {
+	    months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
+	    monthsShort : 'Jän._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
+	    weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
+	    weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT: 'HH:mm',
+	        LTS: 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D. MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[heute um] LT [Uhr]',
+	        sameElse: 'L',
+	        nextDay: '[morgen um] LT [Uhr]',
+	        nextWeek: 'dddd [um] LT [Uhr]',
+	        lastDay: '[gestern um] LT [Uhr]',
+	        lastWeek: '[letzten] dddd [um] LT [Uhr]'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : 'vor %s',
+	        s : 'ein paar Sekunden',
+	        m : processRelativeTime,
+	        mm : '%d Minuten',
+	        h : processRelativeTime,
+	        hh : '%d Stunden',
+	        d : processRelativeTime,
+	        dd : processRelativeTime,
+	        M : processRelativeTime,
+	        MM : processRelativeTime,
+	        y : processRelativeTime,
+	        yy : processRelativeTime
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return deAt;
+
+	})));
+
+
+/***/ },
+/* 68 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : German (Switzerland) [de-ch]
+	//! author : sschueller : https://github.com/sschueller
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	// based on: https://www.bk.admin.ch/dokumentation/sprachen/04915/05016/index.html?lang=de#
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var format = {
+	        'm': ['eine Minute', 'einer Minute'],
+	        'h': ['eine Stunde', 'einer Stunde'],
+	        'd': ['ein Tag', 'einem Tag'],
+	        'dd': [number + ' Tage', number + ' Tagen'],
+	        'M': ['ein Monat', 'einem Monat'],
+	        'MM': [number + ' Monate', number + ' Monaten'],
+	        'y': ['ein Jahr', 'einem Jahr'],
+	        'yy': [number + ' Jahre', number + ' Jahren']
+	    };
+	    return withoutSuffix ? format[key][0] : format[key][1];
+	}
+
+	var deCh = moment.defineLocale('de-ch', {
+	    months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
+	    monthsShort : 'Jan._Febr._März_April_Mai_Juni_Juli_Aug._Sept._Okt._Nov._Dez.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
+	    weekdaysShort : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+	    weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT: 'HH.mm',
+	        LTS: 'HH.mm.ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY HH.mm',
+	        LLLL : 'dddd, D. MMMM YYYY HH.mm'
+	    },
+	    calendar : {
+	        sameDay: '[heute um] LT [Uhr]',
+	        sameElse: 'L',
+	        nextDay: '[morgen um] LT [Uhr]',
+	        nextWeek: 'dddd [um] LT [Uhr]',
+	        lastDay: '[gestern um] LT [Uhr]',
+	        lastWeek: '[letzten] dddd [um] LT [Uhr]'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : 'vor %s',
+	        s : 'ein paar Sekunden',
+	        m : processRelativeTime,
+	        mm : '%d Minuten',
+	        h : processRelativeTime,
+	        hh : '%d Stunden',
+	        d : processRelativeTime,
+	        dd : processRelativeTime,
+	        M : processRelativeTime,
+	        MM : processRelativeTime,
+	        y : processRelativeTime,
+	        yy : processRelativeTime
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return deCh;
+
+	})));
+
+
+/***/ },
+/* 69 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Maldivian [dv]
+	//! author : Jawish Hameed : https://github.com/jawish
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var months = [
+	    'ޖެނުއަރީ',
+	    'ފެބްރުއަރީ',
+	    'މާރިޗު',
+	    'އޭޕްރީލު',
+	    'މޭ',
+	    'ޖޫން',
+	    'ޖުލައި',
+	    'އޯގަސްޓު',
+	    'ސެޕްޓެމްބަރު',
+	    'އޮކްޓޯބަރު',
+	    'ނޮވެމްބަރު',
+	    'ޑިސެމްބަރު'
+	];
+	var weekdays = [
+	    'އާދިއްތަ',
+	    'ހޯމަ',
+	    'އަންގާރަ',
+	    'ބުދަ',
+	    'ބުރާސްފަތި',
+	    'ހުކުރު',
+	    'ހޮނިހިރު'
+	];
+
+	var dv = moment.defineLocale('dv', {
+	    months : months,
+	    monthsShort : months,
+	    weekdays : weekdays,
+	    weekdaysShort : weekdays,
+	    weekdaysMin : 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
+	    longDateFormat : {
+
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'D/M/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /މކ|މފ/,
+	    isPM : function (input) {
+	        return 'މފ' === input;
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'މކ';
+	        } else {
+	            return 'މފ';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[މިއަދު] LT',
+	        nextDay : '[މާދަމާ] LT',
+	        nextWeek : 'dddd LT',
+	        lastDay : '[އިއްޔެ] LT',
+	        lastWeek : '[ފާއިތުވި] dddd LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'ތެރޭގައި %s',
+	        past : 'ކުރިން %s',
+	        s : 'ސިކުންތުކޮޅެއް',
+	        m : 'މިނިޓެއް',
+	        mm : 'މިނިޓު %d',
+	        h : 'ގަޑިއިރެއް',
+	        hh : 'ގަޑިއިރު %d',
+	        d : 'ދުވަހެއް',
+	        dd : 'ދުވަސް %d',
+	        M : 'މަހެއް',
+	        MM : 'މަސް %d',
+	        y : 'އަހަރެއް',
+	        yy : 'އަހަރު %d'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/،/g, ',');
+	    },
+	    postformat: function (string) {
+	        return string.replace(/,/g, '،');
+	    },
+	    week : {
+	        dow : 7,  // Sunday is the first day of the week.
+	        doy : 12  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return dv;
+
+	})));
+
+
+/***/ },
+/* 70 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Greek [el]
+	//! author : Aggelos Karalias : https://github.com/mehiel
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+	function isFunction(input) {
+	    return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
+	}
+
+
+	var el = moment.defineLocale('el', {
+	    monthsNominativeEl : 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
+	    monthsGenitiveEl : 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split('_'),
+	    months : function (momentToFormat, format) {
+	        if (!momentToFormat) {
+	            return this._monthsNominativeEl;
+	        } else if (/D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
+	            return this._monthsGenitiveEl[momentToFormat.month()];
+	        } else {
+	            return this._monthsNominativeEl[momentToFormat.month()];
+	        }
+	    },
+	    monthsShort : 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
+	    weekdays : 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split('_'),
+	    weekdaysShort : 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
+	    weekdaysMin : 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours > 11) {
+	            return isLower ? 'μμ' : 'ΜΜ';
+	        } else {
+	            return isLower ? 'πμ' : 'ΠΜ';
+	        }
+	    },
+	    isPM : function (input) {
+	        return ((input + '').toLowerCase()[0] === 'μ');
+	    },
+	    meridiemParse : /[ΠΜ]\.?Μ?\.?/i,
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY h:mm A',
+	        LLLL : 'dddd, D MMMM YYYY h:mm A'
+	    },
+	    calendarEl : {
+	        sameDay : '[Σήμερα {}] LT',
+	        nextDay : '[Αύριο {}] LT',
+	        nextWeek : 'dddd [{}] LT',
+	        lastDay : '[Χθες {}] LT',
+	        lastWeek : function () {
+	            switch (this.day()) {
+	                case 6:
+	                    return '[το προηγούμενο] dddd [{}] LT';
+	                default:
+	                    return '[την προηγούμενη] dddd [{}] LT';
+	            }
+	        },
+	        sameElse : 'L'
+	    },
+	    calendar : function (key, mom) {
+	        var output = this._calendarEl[key],
+	            hours = mom && mom.hours();
+	        if (isFunction(output)) {
+	            output = output.apply(mom);
+	        }
+	        return output.replace('{}', (hours % 12 === 1 ? 'στη' : 'στις'));
+	    },
+	    relativeTime : {
+	        future : 'σε %s',
+	        past : '%s πριν',
+	        s : 'λίγα δευτερόλεπτα',
+	        m : 'ένα λεπτό',
+	        mm : '%d λεπτά',
+	        h : 'μία ώρα',
+	        hh : '%d ώρες',
+	        d : 'μία μέρα',
+	        dd : '%d μέρες',
+	        M : 'ένας μήνας',
+	        MM : '%d μήνες',
+	        y : 'ένας χρόνος',
+	        yy : '%d χρόνια'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}η/,
+	    ordinal: '%dη',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4st is the first week of the year.
+	    }
+	});
+
+	return el;
+
+	})));
+
+
+/***/ },
+/* 71 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : English (Australia) [en-au]
+	//! author : Jared Morse : https://github.com/jarcoal
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var enAu = moment.defineLocale('en-au', {
+	    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+	    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+	    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+	    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+	    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY h:mm A',
+	        LLLL : 'dddd, D MMMM YYYY h:mm A'
+	    },
+	    calendar : {
+	        sameDay : '[Today at] LT',
+	        nextDay : '[Tomorrow at] LT',
+	        nextWeek : 'dddd [at] LT',
+	        lastDay : '[Yesterday at] LT',
+	        lastWeek : '[Last] dddd [at] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : '%s ago',
+	        s : 'a few seconds',
+	        m : 'a minute',
+	        mm : '%d minutes',
+	        h : 'an hour',
+	        hh : '%d hours',
+	        d : 'a day',
+	        dd : '%d days',
+	        M : 'a month',
+	        MM : '%d months',
+	        y : 'a year',
+	        yy : '%d years'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return enAu;
+
+	})));
+
+
+/***/ },
+/* 72 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : English (Canada) [en-ca]
+	//! author : Jonathan Abourbih : https://github.com/jonbca
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var enCa = moment.defineLocale('en-ca', {
+	    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+	    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+	    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+	    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+	    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'YYYY-MM-DD',
+	        LL : 'MMMM D, YYYY',
+	        LLL : 'MMMM D, YYYY h:mm A',
+	        LLLL : 'dddd, MMMM D, YYYY h:mm A'
+	    },
+	    calendar : {
+	        sameDay : '[Today at] LT',
+	        nextDay : '[Tomorrow at] LT',
+	        nextWeek : 'dddd [at] LT',
+	        lastDay : '[Yesterday at] LT',
+	        lastWeek : '[Last] dddd [at] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : '%s ago',
+	        s : 'a few seconds',
+	        m : 'a minute',
+	        mm : '%d minutes',
+	        h : 'an hour',
+	        hh : '%d hours',
+	        d : 'a day',
+	        dd : '%d days',
+	        M : 'a month',
+	        MM : '%d months',
+	        y : 'a year',
+	        yy : '%d years'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    }
+	});
+
+	return enCa;
+
+	})));
+
+
+/***/ },
+/* 73 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : English (United Kingdom) [en-gb]
+	//! author : Chris Gedrim : https://github.com/chrisgedrim
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var enGb = moment.defineLocale('en-gb', {
+	    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+	    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+	    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+	    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+	    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Today at] LT',
+	        nextDay : '[Tomorrow at] LT',
+	        nextWeek : 'dddd [at] LT',
+	        lastDay : '[Yesterday at] LT',
+	        lastWeek : '[Last] dddd [at] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : '%s ago',
+	        s : 'a few seconds',
+	        m : 'a minute',
+	        mm : '%d minutes',
+	        h : 'an hour',
+	        hh : '%d hours',
+	        d : 'a day',
+	        dd : '%d days',
+	        M : 'a month',
+	        MM : '%d months',
+	        y : 'a year',
+	        yy : '%d years'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return enGb;
+
+	})));
+
+
+/***/ },
+/* 74 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : English (Ireland) [en-ie]
+	//! author : Chris Cartlidge : https://github.com/chriscartlidge
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var enIe = moment.defineLocale('en-ie', {
+	    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+	    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+	    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+	    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+	    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD-MM-YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Today at] LT',
+	        nextDay : '[Tomorrow at] LT',
+	        nextWeek : 'dddd [at] LT',
+	        lastDay : '[Yesterday at] LT',
+	        lastWeek : '[Last] dddd [at] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : '%s ago',
+	        s : 'a few seconds',
+	        m : 'a minute',
+	        mm : '%d minutes',
+	        h : 'an hour',
+	        hh : '%d hours',
+	        d : 'a day',
+	        dd : '%d days',
+	        M : 'a month',
+	        MM : '%d months',
+	        y : 'a year',
+	        yy : '%d years'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return enIe;
+
+	})));
+
+
+/***/ },
+/* 75 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : English (New Zealand) [en-nz]
+	//! author : Luke McGregor : https://github.com/lukemcgregor
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var enNz = moment.defineLocale('en-nz', {
+	    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+	    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+	    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+	    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+	    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY h:mm A',
+	        LLLL : 'dddd, D MMMM YYYY h:mm A'
+	    },
+	    calendar : {
+	        sameDay : '[Today at] LT',
+	        nextDay : '[Tomorrow at] LT',
+	        nextWeek : 'dddd [at] LT',
+	        lastDay : '[Yesterday at] LT',
+	        lastWeek : '[Last] dddd [at] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'in %s',
+	        past : '%s ago',
+	        s : 'a few seconds',
+	        m : 'a minute',
+	        mm : '%d minutes',
+	        h : 'an hour',
+	        hh : '%d hours',
+	        d : 'a day',
+	        dd : '%d days',
+	        M : 'a month',
+	        MM : '%d months',
+	        y : 'a year',
+	        yy : '%d years'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return enNz;
+
+	})));
+
+
+/***/ },
+/* 76 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Esperanto [eo]
+	//! author : Colin Dean : https://github.com/colindean
+	//! author : Mia Nordentoft Imperatori : https://github.com/miestasmia
+	//! comment : miestasmia corrected the translation by colindean
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var eo = moment.defineLocale('eo', {
+	    months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
+	    monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec'.split('_'),
+	    weekdays : 'dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato'.split('_'),
+	    weekdaysShort : 'dim_lun_mard_merk_ĵaŭ_ven_sab'.split('_'),
+	    weekdaysMin : 'di_lu_ma_me_ĵa_ve_sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY-MM-DD',
+	        LL : 'D[-a de] MMMM, YYYY',
+	        LLL : 'D[-a de] MMMM, YYYY HH:mm',
+	        LLLL : 'dddd, [la] D[-a de] MMMM, YYYY HH:mm'
+	    },
+	    meridiemParse: /[ap]\.t\.m/i,
+	    isPM: function (input) {
+	        return input.charAt(0).toLowerCase() === 'p';
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours > 11) {
+	            return isLower ? 'p.t.m.' : 'P.T.M.';
+	        } else {
+	            return isLower ? 'a.t.m.' : 'A.T.M.';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[Hodiaŭ je] LT',
+	        nextDay : '[Morgaŭ je] LT',
+	        nextWeek : 'dddd [je] LT',
+	        lastDay : '[Hieraŭ je] LT',
+	        lastWeek : '[pasinta] dddd [je] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'post %s',
+	        past : 'antaŭ %s',
+	        s : 'sekundoj',
+	        m : 'minuto',
+	        mm : '%d minutoj',
+	        h : 'horo',
+	        hh : '%d horoj',
+	        d : 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
+	        dd : '%d tagoj',
+	        M : 'monato',
+	        MM : '%d monatoj',
+	        y : 'jaro',
+	        yy : '%d jaroj'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}a/,
+	    ordinal : '%da',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return eo;
+
+	})));
+
+
+/***/ },
+/* 77 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Spanish [es]
+	//! author : Julio Napurí : https://github.com/julionc
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_');
+	var monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
+
+	var es = moment.defineLocale('es', {
+	    months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
+	    monthsShort : function (m, format) {
+	        if (!m) {
+	            return monthsShortDot;
+	        } else if (/-MMM-/.test(format)) {
+	            return monthsShort[m.month()];
+	        } else {
+	            return monthsShortDot[m.month()];
+	        }
+	    },
+	    monthsParseExact : true,
+	    weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
+	    weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
+	    weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D [de] MMMM [de] YYYY',
+	        LLL : 'D [de] MMMM [de] YYYY H:mm',
+	        LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay : function () {
+	            return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        nextDay : function () {
+	            return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        nextWeek : function () {
+	            return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        lastDay : function () {
+	            return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        lastWeek : function () {
+	            return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'en %s',
+	        past : 'hace %s',
+	        s : 'unos segundos',
+	        m : 'un minuto',
+	        mm : '%d minutos',
+	        h : 'una hora',
+	        hh : '%d horas',
+	        d : 'un día',
+	        dd : '%d días',
+	        M : 'un mes',
+	        MM : '%d meses',
+	        y : 'un año',
+	        yy : '%d años'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}º/,
+	    ordinal : '%dº',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return es;
+
+	})));
+
+
+/***/ },
+/* 78 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Spanish (Dominican Republic) [es-do]
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_');
+	var monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
+
+	var esDo = moment.defineLocale('es-do', {
+	    months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
+	    monthsShort : function (m, format) {
+	        if (!m) {
+	            return monthsShortDot;
+	        } else if (/-MMM-/.test(format)) {
+	            return monthsShort[m.month()];
+	        } else {
+	            return monthsShortDot[m.month()];
+	        }
+	    },
+	    monthsParseExact : true,
+	    weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
+	    weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
+	    weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D [de] MMMM [de] YYYY',
+	        LLL : 'D [de] MMMM [de] YYYY h:mm A',
+	        LLLL : 'dddd, D [de] MMMM [de] YYYY h:mm A'
+	    },
+	    calendar : {
+	        sameDay : function () {
+	            return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        nextDay : function () {
+	            return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        nextWeek : function () {
+	            return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        lastDay : function () {
+	            return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        lastWeek : function () {
+	            return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'en %s',
+	        past : 'hace %s',
+	        s : 'unos segundos',
+	        m : 'un minuto',
+	        mm : '%d minutos',
+	        h : 'una hora',
+	        hh : '%d horas',
+	        d : 'un día',
+	        dd : '%d días',
+	        M : 'un mes',
+	        MM : '%d meses',
+	        y : 'un año',
+	        yy : '%d años'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}º/,
+	    ordinal : '%dº',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return esDo;
+
+	})));
+
+
+/***/ },
+/* 79 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Estonian [et]
+	//! author : Henry Kehlmann : https://github.com/madhenry
+	//! improvements : Illimar Tambek : https://github.com/ragulka
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var format = {
+	        's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
+	        'm' : ['ühe minuti', 'üks minut'],
+	        'mm': [number + ' minuti', number + ' minutit'],
+	        'h' : ['ühe tunni', 'tund aega', 'üks tund'],
+	        'hh': [number + ' tunni', number + ' tundi'],
+	        'd' : ['ühe päeva', 'üks päev'],
+	        'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
+	        'MM': [number + ' kuu', number + ' kuud'],
+	        'y' : ['ühe aasta', 'aasta', 'üks aasta'],
+	        'yy': [number + ' aasta', number + ' aastat']
+	    };
+	    if (withoutSuffix) {
+	        return format[key][2] ? format[key][2] : format[key][1];
+	    }
+	    return isFuture ? format[key][0] : format[key][1];
+	}
+
+	var et = moment.defineLocale('et', {
+	    months        : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
+	    monthsShort   : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
+	    weekdays      : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
+	    weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
+	    weekdaysMin   : 'P_E_T_K_N_R_L'.split('_'),
+	    longDateFormat : {
+	        LT   : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L    : 'DD.MM.YYYY',
+	        LL   : 'D. MMMM YYYY',
+	        LLL  : 'D. MMMM YYYY H:mm',
+	        LLLL : 'dddd, D. MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay  : '[Täna,] LT',
+	        nextDay  : '[Homme,] LT',
+	        nextWeek : '[Järgmine] dddd LT',
+	        lastDay  : '[Eile,] LT',
+	        lastWeek : '[Eelmine] dddd LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s pärast',
+	        past   : '%s tagasi',
+	        s      : processRelativeTime,
+	        m      : processRelativeTime,
+	        mm     : processRelativeTime,
+	        h      : processRelativeTime,
+	        hh     : processRelativeTime,
+	        d      : processRelativeTime,
+	        dd     : '%d päeva',
+	        M      : processRelativeTime,
+	        MM     : processRelativeTime,
+	        y      : processRelativeTime,
+	        yy     : processRelativeTime
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return et;
+
+	})));
+
+
+/***/ },
+/* 80 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Basque [eu]
+	//! author : Eneko Illarramendi : https://github.com/eillarra
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var eu = moment.defineLocale('eu', {
+	    months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
+	    monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
+	    weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
+	    weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY-MM-DD',
+	        LL : 'YYYY[ko] MMMM[ren] D[a]',
+	        LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm',
+	        LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
+	        l : 'YYYY-M-D',
+	        ll : 'YYYY[ko] MMM D[a]',
+	        lll : 'YYYY[ko] MMM D[a] HH:mm',
+	        llll : 'ddd, YYYY[ko] MMM D[a] HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[gaur] LT[etan]',
+	        nextDay : '[bihar] LT[etan]',
+	        nextWeek : 'dddd LT[etan]',
+	        lastDay : '[atzo] LT[etan]',
+	        lastWeek : '[aurreko] dddd LT[etan]',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s barru',
+	        past : 'duela %s',
+	        s : 'segundo batzuk',
+	        m : 'minutu bat',
+	        mm : '%d minutu',
+	        h : 'ordu bat',
+	        hh : '%d ordu',
+	        d : 'egun bat',
+	        dd : '%d egun',
+	        M : 'hilabete bat',
+	        MM : '%d hilabete',
+	        y : 'urte bat',
+	        yy : '%d urte'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return eu;
+
+	})));
+
+
+/***/ },
+/* 81 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Persian [fa]
+	//! author : Ebrahim Byagowi : https://github.com/ebraminio
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '۱',
+	    '2': '۲',
+	    '3': '۳',
+	    '4': '۴',
+	    '5': '۵',
+	    '6': '۶',
+	    '7': '۷',
+	    '8': '۸',
+	    '9': '۹',
+	    '0': '۰'
+	};
+	var numberMap = {
+	    '۱': '1',
+	    '۲': '2',
+	    '۳': '3',
+	    '۴': '4',
+	    '۵': '5',
+	    '۶': '6',
+	    '۷': '7',
+	    '۸': '8',
+	    '۹': '9',
+	    '۰': '0'
+	};
+
+	var fa = moment.defineLocale('fa', {
+	    months : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
+	    monthsShort : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
+	    weekdays : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
+	    weekdaysShort : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
+	    weekdaysMin : 'ی_د_س_چ_پ_ج_ش'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /قبل از ظهر|بعد از ظهر/,
+	    isPM: function (input) {
+	        return /بعد از ظهر/.test(input);
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'قبل از ظهر';
+	        } else {
+	            return 'بعد از ظهر';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[امروز ساعت] LT',
+	        nextDay : '[فردا ساعت] LT',
+	        nextWeek : 'dddd [ساعت] LT',
+	        lastDay : '[دیروز ساعت] LT',
+	        lastWeek : 'dddd [پیش] [ساعت] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'در %s',
+	        past : '%s پیش',
+	        s : 'چند ثانیه',
+	        m : 'یک دقیقه',
+	        mm : '%d دقیقه',
+	        h : 'یک ساعت',
+	        hh : '%d ساعت',
+	        d : 'یک روز',
+	        dd : '%d روز',
+	        M : 'یک ماه',
+	        MM : '%d ماه',
+	        y : 'یک سال',
+	        yy : '%d سال'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[۰-۹]/g, function (match) {
+	            return numberMap[match];
+	        }).replace(/،/g, ',');
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        }).replace(/,/g, '،');
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}م/,
+	    ordinal : '%dم',
+	    week : {
+	        dow : 6, // Saturday is the first day of the week.
+	        doy : 12 // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return fa;
+
+	})));
+
+
+/***/ },
+/* 82 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Finnish [fi]
+	//! author : Tarmo Aidantausta : https://github.com/bleadof
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' ');
+	var numbersFuture = [
+	        'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
+	        numbersPast[7], numbersPast[8], numbersPast[9]
+	    ];
+	function translate(number, withoutSuffix, key, isFuture) {
+	    var result = '';
+	    switch (key) {
+	        case 's':
+	            return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
+	        case 'm':
+	            return isFuture ? 'minuutin' : 'minuutti';
+	        case 'mm':
+	            result = isFuture ? 'minuutin' : 'minuuttia';
+	            break;
+	        case 'h':
+	            return isFuture ? 'tunnin' : 'tunti';
+	        case 'hh':
+	            result = isFuture ? 'tunnin' : 'tuntia';
+	            break;
+	        case 'd':
+	            return isFuture ? 'päivän' : 'päivä';
+	        case 'dd':
+	            result = isFuture ? 'päivän' : 'päivää';
+	            break;
+	        case 'M':
+	            return isFuture ? 'kuukauden' : 'kuukausi';
+	        case 'MM':
+	            result = isFuture ? 'kuukauden' : 'kuukautta';
+	            break;
+	        case 'y':
+	            return isFuture ? 'vuoden' : 'vuosi';
+	        case 'yy':
+	            result = isFuture ? 'vuoden' : 'vuotta';
+	            break;
+	    }
+	    result = verbalNumber(number, isFuture) + ' ' + result;
+	    return result;
+	}
+	function verbalNumber(number, isFuture) {
+	    return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;
+	}
+
+	var fi = moment.defineLocale('fi', {
+	    months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
+	    monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
+	    weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
+	    weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
+	    weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH.mm',
+	        LTS : 'HH.mm.ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'Do MMMM[ta] YYYY',
+	        LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm',
+	        LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
+	        l : 'D.M.YYYY',
+	        ll : 'Do MMM YYYY',
+	        lll : 'Do MMM YYYY, [klo] HH.mm',
+	        llll : 'ddd, Do MMM YYYY, [klo] HH.mm'
+	    },
+	    calendar : {
+	        sameDay : '[tänään] [klo] LT',
+	        nextDay : '[huomenna] [klo] LT',
+	        nextWeek : 'dddd [klo] LT',
+	        lastDay : '[eilen] [klo] LT',
+	        lastWeek : '[viime] dddd[na] [klo] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s päästä',
+	        past : '%s sitten',
+	        s : translate,
+	        m : translate,
+	        mm : translate,
+	        h : translate,
+	        hh : translate,
+	        d : translate,
+	        dd : translate,
+	        M : translate,
+	        MM : translate,
+	        y : translate,
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return fi;
+
+	})));
+
+
+/***/ },
+/* 83 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Faroese [fo]
+	//! author : Ragnar Johannesen : https://github.com/ragnar123
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var fo = moment.defineLocale('fo', {
+	    months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
+	    monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
+	    weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
+	    weekdaysShort : 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
+	    weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D. MMMM, YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Í dag kl.] LT',
+	        nextDay : '[Í morgin kl.] LT',
+	        nextWeek : 'dddd [kl.] LT',
+	        lastDay : '[Í gjár kl.] LT',
+	        lastWeek : '[síðstu] dddd [kl] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'um %s',
+	        past : '%s síðani',
+	        s : 'fá sekund',
+	        m : 'ein minutt',
+	        mm : '%d minuttir',
+	        h : 'ein tími',
+	        hh : '%d tímar',
+	        d : 'ein dagur',
+	        dd : '%d dagar',
+	        M : 'ein mánaði',
+	        MM : '%d mánaðir',
+	        y : 'eitt ár',
+	        yy : '%d ár'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return fo;
+
+	})));
+
+
+/***/ },
+/* 84 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : French [fr]
+	//! author : John Fischer : https://github.com/jfroffice
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var fr = moment.defineLocale('fr', {
+	    months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
+	    monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
+	    weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
+	    weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Aujourd’hui à] LT',
+	        nextDay : '[Demain à] LT',
+	        nextWeek : 'dddd [à] LT',
+	        lastDay : '[Hier à] LT',
+	        lastWeek : 'dddd [dernier à] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'dans %s',
+	        past : 'il y a %s',
+	        s : 'quelques secondes',
+	        m : 'une minute',
+	        mm : '%d minutes',
+	        h : 'une heure',
+	        hh : '%d heures',
+	        d : 'un jour',
+	        dd : '%d jours',
+	        M : 'un mois',
+	        MM : '%d mois',
+	        y : 'un an',
+	        yy : '%d ans'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(er|)/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            // TODO: Return 'e' when day of month > 1. Move this case inside
+	            // block for masculine words below.
+	            // See https://github.com/moment/moment/issues/3375
+	            case 'D':
+	                return number + (number === 1 ? 'er' : '');
+
+	            // Words with masculine grammatical gender: mois, trimestre, jour
+	            default:
+	            case 'M':
+	            case 'Q':
+	            case 'DDD':
+	            case 'd':
+	                return number + (number === 1 ? 'er' : 'e');
+
+	            // Words with feminine grammatical gender: semaine
+	            case 'w':
+	            case 'W':
+	                return number + (number === 1 ? 're' : 'e');
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return fr;
+
+	})));
+
+
+/***/ },
+/* 85 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : French (Canada) [fr-ca]
+	//! author : Jonathan Abourbih : https://github.com/jonbca
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var frCa = moment.defineLocale('fr-ca', {
+	    months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
+	    monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
+	    weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
+	    weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY-MM-DD',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Aujourd’hui à] LT',
+	        nextDay : '[Demain à] LT',
+	        nextWeek : 'dddd [à] LT',
+	        lastDay : '[Hier à] LT',
+	        lastWeek : 'dddd [dernier à] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'dans %s',
+	        past : 'il y a %s',
+	        s : 'quelques secondes',
+	        m : 'une minute',
+	        mm : '%d minutes',
+	        h : 'une heure',
+	        hh : '%d heures',
+	        d : 'un jour',
+	        dd : '%d jours',
+	        M : 'un mois',
+	        MM : '%d mois',
+	        y : 'un an',
+	        yy : '%d ans'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            // Words with masculine grammatical gender: mois, trimestre, jour
+	            default:
+	            case 'M':
+	            case 'Q':
+	            case 'D':
+	            case 'DDD':
+	            case 'd':
+	                return number + (number === 1 ? 'er' : 'e');
+
+	            // Words with feminine grammatical gender: semaine
+	            case 'w':
+	            case 'W':
+	                return number + (number === 1 ? 're' : 'e');
+	        }
+	    }
+	});
+
+	return frCa;
+
+	})));
+
+
+/***/ },
+/* 86 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : French (Switzerland) [fr-ch]
+	//! author : Gaspard Bucher : https://github.com/gaspard
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var frCh = moment.defineLocale('fr-ch', {
+	    months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
+	    monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
+	    weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
+	    weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Aujourd’hui à] LT',
+	        nextDay : '[Demain à] LT',
+	        nextWeek : 'dddd [à] LT',
+	        lastDay : '[Hier à] LT',
+	        lastWeek : 'dddd [dernier à] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'dans %s',
+	        past : 'il y a %s',
+	        s : 'quelques secondes',
+	        m : 'une minute',
+	        mm : '%d minutes',
+	        h : 'une heure',
+	        hh : '%d heures',
+	        d : 'un jour',
+	        dd : '%d jours',
+	        M : 'un mois',
+	        MM : '%d mois',
+	        y : 'un an',
+	        yy : '%d ans'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            // Words with masculine grammatical gender: mois, trimestre, jour
+	            default:
+	            case 'M':
+	            case 'Q':
+	            case 'D':
+	            case 'DDD':
+	            case 'd':
+	                return number + (number === 1 ? 'er' : 'e');
+
+	            // Words with feminine grammatical gender: semaine
+	            case 'w':
+	            case 'W':
+	                return number + (number === 1 ? 're' : 'e');
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return frCh;
+
+	})));
+
+
+/***/ },
+/* 87 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Frisian [fy]
+	//! author : Robin van der Vliet : https://github.com/robin0van0der0v
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_');
+	var monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
+
+	var fy = moment.defineLocale('fy', {
+	    months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
+	    monthsShort : function (m, format) {
+	        if (!m) {
+	            return monthsShortWithDots;
+	        } else if (/-MMM-/.test(format)) {
+	            return monthsShortWithoutDots[m.month()];
+	        } else {
+	            return monthsShortWithDots[m.month()];
+	        }
+	    },
+	    monthsParseExact : true,
+	    weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
+	    weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'),
+	    weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD-MM-YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[hjoed om] LT',
+	        nextDay: '[moarn om] LT',
+	        nextWeek: 'dddd [om] LT',
+	        lastDay: '[juster om] LT',
+	        lastWeek: '[ôfrûne] dddd [om] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'oer %s',
+	        past : '%s lyn',
+	        s : 'in pear sekonden',
+	        m : 'ien minút',
+	        mm : '%d minuten',
+	        h : 'ien oere',
+	        hh : '%d oeren',
+	        d : 'ien dei',
+	        dd : '%d dagen',
+	        M : 'ien moanne',
+	        MM : '%d moannen',
+	        y : 'ien jier',
+	        yy : '%d jierren'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+	    ordinal : function (number) {
+	        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return fy;
+
+	})));
+
+
+/***/ },
+/* 88 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Scottish Gaelic [gd]
+	//! author : Jon Ashdown : https://github.com/jonashdown
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var months = [
+	    'Am Faoilleach', 'An Gearran', 'Am Màrt', 'An Giblean', 'An Cèitean', 'An t-Ògmhios', 'An t-Iuchar', 'An Lùnastal', 'An t-Sultain', 'An Dàmhair', 'An t-Samhain', 'An Dùbhlachd'
+	];
+
+	var monthsShort = ['Faoi', 'Gear', 'Màrt', 'Gibl', 'Cèit', 'Ògmh', 'Iuch', 'Lùn', 'Sult', 'Dàmh', 'Samh', 'Dùbh'];
+
+	var weekdays = ['Didòmhnaich', 'Diluain', 'Dimàirt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];
+
+	var weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];
+
+	var weekdaysMin = ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];
+
+	var gd = moment.defineLocale('gd', {
+	    months : months,
+	    monthsShort : monthsShort,
+	    monthsParseExact : true,
+	    weekdays : weekdays,
+	    weekdaysShort : weekdaysShort,
+	    weekdaysMin : weekdaysMin,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[An-diugh aig] LT',
+	        nextDay : '[A-màireach aig] LT',
+	        nextWeek : 'dddd [aig] LT',
+	        lastDay : '[An-dè aig] LT',
+	        lastWeek : 'dddd [seo chaidh] [aig] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'ann an %s',
+	        past : 'bho chionn %s',
+	        s : 'beagan diogan',
+	        m : 'mionaid',
+	        mm : '%d mionaidean',
+	        h : 'uair',
+	        hh : '%d uairean',
+	        d : 'latha',
+	        dd : '%d latha',
+	        M : 'mìos',
+	        MM : '%d mìosan',
+	        y : 'bliadhna',
+	        yy : '%d bliadhna'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}(d|na|mh)/,
+	    ordinal : function (number) {
+	        var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return gd;
+
+	})));
+
+
+/***/ },
+/* 89 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Galician [gl]
+	//! author : Juan G. Hurtado : https://github.com/juanghurtado
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var gl = moment.defineLocale('gl', {
+	    months : 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split('_'),
+	    monthsShort : 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'),
+	    weekdaysShort : 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'),
+	    weekdaysMin : 'do_lu_ma_mé_xo_ve_sá'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D [de] MMMM [de] YYYY',
+	        LLL : 'D [de] MMMM [de] YYYY H:mm',
+	        LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay : function () {
+	            return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
+	        },
+	        nextDay : function () {
+	            return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
+	        },
+	        nextWeek : function () {
+	            return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
+	        },
+	        lastDay : function () {
+	            return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
+	        },
+	        lastWeek : function () {
+	            return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : function (str) {
+	            if (str.indexOf('un') === 0) {
+	                return 'n' + str;
+	            }
+	            return 'en ' + str;
+	        },
+	        past : 'hai %s',
+	        s : 'uns segundos',
+	        m : 'un minuto',
+	        mm : '%d minutos',
+	        h : 'unha hora',
+	        hh : '%d horas',
+	        d : 'un día',
+	        dd : '%d días',
+	        M : 'un mes',
+	        MM : '%d meses',
+	        y : 'un ano',
+	        yy : '%d anos'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}º/,
+	    ordinal : '%dº',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return gl;
+
+	})));
+
+
+/***/ },
+/* 90 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Konkani Latin script [gom-latn]
+	//! author : The Discoverer : https://github.com/WikiDiscoverer
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var format = {
+	        's': ['thodde secondanim', 'thodde second'],
+	        'm': ['eka mintan', 'ek minute'],
+	        'mm': [number + ' mintanim', number + ' mintam'],
+	        'h': ['eka horan', 'ek hor'],
+	        'hh': [number + ' horanim', number + ' hor'],
+	        'd': ['eka disan', 'ek dis'],
+	        'dd': [number + ' disanim', number + ' dis'],
+	        'M': ['eka mhoinean', 'ek mhoino'],
+	        'MM': [number + ' mhoineanim', number + ' mhoine'],
+	        'y': ['eka vorsan', 'ek voros'],
+	        'yy': [number + ' vorsanim', number + ' vorsam']
+	    };
+	    return withoutSuffix ? format[key][0] : format[key][1];
+	}
+
+	var gomLatn = moment.defineLocale('gom-latn', {
+	    months : 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split('_'),
+	    monthsShort : 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'Aitar_Somar_Mongllar_Budvar_Brestar_Sukrar_Son\'var'.split('_'),
+	    weekdaysShort : 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'),
+	    weekdaysMin : 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'A h:mm [vazta]',
+	        LTS : 'A h:mm:ss [vazta]',
+	        L : 'DD-MM-YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY A h:mm [vazta]',
+	        LLLL : 'dddd, MMMM[achea] Do, YYYY, A h:mm [vazta]',
+	        llll: 'ddd, D MMM YYYY, A h:mm [vazta]'
+	    },
+	    calendar : {
+	        sameDay: '[Aiz] LT',
+	        nextDay: '[Faleam] LT',
+	        nextWeek: '[Ieta to] dddd[,] LT',
+	        lastDay: '[Kal] LT',
+	        lastWeek: '[Fatlo] dddd[,] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : '%s',
+	        past : '%s adim',
+	        s : processRelativeTime,
+	        m : processRelativeTime,
+	        mm : processRelativeTime,
+	        h : processRelativeTime,
+	        hh : processRelativeTime,
+	        d : processRelativeTime,
+	        dd : processRelativeTime,
+	        M : processRelativeTime,
+	        MM : processRelativeTime,
+	        y : processRelativeTime,
+	        yy : processRelativeTime
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}(er)/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            // the ordinal 'er' only applies to day of the month
+	            case 'D':
+	                return number + 'er';
+	            default:
+	            case 'M':
+	            case 'Q':
+	            case 'DDD':
+	            case 'd':
+	            case 'w':
+	            case 'W':
+	                return number;
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    },
+	    meridiemParse: /rati|sokalli|donparam|sanje/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'rati') {
+	            return hour < 4 ? hour : hour + 12;
+	        } else if (meridiem === 'sokalli') {
+	            return hour;
+	        } else if (meridiem === 'donparam') {
+	            return hour > 12 ? hour : hour + 12;
+	        } else if (meridiem === 'sanje') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'rati';
+	        } else if (hour < 12) {
+	            return 'sokalli';
+	        } else if (hour < 16) {
+	            return 'donparam';
+	        } else if (hour < 20) {
+	            return 'sanje';
+	        } else {
+	            return 'rati';
+	        }
+	    }
+	});
+
+	return gomLatn;
+
+	})));
+
+
+/***/ },
+/* 91 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Hebrew [he]
+	//! author : Tomer Cohen : https://github.com/tomer
+	//! author : Moshe Simantov : https://github.com/DevelopmentIL
+	//! author : Tal Ater : https://github.com/TalAter
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var he = moment.defineLocale('he', {
+	    months : 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
+	    monthsShort : 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split('_'),
+	    weekdays : 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
+	    weekdaysShort : 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
+	    weekdaysMin : 'א_ב_ג_ד_ה_ו_ש'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D [ב]MMMM YYYY',
+	        LLL : 'D [ב]MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D [ב]MMMM YYYY HH:mm',
+	        l : 'D/M/YYYY',
+	        ll : 'D MMM YYYY',
+	        lll : 'D MMM YYYY HH:mm',
+	        llll : 'ddd, D MMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[היום ב־]LT',
+	        nextDay : '[מחר ב־]LT',
+	        nextWeek : 'dddd [בשעה] LT',
+	        lastDay : '[אתמול ב־]LT',
+	        lastWeek : '[ביום] dddd [האחרון בשעה] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'בעוד %s',
+	        past : 'לפני %s',
+	        s : 'מספר שניות',
+	        m : 'דקה',
+	        mm : '%d דקות',
+	        h : 'שעה',
+	        hh : function (number) {
+	            if (number === 2) {
+	                return 'שעתיים';
+	            }
+	            return number + ' שעות';
+	        },
+	        d : 'יום',
+	        dd : function (number) {
+	            if (number === 2) {
+	                return 'יומיים';
+	            }
+	            return number + ' ימים';
+	        },
+	        M : 'חודש',
+	        MM : function (number) {
+	            if (number === 2) {
+	                return 'חודשיים';
+	            }
+	            return number + ' חודשים';
+	        },
+	        y : 'שנה',
+	        yy : function (number) {
+	            if (number === 2) {
+	                return 'שנתיים';
+	            } else if (number % 10 === 0 && number !== 10) {
+	                return number + ' שנה';
+	            }
+	            return number + ' שנים';
+	        }
+	    },
+	    meridiemParse: /אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,
+	    isPM : function (input) {
+	        return /^(אחה"צ|אחרי הצהריים|בערב)$/.test(input);
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 5) {
+	            return 'לפנות בוקר';
+	        } else if (hour < 10) {
+	            return 'בבוקר';
+	        } else if (hour < 12) {
+	            return isLower ? 'לפנה"צ' : 'לפני הצהריים';
+	        } else if (hour < 18) {
+	            return isLower ? 'אחה"צ' : 'אחרי הצהריים';
+	        } else {
+	            return 'בערב';
+	        }
+	    }
+	});
+
+	return he;
+
+	})));
+
+
+/***/ },
+/* 92 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Hindi [hi]
+	//! author : Mayank Singhal : https://github.com/mayanksinghal
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '१',
+	    '2': '२',
+	    '3': '३',
+	    '4': '४',
+	    '5': '५',
+	    '6': '६',
+	    '7': '७',
+	    '8': '८',
+	    '9': '९',
+	    '0': '०'
+	};
+	var numberMap = {
+	    '१': '1',
+	    '२': '2',
+	    '३': '3',
+	    '४': '4',
+	    '५': '5',
+	    '६': '6',
+	    '७': '7',
+	    '८': '8',
+	    '९': '9',
+	    '०': '0'
+	};
+
+	var hi = moment.defineLocale('hi', {
+	    months : 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split('_'),
+	    monthsShort : 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
+	    weekdaysShort : 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
+	    weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm बजे',
+	        LTS : 'A h:mm:ss बजे',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm बजे',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm बजे'
+	    },
+	    calendar : {
+	        sameDay : '[आज] LT',
+	        nextDay : '[कल] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[कल] LT',
+	        lastWeek : '[पिछले] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s में',
+	        past : '%s पहले',
+	        s : 'कुछ ही क्षण',
+	        m : 'एक मिनट',
+	        mm : '%d मिनट',
+	        h : 'एक घंटा',
+	        hh : '%d घंटे',
+	        d : 'एक दिन',
+	        dd : '%d दिन',
+	        M : 'एक महीने',
+	        MM : '%d महीने',
+	        y : 'एक वर्ष',
+	        yy : '%d वर्ष'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[१२३४५६७८९०]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    // Hindi notation for meridiems are quite fuzzy in practice. While there exists
+	    // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
+	    meridiemParse: /रात|सुबह|दोपहर|शाम/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'रात') {
+	            return hour < 4 ? hour : hour + 12;
+	        } else if (meridiem === 'सुबह') {
+	            return hour;
+	        } else if (meridiem === 'दोपहर') {
+	            return hour >= 10 ? hour : hour + 12;
+	        } else if (meridiem === 'शाम') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'रात';
+	        } else if (hour < 10) {
+	            return 'सुबह';
+	        } else if (hour < 17) {
+	            return 'दोपहर';
+	        } else if (hour < 20) {
+	            return 'शाम';
+	        } else {
+	            return 'रात';
+	        }
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return hi;
+
+	})));
+
+
+/***/ },
+/* 93 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Croatian [hr]
+	//! author : Bojan Marković : https://github.com/bmarkovic
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function translate(number, withoutSuffix, key) {
+	    var result = number + ' ';
+	    switch (key) {
+	        case 'm':
+	            return withoutSuffix ? 'jedna minuta' : 'jedne minute';
+	        case 'mm':
+	            if (number === 1) {
+	                result += 'minuta';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'minute';
+	            } else {
+	                result += 'minuta';
+	            }
+	            return result;
+	        case 'h':
+	            return withoutSuffix ? 'jedan sat' : 'jednog sata';
+	        case 'hh':
+	            if (number === 1) {
+	                result += 'sat';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'sata';
+	            } else {
+	                result += 'sati';
+	            }
+	            return result;
+	        case 'dd':
+	            if (number === 1) {
+	                result += 'dan';
+	            } else {
+	                result += 'dana';
+	            }
+	            return result;
+	        case 'MM':
+	            if (number === 1) {
+	                result += 'mjesec';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'mjeseca';
+	            } else {
+	                result += 'mjeseci';
+	            }
+	            return result;
+	        case 'yy':
+	            if (number === 1) {
+	                result += 'godina';
+	            } else if (number === 2 || number === 3 || number === 4) {
+	                result += 'godine';
+	            } else {
+	                result += 'godina';
+	            }
+	            return result;
+	    }
+	}
+
+	var hr = moment.defineLocale('hr', {
+	    months : {
+	        format: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
+	        standalone: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
+	    },
+	    monthsShort : 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
+	    weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
+	    weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY H:mm',
+	        LLLL : 'dddd, D. MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay  : '[danas u] LT',
+	        nextDay  : '[sutra u] LT',
+	        nextWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[u] [nedjelju] [u] LT';
+	                case 3:
+	                    return '[u] [srijedu] [u] LT';
+	                case 6:
+	                    return '[u] [subotu] [u] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[u] dddd [u] LT';
+	            }
+	        },
+	        lastDay  : '[jučer u] LT',
+	        lastWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                case 3:
+	                    return '[prošlu] dddd [u] LT';
+	                case 6:
+	                    return '[prošle] [subote] [u] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[prošli] dddd [u] LT';
+	            }
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'za %s',
+	        past   : 'prije %s',
+	        s      : 'par sekundi',
+	        m      : translate,
+	        mm     : translate,
+	        h      : translate,
+	        hh     : translate,
+	        d      : 'dan',
+	        dd     : translate,
+	        M      : 'mjesec',
+	        MM     : translate,
+	        y      : 'godinu',
+	        yy     : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return hr;
+
+	})));
+
+
+/***/ },
+/* 94 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Hungarian [hu]
+	//! author : Adam Brunner : https://github.com/adambrunner
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');
+	function translate(number, withoutSuffix, key, isFuture) {
+	    var num = number,
+	        suffix;
+	    switch (key) {
+	        case 's':
+	            return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce';
+	        case 'm':
+	            return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
+	        case 'mm':
+	            return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
+	        case 'h':
+	            return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
+	        case 'hh':
+	            return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
+	        case 'd':
+	            return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
+	        case 'dd':
+	            return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
+	        case 'M':
+	            return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
+	        case 'MM':
+	            return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
+	        case 'y':
+	            return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
+	        case 'yy':
+	            return num + (isFuture || withoutSuffix ? ' év' : ' éve');
+	    }
+	    return '';
+	}
+	function week(isFuture) {
+	    return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';
+	}
+
+	var hu = moment.defineLocale('hu', {
+	    months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
+	    monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
+	    weekdays : 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
+	    weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
+	    weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'YYYY.MM.DD.',
+	        LL : 'YYYY. MMMM D.',
+	        LLL : 'YYYY. MMMM D. H:mm',
+	        LLLL : 'YYYY. MMMM D., dddd H:mm'
+	    },
+	    meridiemParse: /de|du/i,
+	    isPM: function (input) {
+	        return input.charAt(1).toLowerCase() === 'u';
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 12) {
+	            return isLower === true ? 'de' : 'DE';
+	        } else {
+	            return isLower === true ? 'du' : 'DU';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[ma] LT[-kor]',
+	        nextDay : '[holnap] LT[-kor]',
+	        nextWeek : function () {
+	            return week.call(this, true);
+	        },
+	        lastDay : '[tegnap] LT[-kor]',
+	        lastWeek : function () {
+	            return week.call(this, false);
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s múlva',
+	        past : '%s',
+	        s : translate,
+	        m : translate,
+	        mm : translate,
+	        h : translate,
+	        hh : translate,
+	        d : translate,
+	        dd : translate,
+	        M : translate,
+	        MM : translate,
+	        y : translate,
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return hu;
+
+	})));
+
+
+/***/ },
+/* 95 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Armenian [hy-am]
+	//! author : Armendarabyan : https://github.com/armendarabyan
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var hyAm = moment.defineLocale('hy-am', {
+	    months : {
+	        format: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_'),
+	        standalone: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_')
+	    },
+	    monthsShort : 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
+	    weekdays : 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split('_'),
+	    weekdaysShort : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
+	    weekdaysMin : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY թ.',
+	        LLL : 'D MMMM YYYY թ., HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY թ., HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[այսօր] LT',
+	        nextDay: '[վաղը] LT',
+	        lastDay: '[երեկ] LT',
+	        nextWeek: function () {
+	            return 'dddd [օրը ժամը] LT';
+	        },
+	        lastWeek: function () {
+	            return '[անցած] dddd [օրը ժամը] LT';
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : '%s հետո',
+	        past : '%s առաջ',
+	        s : 'մի քանի վայրկյան',
+	        m : 'րոպե',
+	        mm : '%d րոպե',
+	        h : 'ժամ',
+	        hh : '%d ժամ',
+	        d : 'օր',
+	        dd : '%d օր',
+	        M : 'ամիս',
+	        MM : '%d ամիս',
+	        y : 'տարի',
+	        yy : '%d տարի'
+	    },
+	    meridiemParse: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
+	    isPM: function (input) {
+	        return /^(ցերեկվա|երեկոյան)$/.test(input);
+	    },
+	    meridiem : function (hour) {
+	        if (hour < 4) {
+	            return 'գիշերվա';
+	        } else if (hour < 12) {
+	            return 'առավոտվա';
+	        } else if (hour < 17) {
+	            return 'ցերեկվա';
+	        } else {
+	            return 'երեկոյան';
+	        }
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}|\d{1,2}-(ին|րդ)/,
+	    ordinal: function (number, period) {
+	        switch (period) {
+	            case 'DDD':
+	            case 'w':
+	            case 'W':
+	            case 'DDDo':
+	                if (number === 1) {
+	                    return number + '-ին';
+	                }
+	                return number + '-րդ';
+	            default:
+	                return number;
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return hyAm;
+
+	})));
+
+
+/***/ },
+/* 96 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Indonesian [id]
+	//! author : Mohammad Satrio Utomo : https://github.com/tyok
+	//! reference: http://id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var id = moment.defineLocale('id', {
+	    months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
+	    monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des'.split('_'),
+	    weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
+	    weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
+	    weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH.mm',
+	        LTS : 'HH.mm.ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY [pukul] HH.mm',
+	        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
+	    },
+	    meridiemParse: /pagi|siang|sore|malam/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'pagi') {
+	            return hour;
+	        } else if (meridiem === 'siang') {
+	            return hour >= 11 ? hour : hour + 12;
+	        } else if (meridiem === 'sore' || meridiem === 'malam') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 11) {
+	            return 'pagi';
+	        } else if (hours < 15) {
+	            return 'siang';
+	        } else if (hours < 19) {
+	            return 'sore';
+	        } else {
+	            return 'malam';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[Hari ini pukul] LT',
+	        nextDay : '[Besok pukul] LT',
+	        nextWeek : 'dddd [pukul] LT',
+	        lastDay : '[Kemarin pukul] LT',
+	        lastWeek : 'dddd [lalu pukul] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'dalam %s',
+	        past : '%s yang lalu',
+	        s : 'beberapa detik',
+	        m : 'semenit',
+	        mm : '%d menit',
+	        h : 'sejam',
+	        hh : '%d jam',
+	        d : 'sehari',
+	        dd : '%d hari',
+	        M : 'sebulan',
+	        MM : '%d bulan',
+	        y : 'setahun',
+	        yy : '%d tahun'
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return id;
+
+	})));
+
+
+/***/ },
+/* 97 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Icelandic [is]
+	//! author : Hinrik Örn Sigurðsson : https://github.com/hinrik
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function plural(n) {
+	    if (n % 100 === 11) {
+	        return true;
+	    } else if (n % 10 === 1) {
+	        return false;
+	    }
+	    return true;
+	}
+	function translate(number, withoutSuffix, key, isFuture) {
+	    var result = number + ' ';
+	    switch (key) {
+	        case 's':
+	            return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
+	        case 'm':
+	            return withoutSuffix ? 'mínúta' : 'mínútu';
+	        case 'mm':
+	            if (plural(number)) {
+	                return result + (withoutSuffix || isFuture ? 'mínútur' : 'mínútum');
+	            } else if (withoutSuffix) {
+	                return result + 'mínúta';
+	            }
+	            return result + 'mínútu';
+	        case 'hh':
+	            if (plural(number)) {
+	                return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
+	            }
+	            return result + 'klukkustund';
+	        case 'd':
+	            if (withoutSuffix) {
+	                return 'dagur';
+	            }
+	            return isFuture ? 'dag' : 'degi';
+	        case 'dd':
+	            if (plural(number)) {
+	                if (withoutSuffix) {
+	                    return result + 'dagar';
+	                }
+	                return result + (isFuture ? 'daga' : 'dögum');
+	            } else if (withoutSuffix) {
+	                return result + 'dagur';
+	            }
+	            return result + (isFuture ? 'dag' : 'degi');
+	        case 'M':
+	            if (withoutSuffix) {
+	                return 'mánuður';
+	            }
+	            return isFuture ? 'mánuð' : 'mánuði';
+	        case 'MM':
+	            if (plural(number)) {
+	                if (withoutSuffix) {
+	                    return result + 'mánuðir';
+	                }
+	                return result + (isFuture ? 'mánuði' : 'mánuðum');
+	            } else if (withoutSuffix) {
+	                return result + 'mánuður';
+	            }
+	            return result + (isFuture ? 'mánuð' : 'mánuði');
+	        case 'y':
+	            return withoutSuffix || isFuture ? 'ár' : 'ári';
+	        case 'yy':
+	            if (plural(number)) {
+	                return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
+	            }
+	            return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
+	    }
+	}
+
+	var is = moment.defineLocale('is', {
+	    months : 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split('_'),
+	    monthsShort : 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
+	    weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
+	    weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
+	    weekdaysMin : 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY [kl.] H:mm',
+	        LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm'
+	    },
+	    calendar : {
+	        sameDay : '[í dag kl.] LT',
+	        nextDay : '[á morgun kl.] LT',
+	        nextWeek : 'dddd [kl.] LT',
+	        lastDay : '[í gær kl.] LT',
+	        lastWeek : '[síðasta] dddd [kl.] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'eftir %s',
+	        past : 'fyrir %s síðan',
+	        s : translate,
+	        m : translate,
+	        mm : translate,
+	        h : 'klukkustund',
+	        hh : translate,
+	        d : translate,
+	        dd : translate,
+	        M : translate,
+	        MM : translate,
+	        y : translate,
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return is;
+
+	})));
+
+
+/***/ },
+/* 98 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Italian [it]
+	//! author : Lorenzo : https://github.com/aliem
+	//! author: Mattia Larentis: https://github.com/nostalgiaz
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var it = moment.defineLocale('it', {
+	    months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
+	    monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
+	    weekdays : 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
+	    weekdaysShort : 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
+	    weekdaysMin : 'do_lu_ma_me_gi_ve_sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Oggi alle] LT',
+	        nextDay: '[Domani alle] LT',
+	        nextWeek: 'dddd [alle] LT',
+	        lastDay: '[Ieri alle] LT',
+	        lastWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[la scorsa] dddd [alle] LT';
+	                default:
+	                    return '[lo scorso] dddd [alle] LT';
+	            }
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : function (s) {
+	            return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
+	        },
+	        past : '%s fa',
+	        s : 'alcuni secondi',
+	        m : 'un minuto',
+	        mm : '%d minuti',
+	        h : 'un\'ora',
+	        hh : '%d ore',
+	        d : 'un giorno',
+	        dd : '%d giorni',
+	        M : 'un mese',
+	        MM : '%d mesi',
+	        y : 'un anno',
+	        yy : '%d anni'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}º/,
+	    ordinal: '%dº',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return it;
+
+	})));
+
+
+/***/ },
+/* 99 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Japanese [ja]
+	//! author : LI Long : https://github.com/baryon
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var ja = moment.defineLocale('ja', {
+	    months : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+	    monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+	    weekdays : '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
+	    weekdaysShort : '日_月_火_水_木_金_土'.split('_'),
+	    weekdaysMin : '日_月_火_水_木_金_土'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY/MM/DD',
+	        LL : 'YYYY年M月D日',
+	        LLL : 'YYYY年M月D日 HH:mm',
+	        LLLL : 'YYYY年M月D日 HH:mm dddd',
+	        l : 'YYYY/MM/DD',
+	        ll : 'YYYY年M月D日',
+	        lll : 'YYYY年M月D日 HH:mm',
+	        llll : 'YYYY年M月D日 HH:mm dddd'
+	    },
+	    meridiemParse: /午前|午後/i,
+	    isPM : function (input) {
+	        return input === '午後';
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return '午前';
+	        } else {
+	            return '午後';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[今日] LT',
+	        nextDay : '[明日] LT',
+	        nextWeek : '[来週]dddd LT',
+	        lastDay : '[昨日] LT',
+	        lastWeek : '[前週]dddd LT',
+	        sameElse : 'L'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}日/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            case 'd':
+	            case 'D':
+	            case 'DDD':
+	                return number + '日';
+	            default:
+	                return number;
+	        }
+	    },
+	    relativeTime : {
+	        future : '%s後',
+	        past : '%s前',
+	        s : '数秒',
+	        m : '1分',
+	        mm : '%d分',
+	        h : '1時間',
+	        hh : '%d時間',
+	        d : '1日',
+	        dd : '%d日',
+	        M : '1ヶ月',
+	        MM : '%dヶ月',
+	        y : '1年',
+	        yy : '%d年'
+	    }
+	});
+
+	return ja;
+
+	})));
+
+
+/***/ },
+/* 100 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Javanese [jv]
+	//! author : Rony Lantip : https://github.com/lantip
+	//! reference: http://jv.wikipedia.org/wiki/Basa_Jawa
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var jv = moment.defineLocale('jv', {
+	    months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
+	    monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
+	    weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
+	    weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
+	    weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH.mm',
+	        LTS : 'HH.mm.ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY [pukul] HH.mm',
+	        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
+	    },
+	    meridiemParse: /enjing|siyang|sonten|ndalu/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'enjing') {
+	            return hour;
+	        } else if (meridiem === 'siyang') {
+	            return hour >= 11 ? hour : hour + 12;
+	        } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 11) {
+	            return 'enjing';
+	        } else if (hours < 15) {
+	            return 'siyang';
+	        } else if (hours < 19) {
+	            return 'sonten';
+	        } else {
+	            return 'ndalu';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[Dinten puniko pukul] LT',
+	        nextDay : '[Mbenjang pukul] LT',
+	        nextWeek : 'dddd [pukul] LT',
+	        lastDay : '[Kala wingi pukul] LT',
+	        lastWeek : 'dddd [kepengker pukul] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'wonten ing %s',
+	        past : '%s ingkang kepengker',
+	        s : 'sawetawis detik',
+	        m : 'setunggal menit',
+	        mm : '%d menit',
+	        h : 'setunggal jam',
+	        hh : '%d jam',
+	        d : 'sedinten',
+	        dd : '%d dinten',
+	        M : 'sewulan',
+	        MM : '%d wulan',
+	        y : 'setaun',
+	        yy : '%d taun'
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return jv;
+
+	})));
+
+
+/***/ },
+/* 101 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Georgian [ka]
+	//! author : Irakli Janiashvili : https://github.com/irakli-janiashvili
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var ka = moment.defineLocale('ka', {
+	    months : {
+	        standalone: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
+	        format: 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
+	    },
+	    monthsShort : 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
+	    weekdays : {
+	        standalone: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
+	        format: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_'),
+	        isFormat: /(წინა|შემდეგ)/
+	    },
+	    weekdaysShort : 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
+	    weekdaysMin : 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY h:mm A',
+	        LLLL : 'dddd, D MMMM YYYY h:mm A'
+	    },
+	    calendar : {
+	        sameDay : '[დღეს] LT[-ზე]',
+	        nextDay : '[ხვალ] LT[-ზე]',
+	        lastDay : '[გუშინ] LT[-ზე]',
+	        nextWeek : '[შემდეგ] dddd LT[-ზე]',
+	        lastWeek : '[წინა] dddd LT-ზე',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : function (s) {
+	            return (/(წამი|წუთი|საათი|წელი)/).test(s) ?
+	                s.replace(/ი$/, 'ში') :
+	                s + 'ში';
+	        },
+	        past : function (s) {
+	            if ((/(წამი|წუთი|საათი|დღე|თვე)/).test(s)) {
+	                return s.replace(/(ი|ე)$/, 'ის უკან');
+	            }
+	            if ((/წელი/).test(s)) {
+	                return s.replace(/წელი$/, 'წლის უკან');
+	            }
+	        },
+	        s : 'რამდენიმე წამი',
+	        m : 'წუთი',
+	        mm : '%d წუთი',
+	        h : 'საათი',
+	        hh : '%d საათი',
+	        d : 'დღე',
+	        dd : '%d დღე',
+	        M : 'თვე',
+	        MM : '%d თვე',
+	        y : 'წელი',
+	        yy : '%d წელი'
+	    },
+	    dayOfMonthOrdinalParse: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
+	    ordinal : function (number) {
+	        if (number === 0) {
+	            return number;
+	        }
+	        if (number === 1) {
+	            return number + '-ლი';
+	        }
+	        if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
+	            return 'მე-' + number;
+	        }
+	        return number + '-ე';
+	    },
+	    week : {
+	        dow : 1,
+	        doy : 7
+	    }
+	});
+
+	return ka;
+
+	})));
+
+
+/***/ },
+/* 102 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Kazakh [kk]
+	//! authors : Nurlan Rakhimzhanov : https://github.com/nurlan
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var suffixes = {
+	    0: '-ші',
+	    1: '-ші',
+	    2: '-ші',
+	    3: '-ші',
+	    4: '-ші',
+	    5: '-ші',
+	    6: '-шы',
+	    7: '-ші',
+	    8: '-ші',
+	    9: '-шы',
+	    10: '-шы',
+	    20: '-шы',
+	    30: '-шы',
+	    40: '-шы',
+	    50: '-ші',
+	    60: '-шы',
+	    70: '-ші',
+	    80: '-ші',
+	    90: '-шы',
+	    100: '-ші'
+	};
+
+	var kk = moment.defineLocale('kk', {
+	    months : 'қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан'.split('_'),
+	    monthsShort : 'қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
+	    weekdays : 'жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі'.split('_'),
+	    weekdaysShort : 'жек_дүй_сей_сәр_бей_жұм_сен'.split('_'),
+	    weekdaysMin : 'жк_дй_сй_ср_бй_жм_сн'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Бүгін сағат] LT',
+	        nextDay : '[Ертең сағат] LT',
+	        nextWeek : 'dddd [сағат] LT',
+	        lastDay : '[Кеше сағат] LT',
+	        lastWeek : '[Өткен аптаның] dddd [сағат] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s ішінде',
+	        past : '%s бұрын',
+	        s : 'бірнеше секунд',
+	        m : 'бір минут',
+	        mm : '%d минут',
+	        h : 'бір сағат',
+	        hh : '%d сағат',
+	        d : 'бір күн',
+	        dd : '%d күн',
+	        M : 'бір ай',
+	        MM : '%d ай',
+	        y : 'бір жыл',
+	        yy : '%d жыл'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(ші|шы)/,
+	    ordinal : function (number) {
+	        var a = number % 10,
+	            b = number >= 100 ? 100 : null;
+	        return number + (suffixes[number] || suffixes[a] || suffixes[b]);
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return kk;
+
+	})));
+
+
+/***/ },
+/* 103 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Cambodian [km]
+	//! author : Kruy Vanna : https://github.com/kruyvanna
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var km = moment.defineLocale('km', {
+	    months: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
+	    monthsShort: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
+	    weekdays: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
+	    weekdaysShort: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
+	    weekdaysMin: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
+	    longDateFormat: {
+	        LT: 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L: 'DD/MM/YYYY',
+	        LL: 'D MMMM YYYY',
+	        LLL: 'D MMMM YYYY HH:mm',
+	        LLLL: 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar: {
+	        sameDay: '[ថ្ងៃនេះ ម៉ោង] LT',
+	        nextDay: '[ស្អែក ម៉ោង] LT',
+	        nextWeek: 'dddd [ម៉ោង] LT',
+	        lastDay: '[ម្សិលមិញ ម៉ោង] LT',
+	        lastWeek: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime: {
+	        future: '%sទៀត',
+	        past: '%sមុន',
+	        s: 'ប៉ុន្មានវិនាទី',
+	        m: 'មួយនាទី',
+	        mm: '%d នាទី',
+	        h: 'មួយម៉ោង',
+	        hh: '%d ម៉ោង',
+	        d: 'មួយថ្ងៃ',
+	        dd: '%d ថ្ងៃ',
+	        M: 'មួយខែ',
+	        MM: '%d ខែ',
+	        y: 'មួយឆ្នាំ',
+	        yy: '%d ឆ្នាំ'
+	    },
+	    week: {
+	        dow: 1, // Monday is the first day of the week.
+	        doy: 4 // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return km;
+
+	})));
+
+
+/***/ },
+/* 104 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Kannada [kn]
+	//! author : Rajeev Naik : https://github.com/rajeevnaikte
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '೧',
+	    '2': '೨',
+	    '3': '೩',
+	    '4': '೪',
+	    '5': '೫',
+	    '6': '೬',
+	    '7': '೭',
+	    '8': '೮',
+	    '9': '೯',
+	    '0': '೦'
+	};
+	var numberMap = {
+	    '೧': '1',
+	    '೨': '2',
+	    '೩': '3',
+	    '೪': '4',
+	    '೫': '5',
+	    '೬': '6',
+	    '೭': '7',
+	    '೮': '8',
+	    '೯': '9',
+	    '೦': '0'
+	};
+
+	var kn = moment.defineLocale('kn', {
+	    months : 'ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್'.split('_'),
+	    monthsShort : 'ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬ_ಅಕ್ಟೋಬ_ನವೆಂಬ_ಡಿಸೆಂಬ'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ'.split('_'),
+	    weekdaysShort : 'ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ'.split('_'),
+	    weekdaysMin : 'ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm',
+	        LTS : 'A h:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm'
+	    },
+	    calendar : {
+	        sameDay : '[ಇಂದು] LT',
+	        nextDay : '[ನಾಳೆ] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[ನಿನ್ನೆ] LT',
+	        lastWeek : '[ಕೊನೆಯ] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s ನಂತರ',
+	        past : '%s ಹಿಂದೆ',
+	        s : 'ಕೆಲವು ಕ್ಷಣಗಳು',
+	        m : 'ಒಂದು ನಿಮಿಷ',
+	        mm : '%d ನಿಮಿಷ',
+	        h : 'ಒಂದು ಗಂಟೆ',
+	        hh : '%d ಗಂಟೆ',
+	        d : 'ಒಂದು ದಿನ',
+	        dd : '%d ದಿನ',
+	        M : 'ಒಂದು ತಿಂಗಳು',
+	        MM : '%d ತಿಂಗಳು',
+	        y : 'ಒಂದು ವರ್ಷ',
+	        yy : '%d ವರ್ಷ'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[೧೨೩೪೫೬೭೮೯೦]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    meridiemParse: /ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'ರಾತ್ರಿ') {
+	            return hour < 4 ? hour : hour + 12;
+	        } else if (meridiem === 'ಬೆಳಿಗ್ಗೆ') {
+	            return hour;
+	        } else if (meridiem === 'ಮಧ್ಯಾಹ್ನ') {
+	            return hour >= 10 ? hour : hour + 12;
+	        } else if (meridiem === 'ಸಂಜೆ') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'ರಾತ್ರಿ';
+	        } else if (hour < 10) {
+	            return 'ಬೆಳಿಗ್ಗೆ';
+	        } else if (hour < 17) {
+	            return 'ಮಧ್ಯಾಹ್ನ';
+	        } else if (hour < 20) {
+	            return 'ಸಂಜೆ';
+	        } else {
+	            return 'ರಾತ್ರಿ';
+	        }
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(ನೇ)/,
+	    ordinal : function (number) {
+	        return number + 'ನೇ';
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return kn;
+
+	})));
+
+
+/***/ },
+/* 105 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Korean [ko]
+	//! author : Kyungwook, Park : https://github.com/kyungw00k
+	//! author : Jeeeyul Lee <jeeeyul@gmail.com>
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var ko = moment.defineLocale('ko', {
+	    months : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
+	    monthsShort : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
+	    weekdays : '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
+	    weekdaysShort : '일_월_화_수_목_금_토'.split('_'),
+	    weekdaysMin : '일_월_화_수_목_금_토'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm',
+	        LTS : 'A h:mm:ss',
+	        L : 'YYYY.MM.DD',
+	        LL : 'YYYY년 MMMM D일',
+	        LLL : 'YYYY년 MMMM D일 A h:mm',
+	        LLLL : 'YYYY년 MMMM D일 dddd A h:mm',
+	        l : 'YYYY.MM.DD',
+	        ll : 'YYYY년 MMMM D일',
+	        lll : 'YYYY년 MMMM D일 A h:mm',
+	        llll : 'YYYY년 MMMM D일 dddd A h:mm'
+	    },
+	    calendar : {
+	        sameDay : '오늘 LT',
+	        nextDay : '내일 LT',
+	        nextWeek : 'dddd LT',
+	        lastDay : '어제 LT',
+	        lastWeek : '지난주 dddd LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s 후',
+	        past : '%s 전',
+	        s : '몇 초',
+	        ss : '%d초',
+	        m : '1분',
+	        mm : '%d분',
+	        h : '한 시간',
+	        hh : '%d시간',
+	        d : '하루',
+	        dd : '%d일',
+	        M : '한 달',
+	        MM : '%d달',
+	        y : '일 년',
+	        yy : '%d년'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}일/,
+	    ordinal : '%d일',
+	    meridiemParse : /오전|오후/,
+	    isPM : function (token) {
+	        return token === '오후';
+	    },
+	    meridiem : function (hour, minute, isUpper) {
+	        return hour < 12 ? '오전' : '오후';
+	    }
+	});
+
+	return ko;
+
+	})));
+
+
+/***/ },
+/* 106 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Kyrgyz [ky]
+	//! author : Chyngyz Arystan uulu : https://github.com/chyngyz
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+
+	var suffixes = {
+	    0: '-чү',
+	    1: '-чи',
+	    2: '-чи',
+	    3: '-чү',
+	    4: '-чү',
+	    5: '-чи',
+	    6: '-чы',
+	    7: '-чи',
+	    8: '-чи',
+	    9: '-чу',
+	    10: '-чу',
+	    20: '-чы',
+	    30: '-чу',
+	    40: '-чы',
+	    50: '-чү',
+	    60: '-чы',
+	    70: '-чи',
+	    80: '-чи',
+	    90: '-чу',
+	    100: '-чү'
+	};
+
+	var ky = moment.defineLocale('ky', {
+	    months : 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
+	    monthsShort : 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
+	    weekdays : 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split('_'),
+	    weekdaysShort : 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
+	    weekdaysMin : 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Бүгүн саат] LT',
+	        nextDay : '[Эртең саат] LT',
+	        nextWeek : 'dddd [саат] LT',
+	        lastDay : '[Кече саат] LT',
+	        lastWeek : '[Өткен аптанын] dddd [күнү] [саат] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s ичинде',
+	        past : '%s мурун',
+	        s : 'бирнече секунд',
+	        m : 'бир мүнөт',
+	        mm : '%d мүнөт',
+	        h : 'бир саат',
+	        hh : '%d саат',
+	        d : 'бир күн',
+	        dd : '%d күн',
+	        M : 'бир ай',
+	        MM : '%d ай',
+	        y : 'бир жыл',
+	        yy : '%d жыл'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(чи|чы|чү|чу)/,
+	    ordinal : function (number) {
+	        var a = number % 10,
+	            b = number >= 100 ? 100 : null;
+	        return number + (suffixes[number] || suffixes[a] || suffixes[b]);
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return ky;
+
+	})));
+
+
+/***/ },
+/* 107 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Luxembourgish [lb]
+	//! author : mweimerskirch : https://github.com/mweimerskirch
+	//! author : David Raison : https://github.com/kwisatz
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var format = {
+	        'm': ['eng Minutt', 'enger Minutt'],
+	        'h': ['eng Stonn', 'enger Stonn'],
+	        'd': ['een Dag', 'engem Dag'],
+	        'M': ['ee Mount', 'engem Mount'],
+	        'y': ['ee Joer', 'engem Joer']
+	    };
+	    return withoutSuffix ? format[key][0] : format[key][1];
+	}
+	function processFutureTime(string) {
+	    var number = string.substr(0, string.indexOf(' '));
+	    if (eifelerRegelAppliesToNumber(number)) {
+	        return 'a ' + string;
+	    }
+	    return 'an ' + string;
+	}
+	function processPastTime(string) {
+	    var number = string.substr(0, string.indexOf(' '));
+	    if (eifelerRegelAppliesToNumber(number)) {
+	        return 'viru ' + string;
+	    }
+	    return 'virun ' + string;
+	}
+	/**
+	 * Returns true if the word before the given number loses the '-n' ending.
+	 * e.g. 'an 10 Deeg' but 'a 5 Deeg'
+	 *
+	 * @param number {integer}
+	 * @returns {boolean}
+	 */
+	function eifelerRegelAppliesToNumber(number) {
+	    number = parseInt(number, 10);
+	    if (isNaN(number)) {
+	        return false;
+	    }
+	    if (number < 0) {
+	        // Negative Number --> always true
+	        return true;
+	    } else if (number < 10) {
+	        // Only 1 digit
+	        if (4 <= number && number <= 7) {
+	            return true;
+	        }
+	        return false;
+	    } else if (number < 100) {
+	        // 2 digits
+	        var lastDigit = number % 10, firstDigit = number / 10;
+	        if (lastDigit === 0) {
+	            return eifelerRegelAppliesToNumber(firstDigit);
+	        }
+	        return eifelerRegelAppliesToNumber(lastDigit);
+	    } else if (number < 10000) {
+	        // 3 or 4 digits --> recursively check first digit
+	        while (number >= 10) {
+	            number = number / 10;
+	        }
+	        return eifelerRegelAppliesToNumber(number);
+	    } else {
+	        // Anything larger than 4 digits: recursively check first n-3 digits
+	        number = number / 1000;
+	        return eifelerRegelAppliesToNumber(number);
+	    }
+	}
+
+	var lb = moment.defineLocale('lb', {
+	    months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
+	    monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
+	    weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
+	    weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat: {
+	        LT: 'H:mm [Auer]',
+	        LTS: 'H:mm:ss [Auer]',
+	        L: 'DD.MM.YYYY',
+	        LL: 'D. MMMM YYYY',
+	        LLL: 'D. MMMM YYYY H:mm [Auer]',
+	        LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]'
+	    },
+	    calendar: {
+	        sameDay: '[Haut um] LT',
+	        sameElse: 'L',
+	        nextDay: '[Muer um] LT',
+	        nextWeek: 'dddd [um] LT',
+	        lastDay: '[Gëschter um] LT',
+	        lastWeek: function () {
+	            // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
+	            switch (this.day()) {
+	                case 2:
+	                case 4:
+	                    return '[Leschten] dddd [um] LT';
+	                default:
+	                    return '[Leschte] dddd [um] LT';
+	            }
+	        }
+	    },
+	    relativeTime : {
+	        future : processFutureTime,
+	        past : processPastTime,
+	        s : 'e puer Sekonnen',
+	        m : processRelativeTime,
+	        mm : '%d Minutten',
+	        h : processRelativeTime,
+	        hh : '%d Stonnen',
+	        d : processRelativeTime,
+	        dd : '%d Deeg',
+	        M : processRelativeTime,
+	        MM : '%d Méint',
+	        y : processRelativeTime,
+	        yy : '%d Joer'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal: '%d.',
+	    week: {
+	        dow: 1, // Monday is the first day of the week.
+	        doy: 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return lb;
+
+	})));
+
+
+/***/ },
+/* 108 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Lao [lo]
+	//! author : Ryan Hart : https://github.com/ryanhart2
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var lo = moment.defineLocale('lo', {
+	    months : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
+	    monthsShort : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
+	    weekdays : 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
+	    weekdaysShort : 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
+	    weekdaysMin : 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'ວັນdddd D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /ຕອນເຊົ້າ|ຕອນແລງ/,
+	    isPM: function (input) {
+	        return input === 'ຕອນແລງ';
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'ຕອນເຊົ້າ';
+	        } else {
+	            return 'ຕອນແລງ';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[ມື້ນີ້ເວລາ] LT',
+	        nextDay : '[ມື້ອື່ນເວລາ] LT',
+	        nextWeek : '[ວັນ]dddd[ໜ້າເວລາ] LT',
+	        lastDay : '[ມື້ວານນີ້ເວລາ] LT',
+	        lastWeek : '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'ອີກ %s',
+	        past : '%sຜ່ານມາ',
+	        s : 'ບໍ່ເທົ່າໃດວິນາທີ',
+	        m : '1 ນາທີ',
+	        mm : '%d ນາທີ',
+	        h : '1 ຊົ່ວໂມງ',
+	        hh : '%d ຊົ່ວໂມງ',
+	        d : '1 ມື້',
+	        dd : '%d ມື້',
+	        M : '1 ເດືອນ',
+	        MM : '%d ເດືອນ',
+	        y : '1 ປີ',
+	        yy : '%d ປີ'
+	    },
+	    dayOfMonthOrdinalParse: /(ທີ່)\d{1,2}/,
+	    ordinal : function (number) {
+	        return 'ທີ່' + number;
+	    }
+	});
+
+	return lo;
+
+	})));
+
+
+/***/ },
+/* 109 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Lithuanian [lt]
+	//! author : Mindaugas Mozūras : https://github.com/mmozuras
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var units = {
+	    'm' : 'minutė_minutės_minutę',
+	    'mm': 'minutės_minučių_minutes',
+	    'h' : 'valanda_valandos_valandą',
+	    'hh': 'valandos_valandų_valandas',
+	    'd' : 'diena_dienos_dieną',
+	    'dd': 'dienos_dienų_dienas',
+	    'M' : 'mėnuo_mėnesio_mėnesį',
+	    'MM': 'mėnesiai_mėnesių_mėnesius',
+	    'y' : 'metai_metų_metus',
+	    'yy': 'metai_metų_metus'
+	};
+	function translateSeconds(number, withoutSuffix, key, isFuture) {
+	    if (withoutSuffix) {
+	        return 'kelios sekundės';
+	    } else {
+	        return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
+	    }
+	}
+	function translateSingular(number, withoutSuffix, key, isFuture) {
+	    return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);
+	}
+	function special(number) {
+	    return number % 10 === 0 || (number > 10 && number < 20);
+	}
+	function forms(key) {
+	    return units[key].split('_');
+	}
+	function translate(number, withoutSuffix, key, isFuture) {
+	    var result = number + ' ';
+	    if (number === 1) {
+	        return result + translateSingular(number, withoutSuffix, key[0], isFuture);
+	    } else if (withoutSuffix) {
+	        return result + (special(number) ? forms(key)[1] : forms(key)[0]);
+	    } else {
+	        if (isFuture) {
+	            return result + forms(key)[1];
+	        } else {
+	            return result + (special(number) ? forms(key)[1] : forms(key)[2]);
+	        }
+	    }
+	}
+	var lt = moment.defineLocale('lt', {
+	    months : {
+	        format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
+	        standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_'),
+	        isFormat: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/
+	    },
+	    monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
+	    weekdays : {
+	        format: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split('_'),
+	        standalone: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split('_'),
+	        isFormat: /dddd HH:mm/
+	    },
+	    weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
+	    weekdaysMin : 'S_P_A_T_K_Pn_Š'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY-MM-DD',
+	        LL : 'YYYY [m.] MMMM D [d.]',
+	        LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
+	        LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
+	        l : 'YYYY-MM-DD',
+	        ll : 'YYYY [m.] MMMM D [d.]',
+	        lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
+	        llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
+	    },
+	    calendar : {
+	        sameDay : '[Šiandien] LT',
+	        nextDay : '[Rytoj] LT',
+	        nextWeek : 'dddd LT',
+	        lastDay : '[Vakar] LT',
+	        lastWeek : '[Praėjusį] dddd LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'po %s',
+	        past : 'prieš %s',
+	        s : translateSeconds,
+	        m : translateSingular,
+	        mm : translate,
+	        h : translateSingular,
+	        hh : translate,
+	        d : translateSingular,
+	        dd : translate,
+	        M : translateSingular,
+	        MM : translate,
+	        y : translateSingular,
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-oji/,
+	    ordinal : function (number) {
+	        return number + '-oji';
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return lt;
+
+	})));
+
+
+/***/ },
+/* 110 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Latvian [lv]
+	//! author : Kristaps Karlsons : https://github.com/skakri
+	//! author : Jānis Elmeris : https://github.com/JanisE
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var units = {
+	    'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
+	    'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
+	    'h': 'stundas_stundām_stunda_stundas'.split('_'),
+	    'hh': 'stundas_stundām_stunda_stundas'.split('_'),
+	    'd': 'dienas_dienām_diena_dienas'.split('_'),
+	    'dd': 'dienas_dienām_diena_dienas'.split('_'),
+	    'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
+	    'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
+	    'y': 'gada_gadiem_gads_gadi'.split('_'),
+	    'yy': 'gada_gadiem_gads_gadi'.split('_')
+	};
+	/**
+	 * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
+	 */
+	function format(forms, number, withoutSuffix) {
+	    if (withoutSuffix) {
+	        // E.g. "21 minūte", "3 minūtes".
+	        return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3];
+	    } else {
+	        // E.g. "21 minūtes" as in "pēc 21 minūtes".
+	        // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
+	        return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1];
+	    }
+	}
+	function relativeTimeWithPlural(number, withoutSuffix, key) {
+	    return number + ' ' + format(units[key], number, withoutSuffix);
+	}
+	function relativeTimeWithSingular(number, withoutSuffix, key) {
+	    return format(units[key], number, withoutSuffix);
+	}
+	function relativeSeconds(number, withoutSuffix) {
+	    return withoutSuffix ? 'dažas sekundes' : 'dažām sekundēm';
+	}
+
+	var lv = moment.defineLocale('lv', {
+	    months : 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
+	    monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
+	    weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
+	    weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
+	    weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY.',
+	        LL : 'YYYY. [gada] D. MMMM',
+	        LLL : 'YYYY. [gada] D. MMMM, HH:mm',
+	        LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Šodien pulksten] LT',
+	        nextDay : '[Rīt pulksten] LT',
+	        nextWeek : 'dddd [pulksten] LT',
+	        lastDay : '[Vakar pulksten] LT',
+	        lastWeek : '[Pagājušā] dddd [pulksten] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'pēc %s',
+	        past : 'pirms %s',
+	        s : relativeSeconds,
+	        m : relativeTimeWithSingular,
+	        mm : relativeTimeWithPlural,
+	        h : relativeTimeWithSingular,
+	        hh : relativeTimeWithPlural,
+	        d : relativeTimeWithSingular,
+	        dd : relativeTimeWithPlural,
+	        M : relativeTimeWithSingular,
+	        MM : relativeTimeWithPlural,
+	        y : relativeTimeWithSingular,
+	        yy : relativeTimeWithPlural
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return lv;
+
+	})));
+
+
+/***/ },
+/* 111 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Montenegrin [me]
+	//! author : Miodrag Nikač <miodrag@restartit.me> : https://github.com/miodragnikac
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var translator = {
+	    words: { //Different grammatical cases
+	        m: ['jedan minut', 'jednog minuta'],
+	        mm: ['minut', 'minuta', 'minuta'],
+	        h: ['jedan sat', 'jednog sata'],
+	        hh: ['sat', 'sata', 'sati'],
+	        dd: ['dan', 'dana', 'dana'],
+	        MM: ['mjesec', 'mjeseca', 'mjeseci'],
+	        yy: ['godina', 'godine', 'godina']
+	    },
+	    correctGrammaticalCase: function (number, wordKey) {
+	        return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
+	    },
+	    translate: function (number, withoutSuffix, key) {
+	        var wordKey = translator.words[key];
+	        if (key.length === 1) {
+	            return withoutSuffix ? wordKey[0] : wordKey[1];
+	        } else {
+	            return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
+	        }
+	    }
+	};
+
+	var me = moment.defineLocale('me', {
+	    months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
+	    monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
+	    weekdaysShort: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
+	    weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat: {
+	        LT: 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L: 'DD.MM.YYYY',
+	        LL: 'D. MMMM YYYY',
+	        LLL: 'D. MMMM YYYY H:mm',
+	        LLLL: 'dddd, D. MMMM YYYY H:mm'
+	    },
+	    calendar: {
+	        sameDay: '[danas u] LT',
+	        nextDay: '[sjutra u] LT',
+
+	        nextWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[u] [nedjelju] [u] LT';
+	                case 3:
+	                    return '[u] [srijedu] [u] LT';
+	                case 6:
+	                    return '[u] [subotu] [u] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[u] dddd [u] LT';
+	            }
+	        },
+	        lastDay  : '[juče u] LT',
+	        lastWeek : function () {
+	            var lastWeekDays = [
+	                '[prošle] [nedjelje] [u] LT',
+	                '[prošlog] [ponedjeljka] [u] LT',
+	                '[prošlog] [utorka] [u] LT',
+	                '[prošle] [srijede] [u] LT',
+	                '[prošlog] [četvrtka] [u] LT',
+	                '[prošlog] [petka] [u] LT',
+	                '[prošle] [subote] [u] LT'
+	            ];
+	            return lastWeekDays[this.day()];
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'za %s',
+	        past   : 'prije %s',
+	        s      : 'nekoliko sekundi',
+	        m      : translator.translate,
+	        mm     : translator.translate,
+	        h      : translator.translate,
+	        hh     : translator.translate,
+	        d      : 'dan',
+	        dd     : translator.translate,
+	        M      : 'mjesec',
+	        MM     : translator.translate,
+	        y      : 'godinu',
+	        yy     : translator.translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return me;
+
+	})));
+
+
+/***/ },
+/* 112 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Maori [mi]
+	//! author : John Corrigan <robbiecloset@gmail.com> : https://github.com/johnideal
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var mi = moment.defineLocale('mi', {
+	    months: 'Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea'.split('_'),
+	    monthsShort: 'Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split('_'),
+	    monthsRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
+	    monthsStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
+	    monthsShortRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
+	    monthsShortStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
+	    weekdays: 'Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei'.split('_'),
+	    weekdaysShort: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
+	    weekdaysMin: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
+	    longDateFormat: {
+	        LT: 'HH:mm',
+	        LTS: 'HH:mm:ss',
+	        L: 'DD/MM/YYYY',
+	        LL: 'D MMMM YYYY',
+	        LLL: 'D MMMM YYYY [i] HH:mm',
+	        LLLL: 'dddd, D MMMM YYYY [i] HH:mm'
+	    },
+	    calendar: {
+	        sameDay: '[i teie mahana, i] LT',
+	        nextDay: '[apopo i] LT',
+	        nextWeek: 'dddd [i] LT',
+	        lastDay: '[inanahi i] LT',
+	        lastWeek: 'dddd [whakamutunga i] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime: {
+	        future: 'i roto i %s',
+	        past: '%s i mua',
+	        s: 'te hēkona ruarua',
+	        m: 'he meneti',
+	        mm: '%d meneti',
+	        h: 'te haora',
+	        hh: '%d haora',
+	        d: 'he ra',
+	        dd: '%d ra',
+	        M: 'he marama',
+	        MM: '%d marama',
+	        y: 'he tau',
+	        yy: '%d tau'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}º/,
+	    ordinal: '%dº',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return mi;
+
+	})));
+
+
+/***/ },
+/* 113 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Macedonian [mk]
+	//! author : Borislav Mickov : https://github.com/B0k0
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var mk = moment.defineLocale('mk', {
+	    months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
+	    monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
+	    weekdays : 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
+	    weekdaysShort : 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
+	    weekdaysMin : 'нe_пo_вт_ср_че_пе_сa'.split('_'),
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'D.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY H:mm',
+	        LLLL : 'dddd, D MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Денес во] LT',
+	        nextDay : '[Утре во] LT',
+	        nextWeek : '[Во] dddd [во] LT',
+	        lastDay : '[Вчера во] LT',
+	        lastWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                case 3:
+	                case 6:
+	                    return '[Изминатата] dddd [во] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[Изминатиот] dddd [во] LT';
+	            }
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'после %s',
+	        past : 'пред %s',
+	        s : 'неколку секунди',
+	        m : 'минута',
+	        mm : '%d минути',
+	        h : 'час',
+	        hh : '%d часа',
+	        d : 'ден',
+	        dd : '%d дена',
+	        M : 'месец',
+	        MM : '%d месеци',
+	        y : 'година',
+	        yy : '%d години'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
+	    ordinal : function (number) {
+	        var lastDigit = number % 10,
+	            last2Digits = number % 100;
+	        if (number === 0) {
+	            return number + '-ев';
+	        } else if (last2Digits === 0) {
+	            return number + '-ен';
+	        } else if (last2Digits > 10 && last2Digits < 20) {
+	            return number + '-ти';
+	        } else if (lastDigit === 1) {
+	            return number + '-ви';
+	        } else if (lastDigit === 2) {
+	            return number + '-ри';
+	        } else if (lastDigit === 7 || lastDigit === 8) {
+	            return number + '-ми';
+	        } else {
+	            return number + '-ти';
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return mk;
+
+	})));
+
+
+/***/ },
+/* 114 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Malayalam [ml]
+	//! author : Floyd Pink : https://github.com/floydpink
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var ml = moment.defineLocale('ml', {
+	    months : 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
+	    monthsShort : 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split('_'),
+	    weekdaysShort : 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
+	    weekdaysMin : 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm -നു',
+	        LTS : 'A h:mm:ss -നു',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm -നു',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm -നു'
+	    },
+	    calendar : {
+	        sameDay : '[ഇന്ന്] LT',
+	        nextDay : '[നാളെ] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[ഇന്നലെ] LT',
+	        lastWeek : '[കഴിഞ്ഞ] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s കഴിഞ്ഞ്',
+	        past : '%s മുൻപ്',
+	        s : 'അൽപ നിമിഷങ്ങൾ',
+	        m : 'ഒരു മിനിറ്റ്',
+	        mm : '%d മിനിറ്റ്',
+	        h : 'ഒരു മണിക്കൂർ',
+	        hh : '%d മണിക്കൂർ',
+	        d : 'ഒരു ദിവസം',
+	        dd : '%d ദിവസം',
+	        M : 'ഒരു മാസം',
+	        MM : '%d മാസം',
+	        y : 'ഒരു വർഷം',
+	        yy : '%d വർഷം'
+	    },
+	    meridiemParse: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if ((meridiem === 'രാത്രി' && hour >= 4) ||
+	                meridiem === 'ഉച്ച കഴിഞ്ഞ്' ||
+	                meridiem === 'വൈകുന്നേരം') {
+	            return hour + 12;
+	        } else {
+	            return hour;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'രാത്രി';
+	        } else if (hour < 12) {
+	            return 'രാവിലെ';
+	        } else if (hour < 17) {
+	            return 'ഉച്ച കഴിഞ്ഞ്';
+	        } else if (hour < 20) {
+	            return 'വൈകുന്നേരം';
+	        } else {
+	            return 'രാത്രി';
+	        }
+	    }
+	});
+
+	return ml;
+
+	})));
+
+
+/***/ },
+/* 115 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Marathi [mr]
+	//! author : Harshad Kale : https://github.com/kalehv
+	//! author : Vivek Athalye : https://github.com/vnathalye
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '१',
+	    '2': '२',
+	    '3': '३',
+	    '4': '४',
+	    '5': '५',
+	    '6': '६',
+	    '7': '७',
+	    '8': '८',
+	    '9': '९',
+	    '0': '०'
+	};
+	var numberMap = {
+	    '१': '1',
+	    '२': '2',
+	    '३': '3',
+	    '४': '4',
+	    '५': '5',
+	    '६': '6',
+	    '७': '7',
+	    '८': '8',
+	    '९': '9',
+	    '०': '0'
+	};
+
+	function relativeTimeMr(number, withoutSuffix, string, isFuture)
+	{
+	    var output = '';
+	    if (withoutSuffix) {
+	        switch (string) {
+	            case 's': output = 'काही सेकंद'; break;
+	            case 'm': output = 'एक मिनिट'; break;
+	            case 'mm': output = '%d मिनिटे'; break;
+	            case 'h': output = 'एक तास'; break;
+	            case 'hh': output = '%d तास'; break;
+	            case 'd': output = 'एक दिवस'; break;
+	            case 'dd': output = '%d दिवस'; break;
+	            case 'M': output = 'एक महिना'; break;
+	            case 'MM': output = '%d महिने'; break;
+	            case 'y': output = 'एक वर्ष'; break;
+	            case 'yy': output = '%d वर्षे'; break;
+	        }
+	    }
+	    else {
+	        switch (string) {
+	            case 's': output = 'काही सेकंदां'; break;
+	            case 'm': output = 'एका मिनिटा'; break;
+	            case 'mm': output = '%d मिनिटां'; break;
+	            case 'h': output = 'एका तासा'; break;
+	            case 'hh': output = '%d तासां'; break;
+	            case 'd': output = 'एका दिवसा'; break;
+	            case 'dd': output = '%d दिवसां'; break;
+	            case 'M': output = 'एका महिन्या'; break;
+	            case 'MM': output = '%d महिन्यां'; break;
+	            case 'y': output = 'एका वर्षा'; break;
+	            case 'yy': output = '%d वर्षां'; break;
+	        }
+	    }
+	    return output.replace(/%d/i, number);
+	}
+
+	var mr = moment.defineLocale('mr', {
+	    months : 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split('_'),
+	    monthsShort: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
+	    weekdaysShort : 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
+	    weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm वाजता',
+	        LTS : 'A h:mm:ss वाजता',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm वाजता',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm वाजता'
+	    },
+	    calendar : {
+	        sameDay : '[आज] LT',
+	        nextDay : '[उद्या] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[काल] LT',
+	        lastWeek: '[मागील] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future: '%sमध्ये',
+	        past: '%sपूर्वी',
+	        s: relativeTimeMr,
+	        m: relativeTimeMr,
+	        mm: relativeTimeMr,
+	        h: relativeTimeMr,
+	        hh: relativeTimeMr,
+	        d: relativeTimeMr,
+	        dd: relativeTimeMr,
+	        M: relativeTimeMr,
+	        MM: relativeTimeMr,
+	        y: relativeTimeMr,
+	        yy: relativeTimeMr
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[१२३४५६७८९०]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    meridiemParse: /रात्री|सकाळी|दुपारी|सायंकाळी/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'रात्री') {
+	            return hour < 4 ? hour : hour + 12;
+	        } else if (meridiem === 'सकाळी') {
+	            return hour;
+	        } else if (meridiem === 'दुपारी') {
+	            return hour >= 10 ? hour : hour + 12;
+	        } else if (meridiem === 'सायंकाळी') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem: function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'रात्री';
+	        } else if (hour < 10) {
+	            return 'सकाळी';
+	        } else if (hour < 17) {
+	            return 'दुपारी';
+	        } else if (hour < 20) {
+	            return 'सायंकाळी';
+	        } else {
+	            return 'रात्री';
+	        }
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return mr;
+
+	})));
+
+
+/***/ },
+/* 116 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Malay [ms]
+	//! author : Weldan Jamili : https://github.com/weldan
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var ms = moment.defineLocale('ms', {
+	    months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
+	    monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
+	    weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
+	    weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
+	    weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH.mm',
+	        LTS : 'HH.mm.ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY [pukul] HH.mm',
+	        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
+	    },
+	    meridiemParse: /pagi|tengahari|petang|malam/,
+	    meridiemHour: function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'pagi') {
+	            return hour;
+	        } else if (meridiem === 'tengahari') {
+	            return hour >= 11 ? hour : hour + 12;
+	        } else if (meridiem === 'petang' || meridiem === 'malam') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 11) {
+	            return 'pagi';
+	        } else if (hours < 15) {
+	            return 'tengahari';
+	        } else if (hours < 19) {
+	            return 'petang';
+	        } else {
+	            return 'malam';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[Hari ini pukul] LT',
+	        nextDay : '[Esok pukul] LT',
+	        nextWeek : 'dddd [pukul] LT',
+	        lastDay : '[Kelmarin pukul] LT',
+	        lastWeek : 'dddd [lepas pukul] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'dalam %s',
+	        past : '%s yang lepas',
+	        s : 'beberapa saat',
+	        m : 'seminit',
+	        mm : '%d minit',
+	        h : 'sejam',
+	        hh : '%d jam',
+	        d : 'sehari',
+	        dd : '%d hari',
+	        M : 'sebulan',
+	        MM : '%d bulan',
+	        y : 'setahun',
+	        yy : '%d tahun'
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return ms;
+
+	})));
+
+
+/***/ },
+/* 117 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Malay [ms-my]
+	//! note : DEPRECATED, the correct one is [ms]
+	//! author : Weldan Jamili : https://github.com/weldan
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var msMy = moment.defineLocale('ms-my', {
+	    months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
+	    monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
+	    weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
+	    weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
+	    weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH.mm',
+	        LTS : 'HH.mm.ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY [pukul] HH.mm',
+	        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
+	    },
+	    meridiemParse: /pagi|tengahari|petang|malam/,
+	    meridiemHour: function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'pagi') {
+	            return hour;
+	        } else if (meridiem === 'tengahari') {
+	            return hour >= 11 ? hour : hour + 12;
+	        } else if (meridiem === 'petang' || meridiem === 'malam') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 11) {
+	            return 'pagi';
+	        } else if (hours < 15) {
+	            return 'tengahari';
+	        } else if (hours < 19) {
+	            return 'petang';
+	        } else {
+	            return 'malam';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[Hari ini pukul] LT',
+	        nextDay : '[Esok pukul] LT',
+	        nextWeek : 'dddd [pukul] LT',
+	        lastDay : '[Kelmarin pukul] LT',
+	        lastWeek : 'dddd [lepas pukul] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'dalam %s',
+	        past : '%s yang lepas',
+	        s : 'beberapa saat',
+	        m : 'seminit',
+	        mm : '%d minit',
+	        h : 'sejam',
+	        hh : '%d jam',
+	        d : 'sehari',
+	        dd : '%d hari',
+	        M : 'sebulan',
+	        MM : '%d bulan',
+	        y : 'setahun',
+	        yy : '%d tahun'
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return msMy;
+
+	})));
+
+
+/***/ },
+/* 118 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Burmese [my]
+	//! author : Squar team, mysquar.com
+	//! author : David Rossellat : https://github.com/gholadr
+	//! author : Tin Aung Lin : https://github.com/thanyawzinmin
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '၁',
+	    '2': '၂',
+	    '3': '၃',
+	    '4': '၄',
+	    '5': '၅',
+	    '6': '၆',
+	    '7': '၇',
+	    '8': '၈',
+	    '9': '၉',
+	    '0': '၀'
+	};
+	var numberMap = {
+	    '၁': '1',
+	    '၂': '2',
+	    '၃': '3',
+	    '၄': '4',
+	    '၅': '5',
+	    '၆': '6',
+	    '၇': '7',
+	    '၈': '8',
+	    '၉': '9',
+	    '၀': '0'
+	};
+
+	var my = moment.defineLocale('my', {
+	    months: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split('_'),
+	    monthsShort: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
+	    weekdays: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split('_'),
+	    weekdaysShort: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
+	    weekdaysMin: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
+
+	    longDateFormat: {
+	        LT: 'HH:mm',
+	        LTS: 'HH:mm:ss',
+	        L: 'DD/MM/YYYY',
+	        LL: 'D MMMM YYYY',
+	        LLL: 'D MMMM YYYY HH:mm',
+	        LLLL: 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar: {
+	        sameDay: '[ယနေ.] LT [မှာ]',
+	        nextDay: '[မနက်ဖြန်] LT [မှာ]',
+	        nextWeek: 'dddd LT [မှာ]',
+	        lastDay: '[မနေ.က] LT [မှာ]',
+	        lastWeek: '[ပြီးခဲ့သော] dddd LT [မှာ]',
+	        sameElse: 'L'
+	    },
+	    relativeTime: {
+	        future: 'လာမည့် %s မှာ',
+	        past: 'လွန်ခဲ့သော %s က',
+	        s: 'စက္ကန်.အနည်းငယ်',
+	        m: 'တစ်မိနစ်',
+	        mm: '%d မိနစ်',
+	        h: 'တစ်နာရီ',
+	        hh: '%d နာရီ',
+	        d: 'တစ်ရက်',
+	        dd: '%d ရက်',
+	        M: 'တစ်လ',
+	        MM: '%d လ',
+	        y: 'တစ်နှစ်',
+	        yy: '%d နှစ်'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    week: {
+	        dow: 1, // Monday is the first day of the week.
+	        doy: 4 // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return my;
+
+	})));
+
+
+/***/ },
+/* 119 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Norwegian Bokmål [nb]
+	//! authors : Espen Hovlandsdal : https://github.com/rexxars
+	//!           Sigurd Gartmann : https://github.com/sigurdga
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var nb = moment.defineLocale('nb', {
+	    months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
+	    monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
+	    weekdaysShort : 'sø._ma._ti._on._to._fr._lø.'.split('_'),
+	    weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY [kl.] HH:mm',
+	        LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[i dag kl.] LT',
+	        nextDay: '[i morgen kl.] LT',
+	        nextWeek: 'dddd [kl.] LT',
+	        lastDay: '[i går kl.] LT',
+	        lastWeek: '[forrige] dddd [kl.] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'om %s',
+	        past : '%s siden',
+	        s : 'noen sekunder',
+	        m : 'ett minutt',
+	        mm : '%d minutter',
+	        h : 'en time',
+	        hh : '%d timer',
+	        d : 'en dag',
+	        dd : '%d dager',
+	        M : 'en måned',
+	        MM : '%d måneder',
+	        y : 'ett år',
+	        yy : '%d år'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return nb;
+
+	})));
+
+
+/***/ },
+/* 120 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Nepalese [ne]
+	//! author : suvash : https://github.com/suvash
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '१',
+	    '2': '२',
+	    '3': '३',
+	    '4': '४',
+	    '5': '५',
+	    '6': '६',
+	    '7': '७',
+	    '8': '८',
+	    '9': '९',
+	    '0': '०'
+	};
+	var numberMap = {
+	    '१': '1',
+	    '२': '2',
+	    '३': '3',
+	    '४': '4',
+	    '५': '5',
+	    '६': '6',
+	    '७': '7',
+	    '८': '8',
+	    '९': '9',
+	    '०': '0'
+	};
+
+	var ne = moment.defineLocale('ne', {
+	    months : 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split('_'),
+	    monthsShort : 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split('_'),
+	    weekdaysShort : 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
+	    weekdaysMin : 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'Aको h:mm बजे',
+	        LTS : 'Aको h:mm:ss बजे',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, Aको h:mm बजे',
+	        LLLL : 'dddd, D MMMM YYYY, Aको h:mm बजे'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[१२३४५६७८९०]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    meridiemParse: /राति|बिहान|दिउँसो|साँझ/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'राति') {
+	            return hour < 4 ? hour : hour + 12;
+	        } else if (meridiem === 'बिहान') {
+	            return hour;
+	        } else if (meridiem === 'दिउँसो') {
+	            return hour >= 10 ? hour : hour + 12;
+	        } else if (meridiem === 'साँझ') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 3) {
+	            return 'राति';
+	        } else if (hour < 12) {
+	            return 'बिहान';
+	        } else if (hour < 16) {
+	            return 'दिउँसो';
+	        } else if (hour < 20) {
+	            return 'साँझ';
+	        } else {
+	            return 'राति';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[आज] LT',
+	        nextDay : '[भोलि] LT',
+	        nextWeek : '[आउँदो] dddd[,] LT',
+	        lastDay : '[हिजो] LT',
+	        lastWeek : '[गएको] dddd[,] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%sमा',
+	        past : '%s अगाडि',
+	        s : 'केही क्षण',
+	        m : 'एक मिनेट',
+	        mm : '%d मिनेट',
+	        h : 'एक घण्टा',
+	        hh : '%d घण्टा',
+	        d : 'एक दिन',
+	        dd : '%d दिन',
+	        M : 'एक महिना',
+	        MM : '%d महिना',
+	        y : 'एक बर्ष',
+	        yy : '%d बर्ष'
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return ne;
+
+	})));
+
+
+/***/ },
+/* 121 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Dutch [nl]
+	//! author : Joris Röling : https://github.com/jorisroling
+	//! author : Jacob Middag : https://github.com/middagj
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_');
+	var monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
+
+	var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
+	var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
+
+	var nl = moment.defineLocale('nl', {
+	    months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
+	    monthsShort : function (m, format) {
+	        if (!m) {
+	            return monthsShortWithDots;
+	        } else if (/-MMM-/.test(format)) {
+	            return monthsShortWithoutDots[m.month()];
+	        } else {
+	            return monthsShortWithDots[m.month()];
+	        }
+	    },
+
+	    monthsRegex: monthsRegex,
+	    monthsShortRegex: monthsRegex,
+	    monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
+	    monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
+
+	    monthsParse : monthsParse,
+	    longMonthsParse : monthsParse,
+	    shortMonthsParse : monthsParse,
+
+	    weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
+	    weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
+	    weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD-MM-YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[vandaag om] LT',
+	        nextDay: '[morgen om] LT',
+	        nextWeek: 'dddd [om] LT',
+	        lastDay: '[gisteren om] LT',
+	        lastWeek: '[afgelopen] dddd [om] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'over %s',
+	        past : '%s geleden',
+	        s : 'een paar seconden',
+	        m : 'één minuut',
+	        mm : '%d minuten',
+	        h : 'één uur',
+	        hh : '%d uur',
+	        d : 'één dag',
+	        dd : '%d dagen',
+	        M : 'één maand',
+	        MM : '%d maanden',
+	        y : 'één jaar',
+	        yy : '%d jaar'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+	    ordinal : function (number) {
+	        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return nl;
+
+	})));
+
+
+/***/ },
+/* 122 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Dutch (Belgium) [nl-be]
+	//! author : Joris Röling : https://github.com/jorisroling
+	//! author : Jacob Middag : https://github.com/middagj
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_');
+	var monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
+
+	var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
+	var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
+
+	var nlBe = moment.defineLocale('nl-be', {
+	    months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
+	    monthsShort : function (m, format) {
+	        if (!m) {
+	            return monthsShortWithDots;
+	        } else if (/-MMM-/.test(format)) {
+	            return monthsShortWithoutDots[m.month()];
+	        } else {
+	            return monthsShortWithDots[m.month()];
+	        }
+	    },
+
+	    monthsRegex: monthsRegex,
+	    monthsShortRegex: monthsRegex,
+	    monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
+	    monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
+
+	    monthsParse : monthsParse,
+	    longMonthsParse : monthsParse,
+	    shortMonthsParse : monthsParse,
+
+	    weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
+	    weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
+	    weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[vandaag om] LT',
+	        nextDay: '[morgen om] LT',
+	        nextWeek: 'dddd [om] LT',
+	        lastDay: '[gisteren om] LT',
+	        lastWeek: '[afgelopen] dddd [om] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'over %s',
+	        past : '%s geleden',
+	        s : 'een paar seconden',
+	        m : 'één minuut',
+	        mm : '%d minuten',
+	        h : 'één uur',
+	        hh : '%d uur',
+	        d : 'één dag',
+	        dd : '%d dagen',
+	        M : 'één maand',
+	        MM : '%d maanden',
+	        y : 'één jaar',
+	        yy : '%d jaar'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+	    ordinal : function (number) {
+	        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return nlBe;
+
+	})));
+
+
+/***/ },
+/* 123 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Nynorsk [nn]
+	//! author : https://github.com/mechuwind
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var nn = moment.defineLocale('nn', {
+	    months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
+	    monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
+	    weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
+	    weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
+	    weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY [kl.] H:mm',
+	        LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[I dag klokka] LT',
+	        nextDay: '[I morgon klokka] LT',
+	        nextWeek: 'dddd [klokka] LT',
+	        lastDay: '[I går klokka] LT',
+	        lastWeek: '[Føregåande] dddd [klokka] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'om %s',
+	        past : '%s sidan',
+	        s : 'nokre sekund',
+	        m : 'eit minutt',
+	        mm : '%d minutt',
+	        h : 'ein time',
+	        hh : '%d timar',
+	        d : 'ein dag',
+	        dd : '%d dagar',
+	        M : 'ein månad',
+	        MM : '%d månader',
+	        y : 'eit år',
+	        yy : '%d år'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return nn;
+
+	})));
+
+
+/***/ },
+/* 124 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Punjabi (India) [pa-in]
+	//! author : Harpreet Singh : https://github.com/harpreetkhalsagtbit
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '੧',
+	    '2': '੨',
+	    '3': '੩',
+	    '4': '੪',
+	    '5': '੫',
+	    '6': '੬',
+	    '7': '੭',
+	    '8': '੮',
+	    '9': '੯',
+	    '0': '੦'
+	};
+	var numberMap = {
+	    '੧': '1',
+	    '੨': '2',
+	    '੩': '3',
+	    '੪': '4',
+	    '੫': '5',
+	    '੬': '6',
+	    '੭': '7',
+	    '੮': '8',
+	    '੯': '9',
+	    '੦': '0'
+	};
+
+	var paIn = moment.defineLocale('pa-in', {
+	    // There are months name as per Nanakshahi Calender but they are not used as rigidly in modern Punjabi.
+	    months : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
+	    monthsShort : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
+	    weekdays : 'ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ'.split('_'),
+	    weekdaysShort : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
+	    weekdaysMin : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm ਵਜੇ',
+	        LTS : 'A h:mm:ss ਵਜੇ',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm ਵਜੇ',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm ਵਜੇ'
+	    },
+	    calendar : {
+	        sameDay : '[ਅਜ] LT',
+	        nextDay : '[ਕਲ] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[ਕਲ] LT',
+	        lastWeek : '[ਪਿਛਲੇ] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s ਵਿੱਚ',
+	        past : '%s ਪਿਛਲੇ',
+	        s : 'ਕੁਝ ਸਕਿੰਟ',
+	        m : 'ਇਕ ਮਿੰਟ',
+	        mm : '%d ਮਿੰਟ',
+	        h : 'ਇੱਕ ਘੰਟਾ',
+	        hh : '%d ਘੰਟੇ',
+	        d : 'ਇੱਕ ਦਿਨ',
+	        dd : '%d ਦਿਨ',
+	        M : 'ਇੱਕ ਮਹੀਨਾ',
+	        MM : '%d ਮਹੀਨੇ',
+	        y : 'ਇੱਕ ਸਾਲ',
+	        yy : '%d ਸਾਲ'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[੧੨੩੪੫੬੭੮੯੦]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
+	    // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
+	    meridiemParse: /ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'ਰਾਤ') {
+	            return hour < 4 ? hour : hour + 12;
+	        } else if (meridiem === 'ਸਵੇਰ') {
+	            return hour;
+	        } else if (meridiem === 'ਦੁਪਹਿਰ') {
+	            return hour >= 10 ? hour : hour + 12;
+	        } else if (meridiem === 'ਸ਼ਾਮ') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'ਰਾਤ';
+	        } else if (hour < 10) {
+	            return 'ਸਵੇਰ';
+	        } else if (hour < 17) {
+	            return 'ਦੁਪਹਿਰ';
+	        } else if (hour < 20) {
+	            return 'ਸ਼ਾਮ';
+	        } else {
+	            return 'ਰਾਤ';
+	        }
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return paIn;
+
+	})));
+
+
+/***/ },
+/* 125 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Polish [pl]
+	//! author : Rafal Hirsz : https://github.com/evoL
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_');
+	var monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');
+	function plural(n) {
+	    return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);
+	}
+	function translate(number, withoutSuffix, key) {
+	    var result = number + ' ';
+	    switch (key) {
+	        case 'm':
+	            return withoutSuffix ? 'minuta' : 'minutę';
+	        case 'mm':
+	            return result + (plural(number) ? 'minuty' : 'minut');
+	        case 'h':
+	            return withoutSuffix  ? 'godzina'  : 'godzinę';
+	        case 'hh':
+	            return result + (plural(number) ? 'godziny' : 'godzin');
+	        case 'MM':
+	            return result + (plural(number) ? 'miesiące' : 'miesięcy');
+	        case 'yy':
+	            return result + (plural(number) ? 'lata' : 'lat');
+	    }
+	}
+
+	var pl = moment.defineLocale('pl', {
+	    months : function (momentToFormat, format) {
+	        if (!momentToFormat) {
+	            return monthsNominative;
+	        } else if (format === '') {
+	            // Hack: if format empty we know this is used to generate
+	            // RegExp by moment. Give then back both valid forms of months
+	            // in RegExp ready format.
+	            return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')';
+	        } else if (/D MMMM/.test(format)) {
+	            return monthsSubjective[momentToFormat.month()];
+	        } else {
+	            return monthsNominative[momentToFormat.month()];
+	        }
+	    },
+	    monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
+	    weekdays : 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
+	    weekdaysShort : 'ndz_pon_wt_śr_czw_pt_sob'.split('_'),
+	    weekdaysMin : 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Dziś o] LT',
+	        nextDay: '[Jutro o] LT',
+	        nextWeek: '[W] dddd [o] LT',
+	        lastDay: '[Wczoraj o] LT',
+	        lastWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[W zeszłą niedzielę o] LT';
+	                case 3:
+	                    return '[W zeszłą środę o] LT';
+	                case 6:
+	                    return '[W zeszłą sobotę o] LT';
+	                default:
+	                    return '[W zeszły] dddd [o] LT';
+	            }
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'za %s',
+	        past : '%s temu',
+	        s : 'kilka sekund',
+	        m : translate,
+	        mm : translate,
+	        h : translate,
+	        hh : translate,
+	        d : '1 dzień',
+	        dd : '%d dni',
+	        M : 'miesiąc',
+	        MM : translate,
+	        y : 'rok',
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return pl;
+
+	})));
+
+
+/***/ },
+/* 126 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Portuguese [pt]
+	//! author : Jefferson : https://github.com/jalex79
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var pt = moment.defineLocale('pt', {
+	    months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
+	    monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
+	    weekdays : 'Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado'.split('_'),
+	    weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
+	    weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D [de] MMMM [de] YYYY',
+	        LLL : 'D [de] MMMM [de] YYYY HH:mm',
+	        LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Hoje às] LT',
+	        nextDay: '[Amanhã às] LT',
+	        nextWeek: 'dddd [às] LT',
+	        lastDay: '[Ontem às] LT',
+	        lastWeek: function () {
+	            return (this.day() === 0 || this.day() === 6) ?
+	                '[Último] dddd [às] LT' : // Saturday + Sunday
+	                '[Última] dddd [às] LT'; // Monday - Friday
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'em %s',
+	        past : 'há %s',
+	        s : 'segundos',
+	        m : 'um minuto',
+	        mm : '%d minutos',
+	        h : 'uma hora',
+	        hh : '%d horas',
+	        d : 'um dia',
+	        dd : '%d dias',
+	        M : 'um mês',
+	        MM : '%d meses',
+	        y : 'um ano',
+	        yy : '%d anos'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}º/,
+	    ordinal : '%dº',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return pt;
+
+	})));
+
+
+/***/ },
+/* 127 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Portuguese (Brazil) [pt-br]
+	//! author : Caio Ribeiro Pereira : https://github.com/caio-ribeiro-pereira
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var ptBr = moment.defineLocale('pt-br', {
+	    months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
+	    monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
+	    weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
+	    weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
+	    weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D [de] MMMM [de] YYYY',
+	        LLL : 'D [de] MMMM [de] YYYY [às] HH:mm',
+	        LLLL : 'dddd, D [de] MMMM [de] YYYY [às] HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Hoje às] LT',
+	        nextDay: '[Amanhã às] LT',
+	        nextWeek: 'dddd [às] LT',
+	        lastDay: '[Ontem às] LT',
+	        lastWeek: function () {
+	            return (this.day() === 0 || this.day() === 6) ?
+	                '[Último] dddd [às] LT' : // Saturday + Sunday
+	                '[Última] dddd [às] LT'; // Monday - Friday
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'em %s',
+	        past : '%s atrás',
+	        s : 'poucos segundos',
+	        m : 'um minuto',
+	        mm : '%d minutos',
+	        h : 'uma hora',
+	        hh : '%d horas',
+	        d : 'um dia',
+	        dd : '%d dias',
+	        M : 'um mês',
+	        MM : '%d meses',
+	        y : 'um ano',
+	        yy : '%d anos'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}º/,
+	    ordinal : '%dº'
+	});
+
+	return ptBr;
+
+	})));
+
+
+/***/ },
+/* 128 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Romanian [ro]
+	//! author : Vlad Gurdiga : https://github.com/gurdiga
+	//! author : Valentin Agachi : https://github.com/avaly
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function relativeTimeWithPlural(number, withoutSuffix, key) {
+	    var format = {
+	            'mm': 'minute',
+	            'hh': 'ore',
+	            'dd': 'zile',
+	            'MM': 'luni',
+	            'yy': 'ani'
+	        },
+	        separator = ' ';
+	    if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
+	        separator = ' de ';
+	    }
+	    return number + separator + format[key];
+	}
+
+	var ro = moment.defineLocale('ro', {
+	    months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
+	    monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
+	    weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
+	    weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY H:mm',
+	        LLLL : 'dddd, D MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay: '[azi la] LT',
+	        nextDay: '[mâine la] LT',
+	        nextWeek: 'dddd [la] LT',
+	        lastDay: '[ieri la] LT',
+	        lastWeek: '[fosta] dddd [la] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'peste %s',
+	        past : '%s în urmă',
+	        s : 'câteva secunde',
+	        m : 'un minut',
+	        mm : relativeTimeWithPlural,
+	        h : 'o oră',
+	        hh : relativeTimeWithPlural,
+	        d : 'o zi',
+	        dd : relativeTimeWithPlural,
+	        M : 'o lună',
+	        MM : relativeTimeWithPlural,
+	        y : 'un an',
+	        yy : relativeTimeWithPlural
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return ro;
+
+	})));
+
+
+/***/ },
+/* 129 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Russian [ru]
+	//! author : Viktorminator : https://github.com/Viktorminator
+	//! Author : Menelion Elensúle : https://github.com/Oire
+	//! author : Коренберг Марк : https://github.com/socketpair
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function plural(word, num) {
+	    var forms = word.split('_');
+	    return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
+	}
+	function relativeTimeWithPlural(number, withoutSuffix, key) {
+	    var format = {
+	        'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
+	        'hh': 'час_часа_часов',
+	        'dd': 'день_дня_дней',
+	        'MM': 'месяц_месяца_месяцев',
+	        'yy': 'год_года_лет'
+	    };
+	    if (key === 'm') {
+	        return withoutSuffix ? 'минута' : 'минуту';
+	    }
+	    else {
+	        return number + ' ' + plural(format[key], +number);
+	    }
+	}
+	var monthsParse = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[йя]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];
+
+	// http://new.gramota.ru/spravka/rules/139-prop : § 103
+	// Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637
+	// CLDR data:          http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
+	var ru = moment.defineLocale('ru', {
+	    months : {
+	        format: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_'),
+	        standalone: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_')
+	    },
+	    monthsShort : {
+	        // по CLDR именно "июл." и "июн.", но какой смысл менять букву на точку ?
+	        format: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split('_'),
+	        standalone: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split('_')
+	    },
+	    weekdays : {
+	        standalone: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),
+	        format: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_'),
+	        isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
+	    },
+	    weekdaysShort : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
+	    weekdaysMin : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
+	    monthsParse : monthsParse,
+	    longMonthsParse : monthsParse,
+	    shortMonthsParse : monthsParse,
+
+	    // полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки
+	    monthsRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
+
+	    // копия предыдущего
+	    monthsShortRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
+
+	    // полные названия с падежами
+	    monthsStrictRegex: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,
+
+	    // Выражение, которое соотвествует только сокращённым формам
+	    monthsShortStrictRegex: /^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY г.',
+	        LLL : 'D MMMM YYYY г., HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY г., HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Сегодня в] LT',
+	        nextDay: '[Завтра в] LT',
+	        lastDay: '[Вчера в] LT',
+	        nextWeek: function (now) {
+	            if (now.week() !== this.week()) {
+	                switch (this.day()) {
+	                    case 0:
+	                        return '[В следующее] dddd [в] LT';
+	                    case 1:
+	                    case 2:
+	                    case 4:
+	                        return '[В следующий] dddd [в] LT';
+	                    case 3:
+	                    case 5:
+	                    case 6:
+	                        return '[В следующую] dddd [в] LT';
+	                }
+	            } else {
+	                if (this.day() === 2) {
+	                    return '[Во] dddd [в] LT';
+	                } else {
+	                    return '[В] dddd [в] LT';
+	                }
+	            }
+	        },
+	        lastWeek: function (now) {
+	            if (now.week() !== this.week()) {
+	                switch (this.day()) {
+	                    case 0:
+	                        return '[В прошлое] dddd [в] LT';
+	                    case 1:
+	                    case 2:
+	                    case 4:
+	                        return '[В прошлый] dddd [в] LT';
+	                    case 3:
+	                    case 5:
+	                    case 6:
+	                        return '[В прошлую] dddd [в] LT';
+	                }
+	            } else {
+	                if (this.day() === 2) {
+	                    return '[Во] dddd [в] LT';
+	                } else {
+	                    return '[В] dddd [в] LT';
+	                }
+	            }
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'через %s',
+	        past : '%s назад',
+	        s : 'несколько секунд',
+	        m : relativeTimeWithPlural,
+	        mm : relativeTimeWithPlural,
+	        h : 'час',
+	        hh : relativeTimeWithPlural,
+	        d : 'день',
+	        dd : relativeTimeWithPlural,
+	        M : 'месяц',
+	        MM : relativeTimeWithPlural,
+	        y : 'год',
+	        yy : relativeTimeWithPlural
+	    },
+	    meridiemParse: /ночи|утра|дня|вечера/i,
+	    isPM : function (input) {
+	        return /^(дня|вечера)$/.test(input);
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'ночи';
+	        } else if (hour < 12) {
+	            return 'утра';
+	        } else if (hour < 17) {
+	            return 'дня';
+	        } else {
+	            return 'вечера';
+	        }
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(й|го|я)/,
+	    ordinal: function (number, period) {
+	        switch (period) {
+	            case 'M':
+	            case 'd':
+	            case 'DDD':
+	                return number + '-й';
+	            case 'D':
+	                return number + '-го';
+	            case 'w':
+	            case 'W':
+	                return number + '-я';
+	            default:
+	                return number;
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return ru;
+
+	})));
+
+
+/***/ },
+/* 130 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Sindhi [sd]
+	//! author : Narain Sagar : https://github.com/narainsagar
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var months = [
+	    'جنوري',
+	    'فيبروري',
+	    'مارچ',
+	    'اپريل',
+	    'مئي',
+	    'جون',
+	    'جولاءِ',
+	    'آگسٽ',
+	    'سيپٽمبر',
+	    'آڪٽوبر',
+	    'نومبر',
+	    'ڊسمبر'
+	];
+	var days = [
+	    'آچر',
+	    'سومر',
+	    'اڱارو',
+	    'اربع',
+	    'خميس',
+	    'جمع',
+	    'ڇنڇر'
+	];
+
+	var sd = moment.defineLocale('sd', {
+	    months : months,
+	    monthsShort : months,
+	    weekdays : days,
+	    weekdaysShort : days,
+	    weekdaysMin : days,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd، D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /صبح|شام/,
+	    isPM : function (input) {
+	        return 'شام' === input;
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'صبح';
+	        }
+	        return 'شام';
+	    },
+	    calendar : {
+	        sameDay : '[اڄ] LT',
+	        nextDay : '[سڀاڻي] LT',
+	        nextWeek : 'dddd [اڳين هفتي تي] LT',
+	        lastDay : '[ڪالهه] LT',
+	        lastWeek : '[گزريل هفتي] dddd [تي] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s پوء',
+	        past : '%s اڳ',
+	        s : 'چند سيڪنڊ',
+	        m : 'هڪ منٽ',
+	        mm : '%d منٽ',
+	        h : 'هڪ ڪلاڪ',
+	        hh : '%d ڪلاڪ',
+	        d : 'هڪ ڏينهن',
+	        dd : '%d ڏينهن',
+	        M : 'هڪ مهينو',
+	        MM : '%d مهينا',
+	        y : 'هڪ سال',
+	        yy : '%d سال'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/،/g, ',');
+	    },
+	    postformat: function (string) {
+	        return string.replace(/,/g, '،');
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return sd;
+
+	})));
+
+
+/***/ },
+/* 131 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Northern Sami [se]
+	//! authors : Bård Rolstad Henriksen : https://github.com/karamell
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+
+	var se = moment.defineLocale('se', {
+	    months : 'ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu'.split('_'),
+	    monthsShort : 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split('_'),
+	    weekdays : 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),
+	    weekdaysShort : 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
+	    weekdaysMin : 's_v_m_g_d_b_L'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'MMMM D. [b.] YYYY',
+	        LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',
+	        LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[otne ti] LT',
+	        nextDay: '[ihttin ti] LT',
+	        nextWeek: 'dddd [ti] LT',
+	        lastDay: '[ikte ti] LT',
+	        lastWeek: '[ovddit] dddd [ti] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : '%s geažes',
+	        past : 'maŋit %s',
+	        s : 'moadde sekunddat',
+	        m : 'okta minuhta',
+	        mm : '%d minuhtat',
+	        h : 'okta diimmu',
+	        hh : '%d diimmut',
+	        d : 'okta beaivi',
+	        dd : '%d beaivvit',
+	        M : 'okta mánnu',
+	        MM : '%d mánut',
+	        y : 'okta jahki',
+	        yy : '%d jagit'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return se;
+
+	})));
+
+
+/***/ },
+/* 132 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Sinhalese [si]
+	//! author : Sampath Sitinamaluwa : https://github.com/sampathsris
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	/*jshint -W100*/
+	var si = moment.defineLocale('si', {
+	    months : 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split('_'),
+	    monthsShort : 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split('_'),
+	    weekdays : 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split('_'),
+	    weekdaysShort : 'ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන'.split('_'),
+	    weekdaysMin : 'ඉ_ස_අ_බ_බ්‍ර_සි_සෙ'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'a h:mm',
+	        LTS : 'a h:mm:ss',
+	        L : 'YYYY/MM/DD',
+	        LL : 'YYYY MMMM D',
+	        LLL : 'YYYY MMMM D, a h:mm',
+	        LLLL : 'YYYY MMMM D [වැනි] dddd, a h:mm:ss'
+	    },
+	    calendar : {
+	        sameDay : '[අද] LT[ට]',
+	        nextDay : '[හෙට] LT[ට]',
+	        nextWeek : 'dddd LT[ට]',
+	        lastDay : '[ඊයේ] LT[ට]',
+	        lastWeek : '[පසුගිය] dddd LT[ට]',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%sකින්',
+	        past : '%sකට පෙර',
+	        s : 'තත්පර කිහිපය',
+	        m : 'මිනිත්තුව',
+	        mm : 'මිනිත්තු %d',
+	        h : 'පැය',
+	        hh : 'පැය %d',
+	        d : 'දිනය',
+	        dd : 'දින %d',
+	        M : 'මාසය',
+	        MM : 'මාස %d',
+	        y : 'වසර',
+	        yy : 'වසර %d'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2} වැනි/,
+	    ordinal : function (number) {
+	        return number + ' වැනි';
+	    },
+	    meridiemParse : /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
+	    isPM : function (input) {
+	        return input === 'ප.ව.' || input === 'පස් වරු';
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours > 11) {
+	            return isLower ? 'ප.ව.' : 'පස් වරු';
+	        } else {
+	            return isLower ? 'පෙ.ව.' : 'පෙර වරු';
+	        }
+	    }
+	});
+
+	return si;
+
+	})));
+
+
+/***/ },
+/* 133 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Slovak [sk]
+	//! author : Martin Minka : https://github.com/k2s
+	//! based on work of petrbela : https://github.com/petrbela
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var months = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_');
+	var monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
+	function plural(n) {
+	    return (n > 1) && (n < 5);
+	}
+	function translate(number, withoutSuffix, key, isFuture) {
+	    var result = number + ' ';
+	    switch (key) {
+	        case 's':  // a few seconds / in a few seconds / a few seconds ago
+	            return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
+	        case 'm':  // a minute / in a minute / a minute ago
+	            return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou');
+	        case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'minúty' : 'minút');
+	            } else {
+	                return result + 'minútami';
+	            }
+	            break;
+	        case 'h':  // an hour / in an hour / an hour ago
+	            return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
+	        case 'hh': // 9 hours / in 9 hours / 9 hours ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'hodiny' : 'hodín');
+	            } else {
+	                return result + 'hodinami';
+	            }
+	            break;
+	        case 'd':  // a day / in a day / a day ago
+	            return (withoutSuffix || isFuture) ? 'deň' : 'dňom';
+	        case 'dd': // 9 days / in 9 days / 9 days ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'dni' : 'dní');
+	            } else {
+	                return result + 'dňami';
+	            }
+	            break;
+	        case 'M':  // a month / in a month / a month ago
+	            return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
+	        case 'MM': // 9 months / in 9 months / 9 months ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'mesiace' : 'mesiacov');
+	            } else {
+	                return result + 'mesiacmi';
+	            }
+	            break;
+	        case 'y':  // a year / in a year / a year ago
+	            return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
+	        case 'yy': // 9 years / in 9 years / 9 years ago
+	            if (withoutSuffix || isFuture) {
+	                return result + (plural(number) ? 'roky' : 'rokov');
+	            } else {
+	                return result + 'rokmi';
+	            }
+	            break;
+	    }
+	}
+
+	var sk = moment.defineLocale('sk', {
+	    months : months,
+	    monthsShort : monthsShort,
+	    weekdays : 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
+	    weekdaysShort : 'ne_po_ut_st_št_pi_so'.split('_'),
+	    weekdaysMin : 'ne_po_ut_st_št_pi_so'.split('_'),
+	    longDateFormat : {
+	        LT: 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY H:mm',
+	        LLLL : 'dddd D. MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay: '[dnes o] LT',
+	        nextDay: '[zajtra o] LT',
+	        nextWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[v nedeľu o] LT';
+	                case 1:
+	                case 2:
+	                    return '[v] dddd [o] LT';
+	                case 3:
+	                    return '[v stredu o] LT';
+	                case 4:
+	                    return '[vo štvrtok o] LT';
+	                case 5:
+	                    return '[v piatok o] LT';
+	                case 6:
+	                    return '[v sobotu o] LT';
+	            }
+	        },
+	        lastDay: '[včera o] LT',
+	        lastWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[minulú nedeľu o] LT';
+	                case 1:
+	                case 2:
+	                    return '[minulý] dddd [o] LT';
+	                case 3:
+	                    return '[minulú stredu o] LT';
+	                case 4:
+	                case 5:
+	                    return '[minulý] dddd [o] LT';
+	                case 6:
+	                    return '[minulú sobotu o] LT';
+	            }
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'za %s',
+	        past : 'pred %s',
+	        s : translate,
+	        m : translate,
+	        mm : translate,
+	        h : translate,
+	        hh : translate,
+	        d : translate,
+	        dd : translate,
+	        M : translate,
+	        MM : translate,
+	        y : translate,
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return sk;
+
+	})));
+
+
+/***/ },
+/* 134 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Slovenian [sl]
+	//! author : Robert Sedovšek : https://github.com/sedovsek
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var result = number + ' ';
+	    switch (key) {
+	        case 's':
+	            return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami';
+	        case 'm':
+	            return withoutSuffix ? 'ena minuta' : 'eno minuto';
+	        case 'mm':
+	            if (number === 1) {
+	                result += withoutSuffix ? 'minuta' : 'minuto';
+	            } else if (number === 2) {
+	                result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
+	            } else if (number < 5) {
+	                result += withoutSuffix || isFuture ? 'minute' : 'minutami';
+	            } else {
+	                result += withoutSuffix || isFuture ? 'minut' : 'minutami';
+	            }
+	            return result;
+	        case 'h':
+	            return withoutSuffix ? 'ena ura' : 'eno uro';
+	        case 'hh':
+	            if (number === 1) {
+	                result += withoutSuffix ? 'ura' : 'uro';
+	            } else if (number === 2) {
+	                result += withoutSuffix || isFuture ? 'uri' : 'urama';
+	            } else if (number < 5) {
+	                result += withoutSuffix || isFuture ? 'ure' : 'urami';
+	            } else {
+	                result += withoutSuffix || isFuture ? 'ur' : 'urami';
+	            }
+	            return result;
+	        case 'd':
+	            return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
+	        case 'dd':
+	            if (number === 1) {
+	                result += withoutSuffix || isFuture ? 'dan' : 'dnem';
+	            } else if (number === 2) {
+	                result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
+	            } else {
+	                result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
+	            }
+	            return result;
+	        case 'M':
+	            return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
+	        case 'MM':
+	            if (number === 1) {
+	                result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
+	            } else if (number === 2) {
+	                result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
+	            } else if (number < 5) {
+	                result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
+	            } else {
+	                result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
+	            }
+	            return result;
+	        case 'y':
+	            return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
+	        case 'yy':
+	            if (number === 1) {
+	                result += withoutSuffix || isFuture ? 'leto' : 'letom';
+	            } else if (number === 2) {
+	                result += withoutSuffix || isFuture ? 'leti' : 'letoma';
+	            } else if (number < 5) {
+	                result += withoutSuffix || isFuture ? 'leta' : 'leti';
+	            } else {
+	                result += withoutSuffix || isFuture ? 'let' : 'leti';
+	            }
+	            return result;
+	    }
+	}
+
+	var sl = moment.defineLocale('sl', {
+	    months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
+	    monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
+	    weekdaysShort : 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
+	    weekdaysMin : 'ne_po_to_sr_če_pe_so'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM YYYY',
+	        LLL : 'D. MMMM YYYY H:mm',
+	        LLLL : 'dddd, D. MMMM YYYY H:mm'
+	    },
+	    calendar : {
+	        sameDay  : '[danes ob] LT',
+	        nextDay  : '[jutri ob] LT',
+
+	        nextWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[v] [nedeljo] [ob] LT';
+	                case 3:
+	                    return '[v] [sredo] [ob] LT';
+	                case 6:
+	                    return '[v] [soboto] [ob] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[v] dddd [ob] LT';
+	            }
+	        },
+	        lastDay  : '[včeraj ob] LT',
+	        lastWeek : function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[prejšnjo] [nedeljo] [ob] LT';
+	                case 3:
+	                    return '[prejšnjo] [sredo] [ob] LT';
+	                case 6:
+	                    return '[prejšnjo] [soboto] [ob] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[prejšnji] dddd [ob] LT';
+	            }
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'čez %s',
+	        past   : 'pred %s',
+	        s      : processRelativeTime,
+	        m      : processRelativeTime,
+	        mm     : processRelativeTime,
+	        h      : processRelativeTime,
+	        hh     : processRelativeTime,
+	        d      : processRelativeTime,
+	        dd     : processRelativeTime,
+	        M      : processRelativeTime,
+	        MM     : processRelativeTime,
+	        y      : processRelativeTime,
+	        yy     : processRelativeTime
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return sl;
+
+	})));
+
+
+/***/ },
+/* 135 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Albanian [sq]
+	//! author : Flakërim Ismani : https://github.com/flakerimi
+	//! author : Menelion Elensúle : https://github.com/Oire
+	//! author : Oerd Cukalla : https://github.com/oerd
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var sq = moment.defineLocale('sq', {
+	    months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
+	    monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
+	    weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
+	    weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
+	    weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'),
+	    weekdaysParseExact : true,
+	    meridiemParse: /PD|MD/,
+	    isPM: function (input) {
+	        return input.charAt(0) === 'M';
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        return hours < 12 ? 'PD' : 'MD';
+	    },
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Sot në] LT',
+	        nextDay : '[Nesër në] LT',
+	        nextWeek : 'dddd [në] LT',
+	        lastDay : '[Dje në] LT',
+	        lastWeek : 'dddd [e kaluar në] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'në %s',
+	        past : '%s më parë',
+	        s : 'disa sekonda',
+	        m : 'një minutë',
+	        mm : '%d minuta',
+	        h : 'një orë',
+	        hh : '%d orë',
+	        d : 'një ditë',
+	        dd : '%d ditë',
+	        M : 'një muaj',
+	        MM : '%d muaj',
+	        y : 'një vit',
+	        yy : '%d vite'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return sq;
+
+	})));
+
+
+/***/ },
+/* 136 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Serbian [sr]
+	//! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var translator = {
+	    words: { //Different grammatical cases
+	        m: ['jedan minut', 'jedne minute'],
+	        mm: ['minut', 'minute', 'minuta'],
+	        h: ['jedan sat', 'jednog sata'],
+	        hh: ['sat', 'sata', 'sati'],
+	        dd: ['dan', 'dana', 'dana'],
+	        MM: ['mesec', 'meseca', 'meseci'],
+	        yy: ['godina', 'godine', 'godina']
+	    },
+	    correctGrammaticalCase: function (number, wordKey) {
+	        return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
+	    },
+	    translate: function (number, withoutSuffix, key) {
+	        var wordKey = translator.words[key];
+	        if (key.length === 1) {
+	            return withoutSuffix ? wordKey[0] : wordKey[1];
+	        } else {
+	            return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
+	        }
+	    }
+	};
+
+	var sr = moment.defineLocale('sr', {
+	    months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
+	    monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays: 'nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota'.split('_'),
+	    weekdaysShort: 'ned._pon._uto._sre._čet._pet._sub.'.split('_'),
+	    weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat: {
+	        LT: 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L: 'DD.MM.YYYY',
+	        LL: 'D. MMMM YYYY',
+	        LLL: 'D. MMMM YYYY H:mm',
+	        LLLL: 'dddd, D. MMMM YYYY H:mm'
+	    },
+	    calendar: {
+	        sameDay: '[danas u] LT',
+	        nextDay: '[sutra u] LT',
+	        nextWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[u] [nedelju] [u] LT';
+	                case 3:
+	                    return '[u] [sredu] [u] LT';
+	                case 6:
+	                    return '[u] [subotu] [u] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[u] dddd [u] LT';
+	            }
+	        },
+	        lastDay  : '[juče u] LT',
+	        lastWeek : function () {
+	            var lastWeekDays = [
+	                '[prošle] [nedelje] [u] LT',
+	                '[prošlog] [ponedeljka] [u] LT',
+	                '[prošlog] [utorka] [u] LT',
+	                '[prošle] [srede] [u] LT',
+	                '[prošlog] [četvrtka] [u] LT',
+	                '[prošlog] [petka] [u] LT',
+	                '[prošle] [subote] [u] LT'
+	            ];
+	            return lastWeekDays[this.day()];
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'za %s',
+	        past   : 'pre %s',
+	        s      : 'nekoliko sekundi',
+	        m      : translator.translate,
+	        mm     : translator.translate,
+	        h      : translator.translate,
+	        hh     : translator.translate,
+	        d      : 'dan',
+	        dd     : translator.translate,
+	        M      : 'mesec',
+	        MM     : translator.translate,
+	        y      : 'godinu',
+	        yy     : translator.translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return sr;
+
+	})));
+
+
+/***/ },
+/* 137 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Serbian Cyrillic [sr-cyrl]
+	//! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var translator = {
+	    words: { //Different grammatical cases
+	        m: ['један минут', 'једне минуте'],
+	        mm: ['минут', 'минуте', 'минута'],
+	        h: ['један сат', 'једног сата'],
+	        hh: ['сат', 'сата', 'сати'],
+	        dd: ['дан', 'дана', 'дана'],
+	        MM: ['месец', 'месеца', 'месеци'],
+	        yy: ['година', 'године', 'година']
+	    },
+	    correctGrammaticalCase: function (number, wordKey) {
+	        return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
+	    },
+	    translate: function (number, withoutSuffix, key) {
+	        var wordKey = translator.words[key];
+	        if (key.length === 1) {
+	            return withoutSuffix ? wordKey[0] : wordKey[1];
+	        } else {
+	            return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
+	        }
+	    }
+	};
+
+	var srCyrl = moment.defineLocale('sr-cyrl', {
+	    months: 'јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар'.split('_'),
+	    monthsShort: 'јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays: 'недеља_понедељак_уторак_среда_четвртак_петак_субота'.split('_'),
+	    weekdaysShort: 'нед._пон._уто._сре._чет._пет._суб.'.split('_'),
+	    weekdaysMin: 'не_по_ут_ср_че_пе_су'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat: {
+	        LT: 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L: 'DD.MM.YYYY',
+	        LL: 'D. MMMM YYYY',
+	        LLL: 'D. MMMM YYYY H:mm',
+	        LLLL: 'dddd, D. MMMM YYYY H:mm'
+	    },
+	    calendar: {
+	        sameDay: '[данас у] LT',
+	        nextDay: '[сутра у] LT',
+	        nextWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                    return '[у] [недељу] [у] LT';
+	                case 3:
+	                    return '[у] [среду] [у] LT';
+	                case 6:
+	                    return '[у] [суботу] [у] LT';
+	                case 1:
+	                case 2:
+	                case 4:
+	                case 5:
+	                    return '[у] dddd [у] LT';
+	            }
+	        },
+	        lastDay  : '[јуче у] LT',
+	        lastWeek : function () {
+	            var lastWeekDays = [
+	                '[прошле] [недеље] [у] LT',
+	                '[прошлог] [понедељка] [у] LT',
+	                '[прошлог] [уторка] [у] LT',
+	                '[прошле] [среде] [у] LT',
+	                '[прошлог] [четвртка] [у] LT',
+	                '[прошлог] [петка] [у] LT',
+	                '[прошле] [суботе] [у] LT'
+	            ];
+	            return lastWeekDays[this.day()];
+	        },
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'за %s',
+	        past   : 'пре %s',
+	        s      : 'неколико секунди',
+	        m      : translator.translate,
+	        mm     : translator.translate,
+	        h      : translator.translate,
+	        hh     : translator.translate,
+	        d      : 'дан',
+	        dd     : translator.translate,
+	        M      : 'месец',
+	        MM     : translator.translate,
+	        y      : 'годину',
+	        yy     : translator.translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return srCyrl;
+
+	})));
+
+
+/***/ },
+/* 138 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : siSwati [ss]
+	//! author : Nicolai Davies<mail@nicolai.io> : https://github.com/nicolaidavies
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+
+	var ss = moment.defineLocale('ss', {
+	    months : "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'),
+	    monthsShort : 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
+	    weekdays : 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'),
+	    weekdaysShort : 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
+	    weekdaysMin : 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY h:mm A',
+	        LLLL : 'dddd, D MMMM YYYY h:mm A'
+	    },
+	    calendar : {
+	        sameDay : '[Namuhla nga] LT',
+	        nextDay : '[Kusasa nga] LT',
+	        nextWeek : 'dddd [nga] LT',
+	        lastDay : '[Itolo nga] LT',
+	        lastWeek : 'dddd [leliphelile] [nga] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'nga %s',
+	        past : 'wenteka nga %s',
+	        s : 'emizuzwana lomcane',
+	        m : 'umzuzu',
+	        mm : '%d emizuzu',
+	        h : 'lihora',
+	        hh : '%d emahora',
+	        d : 'lilanga',
+	        dd : '%d emalanga',
+	        M : 'inyanga',
+	        MM : '%d tinyanga',
+	        y : 'umnyaka',
+	        yy : '%d iminyaka'
+	    },
+	    meridiemParse: /ekuseni|emini|entsambama|ebusuku/,
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 11) {
+	            return 'ekuseni';
+	        } else if (hours < 15) {
+	            return 'emini';
+	        } else if (hours < 19) {
+	            return 'entsambama';
+	        } else {
+	            return 'ebusuku';
+	        }
+	    },
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'ekuseni') {
+	            return hour;
+	        } else if (meridiem === 'emini') {
+	            return hour >= 11 ? hour : hour + 12;
+	        } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') {
+	            if (hour === 0) {
+	                return 0;
+	            }
+	            return hour + 12;
+	        }
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}/,
+	    ordinal : '%d',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return ss;
+
+	})));
+
+
+/***/ },
+/* 139 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Swedish [sv]
+	//! author : Jens Alm : https://github.com/ulmus
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var sv = moment.defineLocale('sv', {
+	    months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
+	    monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
+	    weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
+	    weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
+	    weekdaysMin : 'sö_må_ti_on_to_fr_lö'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY-MM-DD',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY [kl.] HH:mm',
+	        LLLL : 'dddd D MMMM YYYY [kl.] HH:mm',
+	        lll : 'D MMM YYYY HH:mm',
+	        llll : 'ddd D MMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Idag] LT',
+	        nextDay: '[Imorgon] LT',
+	        lastDay: '[Igår] LT',
+	        nextWeek: '[På] dddd LT',
+	        lastWeek: '[I] dddd[s] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'om %s',
+	        past : 'för %s sedan',
+	        s : 'några sekunder',
+	        m : 'en minut',
+	        mm : '%d minuter',
+	        h : 'en timme',
+	        hh : '%d timmar',
+	        d : 'en dag',
+	        dd : '%d dagar',
+	        M : 'en månad',
+	        MM : '%d månader',
+	        y : 'ett år',
+	        yy : '%d år'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(e|a)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'e' :
+	            (b === 1) ? 'a' :
+	            (b === 2) ? 'a' :
+	            (b === 3) ? 'e' : 'e';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return sv;
+
+	})));
+
+
+/***/ },
+/* 140 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Swahili [sw]
+	//! author : Fahad Kassim : https://github.com/fadsel
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var sw = moment.defineLocale('sw', {
+	    months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
+	    monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
+	    weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
+	    weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
+	    weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[leo saa] LT',
+	        nextDay : '[kesho saa] LT',
+	        nextWeek : '[wiki ijayo] dddd [saat] LT',
+	        lastDay : '[jana] LT',
+	        lastWeek : '[wiki iliyopita] dddd [saat] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s baadaye',
+	        past : 'tokea %s',
+	        s : 'hivi punde',
+	        m : 'dakika moja',
+	        mm : 'dakika %d',
+	        h : 'saa limoja',
+	        hh : 'masaa %d',
+	        d : 'siku moja',
+	        dd : 'masiku %d',
+	        M : 'mwezi mmoja',
+	        MM : 'miezi %d',
+	        y : 'mwaka mmoja',
+	        yy : 'miaka %d'
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return sw;
+
+	})));
+
+
+/***/ },
+/* 141 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Tamil [ta]
+	//! author : Arjunkumar Krishnamoorthy : https://github.com/tk120404
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var symbolMap = {
+	    '1': '௧',
+	    '2': '௨',
+	    '3': '௩',
+	    '4': '௪',
+	    '5': '௫',
+	    '6': '௬',
+	    '7': '௭',
+	    '8': '௮',
+	    '9': '௯',
+	    '0': '௦'
+	};
+	var numberMap = {
+	    '௧': '1',
+	    '௨': '2',
+	    '௩': '3',
+	    '௪': '4',
+	    '௫': '5',
+	    '௬': '6',
+	    '௭': '7',
+	    '௮': '8',
+	    '௯': '9',
+	    '௦': '0'
+	};
+
+	var ta = moment.defineLocale('ta', {
+	    months : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
+	    monthsShort : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
+	    weekdays : 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split('_'),
+	    weekdaysShort : 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split('_'),
+	    weekdaysMin : 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY, HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[இன்று] LT',
+	        nextDay : '[நாளை] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[நேற்று] LT',
+	        lastWeek : '[கடந்த வாரம்] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s இல்',
+	        past : '%s முன்',
+	        s : 'ஒரு சில விநாடிகள்',
+	        m : 'ஒரு நிமிடம்',
+	        mm : '%d நிமிடங்கள்',
+	        h : 'ஒரு மணி நேரம்',
+	        hh : '%d மணி நேரம்',
+	        d : 'ஒரு நாள்',
+	        dd : '%d நாட்கள்',
+	        M : 'ஒரு மாதம்',
+	        MM : '%d மாதங்கள்',
+	        y : 'ஒரு வருடம்',
+	        yy : '%d ஆண்டுகள்'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}வது/,
+	    ordinal : function (number) {
+	        return number + 'வது';
+	    },
+	    preparse: function (string) {
+	        return string.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match) {
+	            return numberMap[match];
+	        });
+	    },
+	    postformat: function (string) {
+	        return string.replace(/\d/g, function (match) {
+	            return symbolMap[match];
+	        });
+	    },
+	    // refer http://ta.wikipedia.org/s/1er1
+	    meridiemParse: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 2) {
+	            return ' யாமம்';
+	        } else if (hour < 6) {
+	            return ' வைகறை';  // வைகறை
+	        } else if (hour < 10) {
+	            return ' காலை'; // காலை
+	        } else if (hour < 14) {
+	            return ' நண்பகல்'; // நண்பகல்
+	        } else if (hour < 18) {
+	            return ' எற்பாடு'; // எற்பாடு
+	        } else if (hour < 22) {
+	            return ' மாலை'; // மாலை
+	        } else {
+	            return ' யாமம்';
+	        }
+	    },
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'யாமம்') {
+	            return hour < 2 ? hour : hour + 12;
+	        } else if (meridiem === 'வைகறை' || meridiem === 'காலை') {
+	            return hour;
+	        } else if (meridiem === 'நண்பகல்') {
+	            return hour >= 10 ? hour : hour + 12;
+	        } else {
+	            return hour + 12;
+	        }
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return ta;
+
+	})));
+
+
+/***/ },
+/* 142 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Telugu [te]
+	//! author : Krishna Chaitanya Thota : https://github.com/kcthota
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var te = moment.defineLocale('te', {
+	    months : 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జూలై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split('_'),
+	    monthsShort : 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జూలై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split('_'),
+	    weekdaysShort : 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
+	    weekdaysMin : 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
+	    longDateFormat : {
+	        LT : 'A h:mm',
+	        LTS : 'A h:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY, A h:mm',
+	        LLLL : 'dddd, D MMMM YYYY, A h:mm'
+	    },
+	    calendar : {
+	        sameDay : '[నేడు] LT',
+	        nextDay : '[రేపు] LT',
+	        nextWeek : 'dddd, LT',
+	        lastDay : '[నిన్న] LT',
+	        lastWeek : '[గత] dddd, LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s లో',
+	        past : '%s క్రితం',
+	        s : 'కొన్ని క్షణాలు',
+	        m : 'ఒక నిమిషం',
+	        mm : '%d నిమిషాలు',
+	        h : 'ఒక గంట',
+	        hh : '%d గంటలు',
+	        d : 'ఒక రోజు',
+	        dd : '%d రోజులు',
+	        M : 'ఒక నెల',
+	        MM : '%d నెలలు',
+	        y : 'ఒక సంవత్సరం',
+	        yy : '%d సంవత్సరాలు'
+	    },
+	    dayOfMonthOrdinalParse : /\d{1,2}వ/,
+	    ordinal : '%dవ',
+	    meridiemParse: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === 'రాత్రి') {
+	            return hour < 4 ? hour : hour + 12;
+	        } else if (meridiem === 'ఉదయం') {
+	            return hour;
+	        } else if (meridiem === 'మధ్యాహ్నం') {
+	            return hour >= 10 ? hour : hour + 12;
+	        } else if (meridiem === 'సాయంత్రం') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'రాత్రి';
+	        } else if (hour < 10) {
+	            return 'ఉదయం';
+	        } else if (hour < 17) {
+	            return 'మధ్యాహ్నం';
+	        } else if (hour < 20) {
+	            return 'సాయంత్రం';
+	        } else {
+	            return 'రాత్రి';
+	        }
+	    },
+	    week : {
+	        dow : 0, // Sunday is the first day of the week.
+	        doy : 6  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return te;
+
+	})));
+
+
+/***/ },
+/* 143 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Tetun Dili (East Timor) [tet]
+	//! author : Joshua Brooks : https://github.com/joshbrooks
+	//! author : Onorio De J. Afonso : https://github.com/marobo
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var tet = moment.defineLocale('tet', {
+	    months : 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juniu_Juliu_Augustu_Setembru_Outubru_Novembru_Dezembru'.split('_'),
+	    monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Aug_Set_Out_Nov_Dez'.split('_'),
+	    weekdays : 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sexta_Sabadu'.split('_'),
+	    weekdaysShort : 'Dom_Seg_Ters_Kua_Kint_Sext_Sab'.split('_'),
+	    weekdaysMin : 'Do_Seg_Te_Ku_Ki_Sex_Sa'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Ohin iha] LT',
+	        nextDay: '[Aban iha] LT',
+	        nextWeek: 'dddd [iha] LT',
+	        lastDay: '[Horiseik iha] LT',
+	        lastWeek: 'dddd [semana kotuk] [iha] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'iha %s',
+	        past : '%s liuba',
+	        s : 'minutu balun',
+	        m : 'minutu ida',
+	        mm : 'minutus %d',
+	        h : 'horas ida',
+	        hh : 'horas %d',
+	        d : 'loron ida',
+	        dd : 'loron %d',
+	        M : 'fulan ida',
+	        MM : 'fulan %d',
+	        y : 'tinan ida',
+	        yy : 'tinan %d'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return tet;
+
+	})));
+
+
+/***/ },
+/* 144 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Thai [th]
+	//! author : Kridsada Thanabulpong : https://github.com/sirn
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var th = moment.defineLocale('th', {
+	    months : 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
+	    monthsShort : 'ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.'.split('_'),
+	    monthsParseExact: true,
+	    weekdays : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
+	    weekdaysShort : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
+	    weekdaysMin : 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'H:mm',
+	        LTS : 'H:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY เวลา H:mm',
+	        LLLL : 'วันddddที่ D MMMM YYYY เวลา H:mm'
+	    },
+	    meridiemParse: /ก่อนเที่ยง|หลังเที่ยง/,
+	    isPM: function (input) {
+	        return input === 'หลังเที่ยง';
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'ก่อนเที่ยง';
+	        } else {
+	            return 'หลังเที่ยง';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[วันนี้ เวลา] LT',
+	        nextDay : '[พรุ่งนี้ เวลา] LT',
+	        nextWeek : 'dddd[หน้า เวลา] LT',
+	        lastDay : '[เมื่อวานนี้ เวลา] LT',
+	        lastWeek : '[วัน]dddd[ที่แล้ว เวลา] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'อีก %s',
+	        past : '%sที่แล้ว',
+	        s : 'ไม่กี่วินาที',
+	        m : '1 นาที',
+	        mm : '%d นาที',
+	        h : '1 ชั่วโมง',
+	        hh : '%d ชั่วโมง',
+	        d : '1 วัน',
+	        dd : '%d วัน',
+	        M : '1 เดือน',
+	        MM : '%d เดือน',
+	        y : '1 ปี',
+	        yy : '%d ปี'
+	    }
+	});
+
+	return th;
+
+	})));
+
+
+/***/ },
+/* 145 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Tagalog (Philippines) [tl-ph]
+	//! author : Dan Hagman : https://github.com/hagmandan
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var tlPh = moment.defineLocale('tl-ph', {
+	    months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
+	    monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
+	    weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
+	    weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
+	    weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'MM/D/YYYY',
+	        LL : 'MMMM D, YYYY',
+	        LLL : 'MMMM D, YYYY HH:mm',
+	        LLLL : 'dddd, MMMM DD, YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: 'LT [ngayong araw]',
+	        nextDay: '[Bukas ng] LT',
+	        nextWeek: 'LT [sa susunod na] dddd',
+	        lastDay: 'LT [kahapon]',
+	        lastWeek: 'LT [noong nakaraang] dddd',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'sa loob ng %s',
+	        past : '%s ang nakalipas',
+	        s : 'ilang segundo',
+	        m : 'isang minuto',
+	        mm : '%d minuto',
+	        h : 'isang oras',
+	        hh : '%d oras',
+	        d : 'isang araw',
+	        dd : '%d araw',
+	        M : 'isang buwan',
+	        MM : '%d buwan',
+	        y : 'isang taon',
+	        yy : '%d taon'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}/,
+	    ordinal : function (number) {
+	        return number;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return tlPh;
+
+	})));
+
+
+/***/ },
+/* 146 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Klingon [tlh]
+	//! author : Dominika Kruk : https://github.com/amaranthrose
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
+
+	function translateFuture(output) {
+	    var time = output;
+	    time = (output.indexOf('jaj') !== -1) ?
+	    time.slice(0, -3) + 'leS' :
+	    (output.indexOf('jar') !== -1) ?
+	    time.slice(0, -3) + 'waQ' :
+	    (output.indexOf('DIS') !== -1) ?
+	    time.slice(0, -3) + 'nem' :
+	    time + ' pIq';
+	    return time;
+	}
+
+	function translatePast(output) {
+	    var time = output;
+	    time = (output.indexOf('jaj') !== -1) ?
+	    time.slice(0, -3) + 'Hu’' :
+	    (output.indexOf('jar') !== -1) ?
+	    time.slice(0, -3) + 'wen' :
+	    (output.indexOf('DIS') !== -1) ?
+	    time.slice(0, -3) + 'ben' :
+	    time + ' ret';
+	    return time;
+	}
+
+	function translate(number, withoutSuffix, string, isFuture) {
+	    var numberNoun = numberAsNoun(number);
+	    switch (string) {
+	        case 'mm':
+	            return numberNoun + ' tup';
+	        case 'hh':
+	            return numberNoun + ' rep';
+	        case 'dd':
+	            return numberNoun + ' jaj';
+	        case 'MM':
+	            return numberNoun + ' jar';
+	        case 'yy':
+	            return numberNoun + ' DIS';
+	    }
+	}
+
+	function numberAsNoun(number) {
+	    var hundred = Math.floor((number % 1000) / 100),
+	    ten = Math.floor((number % 100) / 10),
+	    one = number % 10,
+	    word = '';
+	    if (hundred > 0) {
+	        word += numbersNouns[hundred] + 'vatlh';
+	    }
+	    if (ten > 0) {
+	        word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH';
+	    }
+	    if (one > 0) {
+	        word += ((word !== '') ? ' ' : '') + numbersNouns[one];
+	    }
+	    return (word === '') ? 'pagh' : word;
+	}
+
+	var tlh = moment.defineLocale('tlh', {
+	    months : 'tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’'.split('_'),
+	    monthsShort : 'jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
+	    weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
+	    weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[DaHjaj] LT',
+	        nextDay: '[wa’leS] LT',
+	        nextWeek: 'LLL',
+	        lastDay: '[wa’Hu’] LT',
+	        lastWeek: 'LLL',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : translateFuture,
+	        past : translatePast,
+	        s : 'puS lup',
+	        m : 'wa’ tup',
+	        mm : translate,
+	        h : 'wa’ rep',
+	        hh : translate,
+	        d : 'wa’ jaj',
+	        dd : translate,
+	        M : 'wa’ jar',
+	        MM : translate,
+	        y : 'wa’ DIS',
+	        yy : translate
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return tlh;
+
+	})));
+
+
+/***/ },
+/* 147 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Turkish [tr]
+	//! authors : Erhan Gundogan : https://github.com/erhangundogan,
+	//!           Burak Yiğit Kaya: https://github.com/BYK
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var suffixes = {
+	    1: '\'inci',
+	    5: '\'inci',
+	    8: '\'inci',
+	    70: '\'inci',
+	    80: '\'inci',
+	    2: '\'nci',
+	    7: '\'nci',
+	    20: '\'nci',
+	    50: '\'nci',
+	    3: '\'üncü',
+	    4: '\'üncü',
+	    100: '\'üncü',
+	    6: '\'ncı',
+	    9: '\'uncu',
+	    10: '\'uncu',
+	    30: '\'uncu',
+	    60: '\'ıncı',
+	    90: '\'ıncı'
+	};
+
+	var tr = moment.defineLocale('tr', {
+	    months : 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
+	    monthsShort : 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
+	    weekdays : 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
+	    weekdaysShort : 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
+	    weekdaysMin : 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[bugün saat] LT',
+	        nextDay : '[yarın saat] LT',
+	        nextWeek : '[haftaya] dddd [saat] LT',
+	        lastDay : '[dün] LT',
+	        lastWeek : '[geçen hafta] dddd [saat] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s sonra',
+	        past : '%s önce',
+	        s : 'birkaç saniye',
+	        m : 'bir dakika',
+	        mm : '%d dakika',
+	        h : 'bir saat',
+	        hh : '%d saat',
+	        d : 'bir gün',
+	        dd : '%d gün',
+	        M : 'bir ay',
+	        MM : '%d ay',
+	        y : 'bir yıl',
+	        yy : '%d yıl'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}'(inci|nci|üncü|ncı|uncu|ıncı)/,
+	    ordinal : function (number) {
+	        if (number === 0) {  // special case for zero
+	            return number + '\'ıncı';
+	        }
+	        var a = number % 10,
+	            b = number % 100 - a,
+	            c = number >= 100 ? 100 : null;
+	        return number + (suffixes[a] || suffixes[b] || suffixes[c]);
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return tr;
+
+	})));
+
+
+/***/ },
+/* 148 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Talossan [tzl]
+	//! author : Robin van der Vliet : https://github.com/robin0van0der0v
+	//! author : Iustì Canun
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	// After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
+	// This is currently too difficult (maybe even impossible) to add.
+	var tzl = moment.defineLocale('tzl', {
+	    months : 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'),
+	    monthsShort : 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
+	    weekdays : 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
+	    weekdaysShort : 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
+	    weekdaysMin : 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH.mm',
+	        LTS : 'HH.mm.ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D. MMMM [dallas] YYYY',
+	        LLL : 'D. MMMM [dallas] YYYY HH.mm',
+	        LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
+	    },
+	    meridiemParse: /d\'o|d\'a/i,
+	    isPM : function (input) {
+	        return 'd\'o' === input.toLowerCase();
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours > 11) {
+	            return isLower ? 'd\'o' : 'D\'O';
+	        } else {
+	            return isLower ? 'd\'a' : 'D\'A';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[oxhi à] LT',
+	        nextDay : '[demà à] LT',
+	        nextWeek : 'dddd [à] LT',
+	        lastDay : '[ieiri à] LT',
+	        lastWeek : '[sür el] dddd [lasteu à] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'osprei %s',
+	        past : 'ja%s',
+	        s : processRelativeTime,
+	        m : processRelativeTime,
+	        mm : processRelativeTime,
+	        h : processRelativeTime,
+	        hh : processRelativeTime,
+	        d : processRelativeTime,
+	        dd : processRelativeTime,
+	        M : processRelativeTime,
+	        MM : processRelativeTime,
+	        y : processRelativeTime,
+	        yy : processRelativeTime
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}\./,
+	    ordinal : '%d.',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	function processRelativeTime(number, withoutSuffix, key, isFuture) {
+	    var format = {
+	        's': ['viensas secunds', '\'iensas secunds'],
+	        'm': ['\'n míut', '\'iens míut'],
+	        'mm': [number + ' míuts', '' + number + ' míuts'],
+	        'h': ['\'n þora', '\'iensa þora'],
+	        'hh': [number + ' þoras', '' + number + ' þoras'],
+	        'd': ['\'n ziua', '\'iensa ziua'],
+	        'dd': [number + ' ziuas', '' + number + ' ziuas'],
+	        'M': ['\'n mes', '\'iens mes'],
+	        'MM': [number + ' mesen', '' + number + ' mesen'],
+	        'y': ['\'n ar', '\'iens ar'],
+	        'yy': [number + ' ars', '' + number + ' ars']
+	    };
+	    return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]);
+	}
+
+	return tzl;
+
+	})));
+
+
+/***/ },
+/* 149 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Central Atlas Tamazight [tzm]
+	//! author : Abdel Said : https://github.com/abdelsaid
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var tzm = moment.defineLocale('tzm', {
+	    months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
+	    monthsShort : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
+	    weekdays : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
+	    weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
+	    weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS: 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
+	        nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
+	        nextWeek: 'dddd [ⴴ] LT',
+	        lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
+	        lastWeek: 'dddd [ⴴ] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
+	        past : 'ⵢⴰⵏ %s',
+	        s : 'ⵉⵎⵉⴽ',
+	        m : 'ⵎⵉⵏⵓⴺ',
+	        mm : '%d ⵎⵉⵏⵓⴺ',
+	        h : 'ⵙⴰⵄⴰ',
+	        hh : '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
+	        d : 'ⴰⵙⵙ',
+	        dd : '%d oⵙⵙⴰⵏ',
+	        M : 'ⴰⵢoⵓⵔ',
+	        MM : '%d ⵉⵢⵢⵉⵔⵏ',
+	        y : 'ⴰⵙⴳⴰⵙ',
+	        yy : '%d ⵉⵙⴳⴰⵙⵏ'
+	    },
+	    week : {
+	        dow : 6, // Saturday is the first day of the week.
+	        doy : 12  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return tzm;
+
+	})));
+
+
+/***/ },
+/* 150 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Central Atlas Tamazight Latin [tzm-latn]
+	//! author : Abdel Said : https://github.com/abdelsaid
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var tzmLatn = moment.defineLocale('tzm-latn', {
+	    months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
+	    monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
+	    weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
+	    weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
+	    weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[asdkh g] LT',
+	        nextDay: '[aska g] LT',
+	        nextWeek: 'dddd [g] LT',
+	        lastDay: '[assant g] LT',
+	        lastWeek: 'dddd [g] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'dadkh s yan %s',
+	        past : 'yan %s',
+	        s : 'imik',
+	        m : 'minuḍ',
+	        mm : '%d minuḍ',
+	        h : 'saɛa',
+	        hh : '%d tassaɛin',
+	        d : 'ass',
+	        dd : '%d ossan',
+	        M : 'ayowr',
+	        MM : '%d iyyirn',
+	        y : 'asgas',
+	        yy : '%d isgasn'
+	    },
+	    week : {
+	        dow : 6, // Saturday is the first day of the week.
+	        doy : 12  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return tzmLatn;
+
+	})));
+
+
+/***/ },
+/* 151 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Ukrainian [uk]
+	//! author : zemlanin : https://github.com/zemlanin
+	//! Author : Menelion Elensúle : https://github.com/Oire
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	function plural(word, num) {
+	    var forms = word.split('_');
+	    return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
+	}
+	function relativeTimeWithPlural(number, withoutSuffix, key) {
+	    var format = {
+	        'mm': withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
+	        'hh': withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
+	        'dd': 'день_дні_днів',
+	        'MM': 'місяць_місяці_місяців',
+	        'yy': 'рік_роки_років'
+	    };
+	    if (key === 'm') {
+	        return withoutSuffix ? 'хвилина' : 'хвилину';
+	    }
+	    else if (key === 'h') {
+	        return withoutSuffix ? 'година' : 'годину';
+	    }
+	    else {
+	        return number + ' ' + plural(format[key], +number);
+	    }
+	}
+	function weekdaysCaseReplace(m, format) {
+	    var weekdays = {
+	        'nominative': 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
+	        'accusative': 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split('_'),
+	        'genitive': 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split('_')
+	    };
+
+	    if (!m) {
+	        return weekdays['nominative'];
+	    }
+
+	    var nounCase = (/(\[[ВвУу]\]) ?dddd/).test(format) ?
+	        'accusative' :
+	        ((/\[?(?:минулої|наступної)? ?\] ?dddd/).test(format) ?
+	            'genitive' :
+	            'nominative');
+	    return weekdays[nounCase][m.day()];
+	}
+	function processHoursFunction(str) {
+	    return function () {
+	        return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
+	    };
+	}
+
+	var uk = moment.defineLocale('uk', {
+	    months : {
+	        'format': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_'),
+	        'standalone': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_')
+	    },
+	    monthsShort : 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
+	    weekdays : weekdaysCaseReplace,
+	    weekdaysShort : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
+	    weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD.MM.YYYY',
+	        LL : 'D MMMM YYYY р.',
+	        LLL : 'D MMMM YYYY р., HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY р., HH:mm'
+	    },
+	    calendar : {
+	        sameDay: processHoursFunction('[Сьогодні '),
+	        nextDay: processHoursFunction('[Завтра '),
+	        lastDay: processHoursFunction('[Вчора '),
+	        nextWeek: processHoursFunction('[У] dddd ['),
+	        lastWeek: function () {
+	            switch (this.day()) {
+	                case 0:
+	                case 3:
+	                case 5:
+	                case 6:
+	                    return processHoursFunction('[Минулої] dddd [').call(this);
+	                case 1:
+	                case 2:
+	                case 4:
+	                    return processHoursFunction('[Минулого] dddd [').call(this);
+	            }
+	        },
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : 'за %s',
+	        past : '%s тому',
+	        s : 'декілька секунд',
+	        m : relativeTimeWithPlural,
+	        mm : relativeTimeWithPlural,
+	        h : 'годину',
+	        hh : relativeTimeWithPlural,
+	        d : 'день',
+	        dd : relativeTimeWithPlural,
+	        M : 'місяць',
+	        MM : relativeTimeWithPlural,
+	        y : 'рік',
+	        yy : relativeTimeWithPlural
+	    },
+	    // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
+	    meridiemParse: /ночі|ранку|дня|вечора/,
+	    isPM: function (input) {
+	        return /^(дня|вечора)$/.test(input);
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 4) {
+	            return 'ночі';
+	        } else if (hour < 12) {
+	            return 'ранку';
+	        } else if (hour < 17) {
+	            return 'дня';
+	        } else {
+	            return 'вечора';
+	        }
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}-(й|го)/,
+	    ordinal: function (number, period) {
+	        switch (period) {
+	            case 'M':
+	            case 'd':
+	            case 'DDD':
+	            case 'w':
+	            case 'W':
+	                return number + '-й';
+	            case 'D':
+	                return number + '-го';
+	            default:
+	                return number;
+	        }
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return uk;
+
+	})));
+
+
+/***/ },
+/* 152 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Urdu [ur]
+	//! author : Sawood Alam : https://github.com/ibnesayeed
+	//! author : Zack : https://github.com/ZackVision
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var months = [
+	    'جنوری',
+	    'فروری',
+	    'مارچ',
+	    'اپریل',
+	    'مئی',
+	    'جون',
+	    'جولائی',
+	    'اگست',
+	    'ستمبر',
+	    'اکتوبر',
+	    'نومبر',
+	    'دسمبر'
+	];
+	var days = [
+	    'اتوار',
+	    'پیر',
+	    'منگل',
+	    'بدھ',
+	    'جمعرات',
+	    'جمعہ',
+	    'ہفتہ'
+	];
+
+	var ur = moment.defineLocale('ur', {
+	    months : months,
+	    monthsShort : months,
+	    weekdays : days,
+	    weekdaysShort : days,
+	    weekdaysMin : days,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd، D MMMM YYYY HH:mm'
+	    },
+	    meridiemParse: /صبح|شام/,
+	    isPM : function (input) {
+	        return 'شام' === input;
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        if (hour < 12) {
+	            return 'صبح';
+	        }
+	        return 'شام';
+	    },
+	    calendar : {
+	        sameDay : '[آج بوقت] LT',
+	        nextDay : '[کل بوقت] LT',
+	        nextWeek : 'dddd [بوقت] LT',
+	        lastDay : '[گذشتہ روز بوقت] LT',
+	        lastWeek : '[گذشتہ] dddd [بوقت] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : '%s بعد',
+	        past : '%s قبل',
+	        s : 'چند سیکنڈ',
+	        m : 'ایک منٹ',
+	        mm : '%d منٹ',
+	        h : 'ایک گھنٹہ',
+	        hh : '%d گھنٹے',
+	        d : 'ایک دن',
+	        dd : '%d دن',
+	        M : 'ایک ماہ',
+	        MM : '%d ماہ',
+	        y : 'ایک سال',
+	        yy : '%d سال'
+	    },
+	    preparse: function (string) {
+	        return string.replace(/،/g, ',');
+	    },
+	    postformat: function (string) {
+	        return string.replace(/,/g, '،');
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return ur;
+
+	})));
+
+
+/***/ },
+/* 153 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Uzbek [uz]
+	//! author : Sardor Muminov : https://github.com/muminoff
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var uz = moment.defineLocale('uz', {
+	    months : 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
+	    monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
+	    weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
+	    weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
+	    weekdaysMin : 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'D MMMM YYYY, dddd HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Бугун соат] LT [да]',
+	        nextDay : '[Эртага] LT [да]',
+	        nextWeek : 'dddd [куни соат] LT [да]',
+	        lastDay : '[Кеча соат] LT [да]',
+	        lastWeek : '[Утган] dddd [куни соат] LT [да]',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'Якин %s ичида',
+	        past : 'Бир неча %s олдин',
+	        s : 'фурсат',
+	        m : 'бир дакика',
+	        mm : '%d дакика',
+	        h : 'бир соат',
+	        hh : '%d соат',
+	        d : 'бир кун',
+	        dd : '%d кун',
+	        M : 'бир ой',
+	        MM : '%d ой',
+	        y : 'бир йил',
+	        yy : '%d йил'
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return uz;
+
+	})));
+
+
+/***/ },
+/* 154 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Uzbek Latin [uz-latn]
+	//! author : Rasulbek Mirzayev : github.com/Rasulbeeek
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var uzLatn = moment.defineLocale('uz-latn', {
+	    months : 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split('_'),
+	    monthsShort : 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'),
+	    weekdays : 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split('_'),
+	    weekdaysShort : 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'),
+	    weekdaysMin : 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'D MMMM YYYY, dddd HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[Bugun soat] LT [da]',
+	        nextDay : '[Ertaga] LT [da]',
+	        nextWeek : 'dddd [kuni soat] LT [da]',
+	        lastDay : '[Kecha soat] LT [da]',
+	        lastWeek : '[O\'tgan] dddd [kuni soat] LT [da]',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'Yaqin %s ichida',
+	        past : 'Bir necha %s oldin',
+	        s : 'soniya',
+	        m : 'bir daqiqa',
+	        mm : '%d daqiqa',
+	        h : 'bir soat',
+	        hh : '%d soat',
+	        d : 'bir kun',
+	        dd : '%d kun',
+	        M : 'bir oy',
+	        MM : '%d oy',
+	        y : 'bir yil',
+	        yy : '%d yil'
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 7  // The week that contains Jan 1st is the first week of the year.
+	    }
+	});
+
+	return uzLatn;
+
+	})));
+
+
+/***/ },
+/* 155 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Vietnamese [vi]
+	//! author : Bang Nguyen : https://github.com/bangnk
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var vi = moment.defineLocale('vi', {
+	    months : 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split('_'),
+	    monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
+	    weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
+	    weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
+	    weekdaysParseExact : true,
+	    meridiemParse: /sa|ch/i,
+	    isPM : function (input) {
+	        return /^ch$/i.test(input);
+	    },
+	    meridiem : function (hours, minutes, isLower) {
+	        if (hours < 12) {
+	            return isLower ? 'sa' : 'SA';
+	        } else {
+	            return isLower ? 'ch' : 'CH';
+	        }
+	    },
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM [năm] YYYY',
+	        LLL : 'D MMMM [năm] YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM [năm] YYYY HH:mm',
+	        l : 'DD/M/YYYY',
+	        ll : 'D MMM YYYY',
+	        lll : 'D MMM YYYY HH:mm',
+	        llll : 'ddd, D MMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay: '[Hôm nay lúc] LT',
+	        nextDay: '[Ngày mai lúc] LT',
+	        nextWeek: 'dddd [tuần tới lúc] LT',
+	        lastDay: '[Hôm qua lúc] LT',
+	        lastWeek: 'dddd [tuần rồi lúc] LT',
+	        sameElse: 'L'
+	    },
+	    relativeTime : {
+	        future : '%s tới',
+	        past : '%s trước',
+	        s : 'vài giây',
+	        m : 'một phút',
+	        mm : '%d phút',
+	        h : 'một giờ',
+	        hh : '%d giờ',
+	        d : 'một ngày',
+	        dd : '%d ngày',
+	        M : 'một tháng',
+	        MM : '%d tháng',
+	        y : 'một năm',
+	        yy : '%d năm'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}/,
+	    ordinal : function (number) {
+	        return number;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return vi;
+
+	})));
+
+
+/***/ },
+/* 156 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Pseudo [x-pseudo]
+	//! author : Andrew Hood : https://github.com/andrewhood125
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var xPseudo = moment.defineLocale('x-pseudo', {
+	    months : 'J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér'.split('_'),
+	    monthsShort : 'J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc'.split('_'),
+	    monthsParseExact : true,
+	    weekdays : 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý'.split('_'),
+	    weekdaysShort : 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát'.split('_'),
+	    weekdaysMin : 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
+	    weekdaysParseExact : true,
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY HH:mm',
+	        LLLL : 'dddd, D MMMM YYYY HH:mm'
+	    },
+	    calendar : {
+	        sameDay : '[T~ódá~ý át] LT',
+	        nextDay : '[T~ómó~rró~w át] LT',
+	        nextWeek : 'dddd [át] LT',
+	        lastDay : '[Ý~ést~érdá~ý át] LT',
+	        lastWeek : '[L~ást] dddd [át] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'í~ñ %s',
+	        past : '%s á~gó',
+	        s : 'á ~féw ~sécó~ñds',
+	        m : 'á ~míñ~úté',
+	        mm : '%d m~íñú~tés',
+	        h : 'á~ñ hó~úr',
+	        hh : '%d h~óúrs',
+	        d : 'á ~dáý',
+	        dd : '%d d~áýs',
+	        M : 'á ~móñ~th',
+	        MM : '%d m~óñt~hs',
+	        y : 'á ~ýéár',
+	        yy : '%d ý~éárs'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+	    ordinal : function (number) {
+	        var b = number % 10,
+	            output = (~~(number % 100 / 10) === 1) ? 'th' :
+	            (b === 1) ? 'st' :
+	            (b === 2) ? 'nd' :
+	            (b === 3) ? 'rd' : 'th';
+	        return number + output;
+	    },
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return xPseudo;
+
+	})));
+
+
+/***/ },
+/* 157 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Yoruba Nigeria [yo]
+	//! author : Atolagbe Abisoye : https://github.com/andela-batolagbe
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var yo = moment.defineLocale('yo', {
+	    months : 'Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀'.split('_'),
+	    monthsShort : 'Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀'.split('_'),
+	    weekdays : 'Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta'.split('_'),
+	    weekdaysShort : 'Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá'.split('_'),
+	    weekdaysMin : 'Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb'.split('_'),
+	    longDateFormat : {
+	        LT : 'h:mm A',
+	        LTS : 'h:mm:ss A',
+	        L : 'DD/MM/YYYY',
+	        LL : 'D MMMM YYYY',
+	        LLL : 'D MMMM YYYY h:mm A',
+	        LLLL : 'dddd, D MMMM YYYY h:mm A'
+	    },
+	    calendar : {
+	        sameDay : '[Ònì ni] LT',
+	        nextDay : '[Ọ̀la ni] LT',
+	        nextWeek : 'dddd [Ọsẹ̀ tón\'bọ] [ni] LT',
+	        lastDay : '[Àna ni] LT',
+	        lastWeek : 'dddd [Ọsẹ̀ tólọ́] [ni] LT',
+	        sameElse : 'L'
+	    },
+	    relativeTime : {
+	        future : 'ní %s',
+	        past : '%s kọjá',
+	        s : 'ìsẹjú aayá die',
+	        m : 'ìsẹjú kan',
+	        mm : 'ìsẹjú %d',
+	        h : 'wákati kan',
+	        hh : 'wákati %d',
+	        d : 'ọjọ́ kan',
+	        dd : 'ọjọ́ %d',
+	        M : 'osù kan',
+	        MM : 'osù %d',
+	        y : 'ọdún kan',
+	        yy : 'ọdún %d'
+	    },
+	    dayOfMonthOrdinalParse : /ọjọ́\s\d{1,2}/,
+	    ordinal : 'ọjọ́ %d',
+	    week : {
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4 // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return yo;
+
+	})));
+
+
+/***/ },
+/* 158 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Chinese (China) [zh-cn]
+	//! author : suupic : https://github.com/suupic
+	//! author : Zeno Zeng : https://github.com/zenozeng
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var zhCn = moment.defineLocale('zh-cn', {
+	    months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
+	    monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+	    weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
+	    weekdaysShort : '周日_周一_周二_周三_周四_周五_周六'.split('_'),
+	    weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY年MMMD日',
+	        LL : 'YYYY年MMMD日',
+	        LLL : 'YYYY年MMMD日Ah点mm分',
+	        LLLL : 'YYYY年MMMD日ddddAh点mm分',
+	        l : 'YYYY年MMMD日',
+	        ll : 'YYYY年MMMD日',
+	        lll : 'YYYY年MMMD日 HH:mm',
+	        llll : 'YYYY年MMMD日dddd HH:mm'
+	    },
+	    meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
+	    meridiemHour: function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === '凌晨' || meridiem === '早上' ||
+	                meridiem === '上午') {
+	            return hour;
+	        } else if (meridiem === '下午' || meridiem === '晚上') {
+	            return hour + 12;
+	        } else {
+	            // '中午'
+	            return hour >= 11 ? hour : hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        var hm = hour * 100 + minute;
+	        if (hm < 600) {
+	            return '凌晨';
+	        } else if (hm < 900) {
+	            return '早上';
+	        } else if (hm < 1130) {
+	            return '上午';
+	        } else if (hm < 1230) {
+	            return '中午';
+	        } else if (hm < 1800) {
+	            return '下午';
+	        } else {
+	            return '晚上';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[今天]LT',
+	        nextDay : '[明天]LT',
+	        nextWeek : '[下]ddddLT',
+	        lastDay : '[昨天]LT',
+	        lastWeek : '[上]ddddLT',
+	        sameElse : 'L'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(日|月|周)/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            case 'd':
+	            case 'D':
+	            case 'DDD':
+	                return number + '日';
+	            case 'M':
+	                return number + '月';
+	            case 'w':
+	            case 'W':
+	                return number + '周';
+	            default:
+	                return number;
+	        }
+	    },
+	    relativeTime : {
+	        future : '%s内',
+	        past : '%s前',
+	        s : '几秒',
+	        m : '1 分钟',
+	        mm : '%d 分钟',
+	        h : '1 小时',
+	        hh : '%d 小时',
+	        d : '1 天',
+	        dd : '%d 天',
+	        M : '1 个月',
+	        MM : '%d 个月',
+	        y : '1 年',
+	        yy : '%d 年'
+	    },
+	    week : {
+	        // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
+	        dow : 1, // Monday is the first day of the week.
+	        doy : 4  // The week that contains Jan 4th is the first week of the year.
+	    }
+	});
+
+	return zhCn;
+
+	})));
+
+
+/***/ },
+/* 159 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Chinese (Hong Kong) [zh-hk]
+	//! author : Ben : https://github.com/ben-lin
+	//! author : Chris Lam : https://github.com/hehachris
+	//! author : Konstantin : https://github.com/skfd
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var zhHk = moment.defineLocale('zh-hk', {
+	    months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
+	    monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+	    weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
+	    weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
+	    weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY年MMMD日',
+	        LL : 'YYYY年MMMD日',
+	        LLL : 'YYYY年MMMD日 HH:mm',
+	        LLLL : 'YYYY年MMMD日dddd HH:mm',
+	        l : 'YYYY年MMMD日',
+	        ll : 'YYYY年MMMD日',
+	        lll : 'YYYY年MMMD日 HH:mm',
+	        llll : 'YYYY年MMMD日dddd HH:mm'
+	    },
+	    meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
+	            return hour;
+	        } else if (meridiem === '中午') {
+	            return hour >= 11 ? hour : hour + 12;
+	        } else if (meridiem === '下午' || meridiem === '晚上') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        var hm = hour * 100 + minute;
+	        if (hm < 600) {
+	            return '凌晨';
+	        } else if (hm < 900) {
+	            return '早上';
+	        } else if (hm < 1130) {
+	            return '上午';
+	        } else if (hm < 1230) {
+	            return '中午';
+	        } else if (hm < 1800) {
+	            return '下午';
+	        } else {
+	            return '晚上';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[今天]LT',
+	        nextDay : '[明天]LT',
+	        nextWeek : '[下]ddddLT',
+	        lastDay : '[昨天]LT',
+	        lastWeek : '[上]ddddLT',
+	        sameElse : 'L'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            case 'd' :
+	            case 'D' :
+	            case 'DDD' :
+	                return number + '日';
+	            case 'M' :
+	                return number + '月';
+	            case 'w' :
+	            case 'W' :
+	                return number + '週';
+	            default :
+	                return number;
+	        }
+	    },
+	    relativeTime : {
+	        future : '%s內',
+	        past : '%s前',
+	        s : '幾秒',
+	        m : '1 分鐘',
+	        mm : '%d 分鐘',
+	        h : '1 小時',
+	        hh : '%d 小時',
+	        d : '1 天',
+	        dd : '%d 天',
+	        M : '1 個月',
+	        MM : '%d 個月',
+	        y : '1 年',
+	        yy : '%d 年'
+	    }
+	});
+
+	return zhHk;
+
+	})));
+
+
+/***/ },
+/* 160 */
+/***/ function(module, exports, __webpack_require__) {
+
+	//! moment.js locale configuration
+	//! locale : Chinese (Taiwan) [zh-tw]
+	//! author : Ben : https://github.com/ben-lin
+	//! author : Chris Lam : https://github.com/hehachris
+
+	;(function (global, factory) {
+	    true ? factory(__webpack_require__(43)) :
+	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
+	   factory(global.moment)
+	}(this, (function (moment) { 'use strict';
+
+
+	var zhTw = moment.defineLocale('zh-tw', {
+	    months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
+	    monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+	    weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
+	    weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
+	    weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
+	    longDateFormat : {
+	        LT : 'HH:mm',
+	        LTS : 'HH:mm:ss',
+	        L : 'YYYY年MMMD日',
+	        LL : 'YYYY年MMMD日',
+	        LLL : 'YYYY年MMMD日 HH:mm',
+	        LLLL : 'YYYY年MMMD日dddd HH:mm',
+	        l : 'YYYY年MMMD日',
+	        ll : 'YYYY年MMMD日',
+	        lll : 'YYYY年MMMD日 HH:mm',
+	        llll : 'YYYY年MMMD日dddd HH:mm'
+	    },
+	    meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
+	    meridiemHour : function (hour, meridiem) {
+	        if (hour === 12) {
+	            hour = 0;
+	        }
+	        if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
+	            return hour;
+	        } else if (meridiem === '中午') {
+	            return hour >= 11 ? hour : hour + 12;
+	        } else if (meridiem === '下午' || meridiem === '晚上') {
+	            return hour + 12;
+	        }
+	    },
+	    meridiem : function (hour, minute, isLower) {
+	        var hm = hour * 100 + minute;
+	        if (hm < 600) {
+	            return '凌晨';
+	        } else if (hm < 900) {
+	            return '早上';
+	        } else if (hm < 1130) {
+	            return '上午';
+	        } else if (hm < 1230) {
+	            return '中午';
+	        } else if (hm < 1800) {
+	            return '下午';
+	        } else {
+	            return '晚上';
+	        }
+	    },
+	    calendar : {
+	        sameDay : '[今天]LT',
+	        nextDay : '[明天]LT',
+	        nextWeek : '[下]ddddLT',
+	        lastDay : '[昨天]LT',
+	        lastWeek : '[上]ddddLT',
+	        sameElse : 'L'
+	    },
+	    dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
+	    ordinal : function (number, period) {
+	        switch (period) {
+	            case 'd' :
+	            case 'D' :
+	            case 'DDD' :
+	                return number + '日';
+	            case 'M' :
+	                return number + '月';
+	            case 'w' :
+	            case 'W' :
+	                return number + '週';
+	            default :
+	                return number;
+	        }
+	    },
+	    relativeTime : {
+	        future : '%s內',
+	        past : '%s前',
+	        s : '幾秒',
+	        m : '1 分鐘',
+	        mm : '%d 分鐘',
+	        h : '1 小時',
+	        hh : '%d 小時',
+	        d : '1 天',
+	        dd : '%d 天',
+	        M : '1 個月',
+	        MM : '%d 個月',
+	        y : '1 年',
+	        yy : '%d 年'
+	    }
+	});
+
+	return zhTw;
+
+	})));
+
+
+/***/ },
+/* 161 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var elements = __webpack_require__(19);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('bar', {
+		hover: {
+			mode: 'label'
+		},
+
+		scales: {
+			xAxes: [{
+				type: 'category',
+
+				// Specific to Bar Controller
+				categoryPercentage: 0.8,
+				barPercentage: 0.9,
+
+				// offset settings
+				offset: true,
+
+				// grid line settings
+				gridLines: {
+					offsetGridLines: true
+				}
+			}],
+
+			yAxes: [{
+				type: 'linear'
+			}]
+		}
+	});
+
+	defaults._set('horizontalBar', {
+		hover: {
+			mode: 'index',
+			axis: 'y'
+		},
+
+		scales: {
+			xAxes: [{
+				type: 'linear',
+				position: 'bottom'
+			}],
+
+			yAxes: [{
+				position: 'left',
+				type: 'category',
+
+				// Specific to Horizontal Bar Controller
+				categoryPercentage: 0.8,
+				barPercentage: 0.9,
+
+				// offset settings
+				offset: true,
+
+				// grid line settings
+				gridLines: {
+					offsetGridLines: true
+				}
+			}]
+		},
+
+		elements: {
+			rectangle: {
+				borderSkipped: 'left'
+			}
+		},
+
+		tooltips: {
+			callbacks: {
+				title: function(item, data) {
+					// Pick first xLabel for now
+					var title = '';
+
+					if (item.length > 0) {
+						if (item[0].yLabel) {
+							title = item[0].yLabel;
+						} else if (data.labels.length > 0 && item[0].index < data.labels.length) {
+							title = data.labels[item[0].index];
+						}
+					}
+
+					return title;
+				},
+
+				label: function(item, data) {
+					var datasetLabel = data.datasets[item.datasetIndex].label || '';
+					return datasetLabel + ': ' + item.xLabel;
+				}
+			},
+			mode: 'index',
+			axis: 'y'
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		Chart.controllers.bar = Chart.DatasetController.extend({
+
+			dataElementType: elements.Rectangle,
+
+			initialize: function() {
+				var me = this;
+				var meta;
+
+				Chart.DatasetController.prototype.initialize.apply(me, arguments);
+
+				meta = me.getMeta();
+				meta.stack = me.getDataset().stack;
+				meta.bar = true;
+			},
+
+			update: function(reset) {
+				var me = this;
+				var rects = me.getMeta().data;
+				var i, ilen;
+
+				me._ruler = me.getRuler();
+
+				for (i = 0, ilen = rects.length; i < ilen; ++i) {
+					me.updateElement(rects[i], i, reset);
+				}
+			},
+
+			updateElement: function(rectangle, index, reset) {
+				var me = this;
+				var chart = me.chart;
+				var meta = me.getMeta();
+				var dataset = me.getDataset();
+				var custom = rectangle.custom || {};
+				var rectangleOptions = chart.options.elements.rectangle;
+
+				rectangle._xScale = me.getScaleForId(meta.xAxisID);
+				rectangle._yScale = me.getScaleForId(meta.yAxisID);
+				rectangle._datasetIndex = me.index;
+				rectangle._index = index;
+
+				rectangle._model = {
+					datasetLabel: dataset.label,
+					label: chart.data.labels[index],
+					borderSkipped: custom.borderSkipped ? custom.borderSkipped : rectangleOptions.borderSkipped,
+					backgroundColor: custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.backgroundColor, index, rectangleOptions.backgroundColor),
+					borderColor: custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.borderColor, index, rectangleOptions.borderColor),
+					borderWidth: custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.borderWidth, index, rectangleOptions.borderWidth)
+				};
+
+				me.updateElementGeometry(rectangle, index, reset);
+
+				rectangle.pivot();
+			},
+
+			/**
+			 * @private
+			 */
+			updateElementGeometry: function(rectangle, index, reset) {
+				var me = this;
+				var model = rectangle._model;
+				var vscale = me.getValueScale();
+				var base = vscale.getBasePixel();
+				var horizontal = vscale.isHorizontal();
+				var ruler = me._ruler || me.getRuler();
+				var vpixels = me.calculateBarValuePixels(me.index, index);
+				var ipixels = me.calculateBarIndexPixels(me.index, index, ruler);
+
+				model.horizontal = horizontal;
+				model.base = reset ? base : vpixels.base;
+				model.x = horizontal ? reset ? base : vpixels.head : ipixels.center;
+				model.y = horizontal ? ipixels.center : reset ? base : vpixels.head;
+				model.height = horizontal ? ipixels.size : undefined;
+				model.width = horizontal ? undefined : ipixels.size;
+			},
+
+			/**
+			 * @private
+			 */
+			getValueScaleId: function() {
+				return this.getMeta().yAxisID;
+			},
+
+			/**
+			 * @private
+			 */
+			getIndexScaleId: function() {
+				return this.getMeta().xAxisID;
+			},
+
+			/**
+			 * @private
+			 */
+			getValueScale: function() {
+				return this.getScaleForId(this.getValueScaleId());
+			},
+
+			/**
+			 * @private
+			 */
+			getIndexScale: function() {
+				return this.getScaleForId(this.getIndexScaleId());
+			},
+
+			/**
+			 * Returns the effective number of stacks based on groups and bar visibility.
+			 * @private
+			 */
+			getStackCount: function(last) {
+				var me = this;
+				var chart = me.chart;
+				var scale = me.getIndexScale();
+				var stacked = scale.options.stacked;
+				var ilen = last === undefined ? chart.data.datasets.length : last + 1;
+				var stacks = [];
+				var i, meta;
+
+				for (i = 0; i < ilen; ++i) {
+					meta = chart.getDatasetMeta(i);
+					if (meta.bar && chart.isDatasetVisible(i) &&
+						(stacked === false ||
+						(stacked === true && stacks.indexOf(meta.stack) === -1) ||
+						(stacked === undefined && (meta.stack === undefined || stacks.indexOf(meta.stack) === -1)))) {
+						stacks.push(meta.stack);
+					}
+				}
+
+				return stacks.length;
+			},
+
+			/**
+			 * Returns the stack index for the given dataset based on groups and bar visibility.
+			 * @private
+			 */
+			getStackIndex: function(datasetIndex) {
+				return this.getStackCount(datasetIndex) - 1;
+			},
+
+			/**
+			 * @private
+			 */
+			getRuler: function() {
+				var me = this;
+				var scale = me.getIndexScale();
+				var stackCount = me.getStackCount();
+				var datasetIndex = me.index;
+				var pixels = [];
+				var isHorizontal = scale.isHorizontal();
+				var start = isHorizontal ? scale.left : scale.top;
+				var end = start + (isHorizontal ? scale.width : scale.height);
+				var i, ilen;
+
+				for (i = 0, ilen = me.getMeta().data.length; i < ilen; ++i) {
+					pixels.push(scale.getPixelForValue(null, i, datasetIndex));
+				}
+
+				return {
+					pixels: pixels,
+					start: start,
+					end: end,
+					stackCount: stackCount,
+					scale: scale
+				};
+			},
+
+			/**
+			 * Note: pixel values are not clamped to the scale area.
+			 * @private
+			 */
+			calculateBarValuePixels: function(datasetIndex, index) {
+				var me = this;
+				var chart = me.chart;
+				var meta = me.getMeta();
+				var scale = me.getValueScale();
+				var datasets = chart.data.datasets;
+				var value = scale.getRightValue(datasets[datasetIndex].data[index]);
+				var stacked = scale.options.stacked;
+				var stack = meta.stack;
+				var start = 0;
+				var i, imeta, ivalue, base, head, size;
+
+				if (stacked || (stacked === undefined && stack !== undefined)) {
+					for (i = 0; i < datasetIndex; ++i) {
+						imeta = chart.getDatasetMeta(i);
+
+						if (imeta.bar &&
+							imeta.stack === stack &&
+							imeta.controller.getValueScaleId() === scale.id &&
+							chart.isDatasetVisible(i)) {
+
+							ivalue = scale.getRightValue(datasets[i].data[index]);
+							if ((value < 0 && ivalue < 0) || (value >= 0 && ivalue > 0)) {
+								start += ivalue;
+							}
+						}
+					}
+				}
+
+				base = scale.getPixelForValue(start);
+				head = scale.getPixelForValue(start + value);
+				size = (head - base) / 2;
+
+				return {
+					size: size,
+					base: base,
+					head: head,
+					center: head + size / 2
+				};
+			},
+
+			/**
+			 * @private
+			 */
+			calculateBarIndexPixels: function(datasetIndex, index, ruler) {
+				var me = this;
+				var options = ruler.scale.options;
+				var stackIndex = me.getStackIndex(datasetIndex);
+				var pixels = ruler.pixels;
+				var base = pixels[index];
+				var length = pixels.length;
+				var start = ruler.start;
+				var end = ruler.end;
+				var leftSampleSize, rightSampleSize, leftCategorySize, rightCategorySize, fullBarSize, size;
+
+				if (length === 1) {
+					leftSampleSize = base > start ? base - start : end - base;
+					rightSampleSize = base < end ? end - base : base - start;
+				} else {
+					if (index > 0) {
+						leftSampleSize = (base - pixels[index - 1]) / 2;
+						if (index === length - 1) {
+							rightSampleSize = leftSampleSize;
+						}
+					}
+					if (index < length - 1) {
+						rightSampleSize = (pixels[index + 1] - base) / 2;
+						if (index === 0) {
+							leftSampleSize = rightSampleSize;
+						}
+					}
+				}
+
+				leftCategorySize = leftSampleSize * options.categoryPercentage;
+				rightCategorySize = rightSampleSize * options.categoryPercentage;
+				fullBarSize = (leftCategorySize + rightCategorySize) / ruler.stackCount;
+				size = fullBarSize * options.barPercentage;
+
+				size = Math.min(
+					helpers.valueOrDefault(options.barThickness, size),
+					helpers.valueOrDefault(options.maxBarThickness, Infinity));
+
+				base -= leftCategorySize;
+				base += fullBarSize * stackIndex;
+				base += (fullBarSize - size) / 2;
+
+				return {
+					size: size,
+					base: base,
+					head: base + size,
+					center: base + size / 2
+				};
+			},
+
+			draw: function() {
+				var me = this;
+				var chart = me.chart;
+				var scale = me.getValueScale();
+				var rects = me.getMeta().data;
+				var dataset = me.getDataset();
+				var ilen = rects.length;
+				var i = 0;
+
+				helpers.canvas.clipArea(chart.ctx, chart.chartArea);
+
+				for (; i < ilen; ++i) {
+					if (!isNaN(scale.getRightValue(dataset.data[i]))) {
+						rects[i].draw();
+					}
+				}
+
+				helpers.canvas.unclipArea(chart.ctx);
+			},
+
+			setHoverStyle: function(rectangle) {
+				var dataset = this.chart.data.datasets[rectangle._datasetIndex];
+				var index = rectangle._index;
+				var custom = rectangle.custom || {};
+				var model = rectangle._model;
+
+				model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : helpers.valueAtIndexOrDefault(dataset.hoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor));
+				model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : helpers.valueAtIndexOrDefault(dataset.hoverBorderColor, index, helpers.getHoverColor(model.borderColor));
+				model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : helpers.valueAtIndexOrDefault(dataset.hoverBorderWidth, index, model.borderWidth);
+			},
+
+			removeHoverStyle: function(rectangle) {
+				var dataset = this.chart.data.datasets[rectangle._datasetIndex];
+				var index = rectangle._index;
+				var custom = rectangle.custom || {};
+				var model = rectangle._model;
+				var rectangleElementOptions = this.chart.options.elements.rectangle;
+
+				model.backgroundColor = custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.backgroundColor, index, rectangleElementOptions.backgroundColor);
+				model.borderColor = custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.borderColor, index, rectangleElementOptions.borderColor);
+				model.borderWidth = custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.borderWidth, index, rectangleElementOptions.borderWidth);
+			}
+		});
+
+		Chart.controllers.horizontalBar = Chart.controllers.bar.extend({
+			/**
+			 * @private
+			 */
+			getValueScaleId: function() {
+				return this.getMeta().xAxisID;
+			},
+
+			/**
+			 * @private
+			 */
+			getIndexScaleId: function() {
+				return this.getMeta().yAxisID;
+			}
+		});
+	};
+
+
+/***/ },
+/* 162 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var elements = __webpack_require__(19);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('bubble', {
+		hover: {
+			mode: 'single'
+		},
+
+		scales: {
+			xAxes: [{
+				type: 'linear', // bubble should probably use a linear scale by default
+				position: 'bottom',
+				id: 'x-axis-0' // need an ID so datasets can reference the scale
+			}],
+			yAxes: [{
+				type: 'linear',
+				position: 'left',
+				id: 'y-axis-0'
+			}]
+		},
+
+		tooltips: {
+			callbacks: {
+				title: function() {
+					// Title doesn't make sense for scatter since we format the data as a point
+					return '';
+				},
+				label: function(item, data) {
+					var datasetLabel = data.datasets[item.datasetIndex].label || '';
+					var dataPoint = data.datasets[item.datasetIndex].data[item.index];
+					return datasetLabel + ': (' + item.xLabel + ', ' + item.yLabel + ', ' + dataPoint.r + ')';
+				}
+			}
+		}
+	});
+
+
+	module.exports = function(Chart) {
+
+		Chart.controllers.bubble = Chart.DatasetController.extend({
+			/**
+			 * @protected
+			 */
+			dataElementType: elements.Point,
+
+			/**
+			 * @protected
+			 */
+			update: function(reset) {
+				var me = this;
+				var meta = me.getMeta();
+				var points = meta.data;
+
+				// Update Points
+				helpers.each(points, function(point, index) {
+					me.updateElement(point, index, reset);
+				});
+			},
+
+			/**
+			 * @protected
+			 */
+			updateElement: function(point, index, reset) {
+				var me = this;
+				var meta = me.getMeta();
+				var custom = point.custom || {};
+				var xScale = me.getScaleForId(meta.xAxisID);
+				var yScale = me.getScaleForId(meta.yAxisID);
+				var options = me._resolveElementOptions(point, index);
+				var data = me.getDataset().data[index];
+				var dsIndex = me.index;
+
+				var x = reset ? xScale.getPixelForDecimal(0.5) : xScale.getPixelForValue(typeof data === 'object' ? data : NaN, index, dsIndex);
+				var y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(data, index, dsIndex);
+
+				point._xScale = xScale;
+				point._yScale = yScale;
+				point._options = options;
+				point._datasetIndex = dsIndex;
+				point._index = index;
+				point._model = {
+					backgroundColor: options.backgroundColor,
+					borderColor: options.borderColor,
+					borderWidth: options.borderWidth,
+					hitRadius: options.hitRadius,
+					pointStyle: options.pointStyle,
+					radius: reset ? 0 : options.radius,
+					skip: custom.skip || isNaN(x) || isNaN(y),
+					x: x,
+					y: y,
+				};
+
+				point.pivot();
+			},
+
+			/**
+			 * @protected
+			 */
+			setHoverStyle: function(point) {
+				var model = point._model;
+				var options = point._options;
+
+				model.backgroundColor = helpers.valueOrDefault(options.hoverBackgroundColor, helpers.getHoverColor(options.backgroundColor));
+				model.borderColor = helpers.valueOrDefault(options.hoverBorderColor, helpers.getHoverColor(options.borderColor));
+				model.borderWidth = helpers.valueOrDefault(options.hoverBorderWidth, options.borderWidth);
+				model.radius = options.radius + options.hoverRadius;
+			},
+
+			/**
+			 * @protected
+			 */
+			removeHoverStyle: function(point) {
+				var model = point._model;
+				var options = point._options;
+
+				model.backgroundColor = options.backgroundColor;
+				model.borderColor = options.borderColor;
+				model.borderWidth = options.borderWidth;
+				model.radius = options.radius;
+			},
+
+			/**
+			 * @private
+			 */
+			_resolveElementOptions: function(point, index) {
+				var me = this;
+				var chart = me.chart;
+				var datasets = chart.data.datasets;
+				var dataset = datasets[me.index];
+				var custom = point.custom || {};
+				var options = chart.options.elements.point;
+				var resolve = helpers.options.resolve;
+				var data = dataset.data[index];
+				var values = {};
+				var i, ilen, key;
+
+				// Scriptable options
+				var context = {
+					chart: chart,
+					dataIndex: index,
+					dataset: dataset,
+					datasetIndex: me.index
+				};
+
+				var keys = [
+					'backgroundColor',
+					'borderColor',
+					'borderWidth',
+					'hoverBackgroundColor',
+					'hoverBorderColor',
+					'hoverBorderWidth',
+					'hoverRadius',
+					'hitRadius',
+					'pointStyle'
+				];
+
+				for (i = 0, ilen = keys.length; i < ilen; ++i) {
+					key = keys[i];
+					values[key] = resolve([
+						custom[key],
+						dataset[key],
+						options[key]
+					], context, index);
+				}
+
+				// Custom radius resolution
+				values.radius = resolve([
+					custom.radius,
+					data ? data.r : undefined,
+					dataset.radius,
+					options.radius
+				], context, index);
+
+				return values;
+			}
+		});
+	};
+
+
+/***/ },
+/* 163 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var elements = __webpack_require__(19);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('doughnut', {
+		animation: {
+			// Boolean - Whether we animate the rotation of the Doughnut
+			animateRotate: true,
+			// Boolean - Whether we animate scaling the Doughnut from the centre
+			animateScale: false
+		},
+		hover: {
+			mode: 'single'
+		},
+		legendCallback: function(chart) {
+			var text = [];
+			text.push('<ul class="' + chart.id + '-legend">');
+
+			var data = chart.data;
+			var datasets = data.datasets;
+			var labels = data.labels;
+
+			if (datasets.length) {
+				for (var i = 0; i < datasets[0].data.length; ++i) {
+					text.push('<li><span style="background-color:' + datasets[0].backgroundColor[i] + '"></span>');
+					if (labels[i]) {
+						text.push(labels[i]);
+					}
+					text.push('</li>');
+				}
+			}
+
+			text.push('</ul>');
+			return text.join('');
+		},
+		legend: {
+			labels: {
+				generateLabels: function(chart) {
+					var data = chart.data;
+					if (data.labels.length && data.datasets.length) {
+						return data.labels.map(function(label, i) {
+							var meta = chart.getDatasetMeta(0);
+							var ds = data.datasets[0];
+							var arc = meta.data[i];
+							var custom = arc && arc.custom || {};
+							var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
+							var arcOpts = chart.options.elements.arc;
+							var fill = custom.backgroundColor ? custom.backgroundColor : valueAtIndexOrDefault(ds.backgroundColor, i, arcOpts.backgroundColor);
+							var stroke = custom.borderColor ? custom.borderColor : valueAtIndexOrDefault(ds.borderColor, i, arcOpts.borderColor);
+							var bw = custom.borderWidth ? custom.borderWidth : valueAtIndexOrDefault(ds.borderWidth, i, arcOpts.borderWidth);
+
+							return {
+								text: label,
+								fillStyle: fill,
+								strokeStyle: stroke,
+								lineWidth: bw,
+								hidden: isNaN(ds.data[i]) || meta.data[i].hidden,
+
+								// Extra data used for toggling the correct item
+								index: i
+							};
+						});
+					}
+					return [];
+				}
+			},
+
+			onClick: function(e, legendItem) {
+				var index = legendItem.index;
+				var chart = this.chart;
+				var i, ilen, meta;
+
+				for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) {
+					meta = chart.getDatasetMeta(i);
+					// toggle visibility of index if exists
+					if (meta.data[index]) {
+						meta.data[index].hidden = !meta.data[index].hidden;
+					}
+				}
+
+				chart.update();
+			}
+		},
+
+		// The percentage of the chart that we cut out of the middle.
+		cutoutPercentage: 50,
+
+		// The rotation of the chart, where the first data arc begins.
+		rotation: Math.PI * -0.5,
+
+		// The total circumference of the chart.
+		circumference: Math.PI * 2.0,
+
+		// Need to override these to give a nice default
+		tooltips: {
+			callbacks: {
+				title: function() {
+					return '';
+				},
+				label: function(tooltipItem, data) {
+					var dataLabel = data.labels[tooltipItem.index];
+					var value = ': ' + data.datasets[tooltipItem.datasetIndex].data[tooltipItem.index];
+
+					if (helpers.isArray(dataLabel)) {
+						// show value on first line of multiline label
+						// need to clone because we are changing the value
+						dataLabel = dataLabel.slice();
+						dataLabel[0] += value;
+					} else {
+						dataLabel += value;
+					}
+
+					return dataLabel;
+				}
+			}
+		}
+	});
+
+	defaults._set('pie', helpers.clone(defaults.doughnut));
+	defaults._set('pie', {
+		cutoutPercentage: 0
+	});
+
+	module.exports = function(Chart) {
+
+		Chart.controllers.doughnut = Chart.controllers.pie = Chart.DatasetController.extend({
+
+			dataElementType: elements.Arc,
+
+			linkScales: helpers.noop,
+
+			// Get index of the dataset in relation to the visible datasets. This allows determining the inner and outer radius correctly
+			getRingIndex: function(datasetIndex) {
+				var ringIndex = 0;
+
+				for (var j = 0; j < datasetIndex; ++j) {
+					if (this.chart.isDatasetVisible(j)) {
+						++ringIndex;
+					}
+				}
+
+				return ringIndex;
+			},
+
+			update: function(reset) {
+				var me = this;
+				var chart = me.chart;
+				var chartArea = chart.chartArea;
+				var opts = chart.options;
+				var arcOpts = opts.elements.arc;
+				var availableWidth = chartArea.right - chartArea.left - arcOpts.borderWidth;
+				var availableHeight = chartArea.bottom - chartArea.top - arcOpts.borderWidth;
+				var minSize = Math.min(availableWidth, availableHeight);
+				var offset = {x: 0, y: 0};
+				var meta = me.getMeta();
+				var cutoutPercentage = opts.cutoutPercentage;
+				var circumference = opts.circumference;
+
+				// If the chart's circumference isn't a full circle, calculate minSize as a ratio of the width/height of the arc
+				if (circumference < Math.PI * 2.0) {
+					var startAngle = opts.rotation % (Math.PI * 2.0);
+					startAngle += Math.PI * 2.0 * (startAngle >= Math.PI ? -1 : startAngle < -Math.PI ? 1 : 0);
+					var endAngle = startAngle + circumference;
+					var start = {x: Math.cos(startAngle), y: Math.sin(startAngle)};
+					var end = {x: Math.cos(endAngle), y: Math.sin(endAngle)};
+					var contains0 = (startAngle <= 0 && endAngle >= 0) || (startAngle <= Math.PI * 2.0 && Math.PI * 2.0 <= endAngle);
+					var contains90 = (startAngle <= Math.PI * 0.5 && Math.PI * 0.5 <= endAngle) || (startAngle <= Math.PI * 2.5 && Math.PI * 2.5 <= endAngle);
+					var contains180 = (startAngle <= -Math.PI && -Math.PI <= endAngle) || (startAngle <= Math.PI && Math.PI <= endAngle);
+					var contains270 = (startAngle <= -Math.PI * 0.5 && -Math.PI * 0.5 <= endAngle) || (startAngle <= Math.PI * 1.5 && Math.PI * 1.5 <= endAngle);
+					var cutout = cutoutPercentage / 100.0;
+					var min = {x: contains180 ? -1 : Math.min(start.x * (start.x < 0 ? 1 : cutout), end.x * (end.x < 0 ? 1 : cutout)), y: contains270 ? -1 : Math.min(start.y * (start.y < 0 ? 1 : cutout), end.y * (end.y < 0 ? 1 : cutout))};
+					var max = {x: contains0 ? 1 : Math.max(start.x * (start.x > 0 ? 1 : cutout), end.x * (end.x > 0 ? 1 : cutout)), y: contains90 ? 1 : Math.max(start.y * (start.y > 0 ? 1 : cutout), end.y * (end.y > 0 ? 1 : cutout))};
+					var size = {width: (max.x - min.x) * 0.5, height: (max.y - min.y) * 0.5};
+					minSize = Math.min(availableWidth / size.width, availableHeight / size.height);
+					offset = {x: (max.x + min.x) * -0.5, y: (max.y + min.y) * -0.5};
+				}
+
+				chart.borderWidth = me.getMaxBorderWidth(meta.data);
+				chart.outerRadius = Math.max((minSize - chart.borderWidth) / 2, 0);
+				chart.innerRadius = Math.max(cutoutPercentage ? (chart.outerRadius / 100) * (cutoutPercentage) : 0, 0);
+				chart.radiusLength = (chart.outerRadius - chart.innerRadius) / chart.getVisibleDatasetCount();
+				chart.offsetX = offset.x * chart.outerRadius;
+				chart.offsetY = offset.y * chart.outerRadius;
+
+				meta.total = me.calculateTotal();
+
+				me.outerRadius = chart.outerRadius - (chart.radiusLength * me.getRingIndex(me.index));
+				me.innerRadius = Math.max(me.outerRadius - chart.radiusLength, 0);
+
+				helpers.each(meta.data, function(arc, index) {
+					me.updateElement(arc, index, reset);
+				});
+			},
+
+			updateElement: function(arc, index, reset) {
+				var me = this;
+				var chart = me.chart;
+				var chartArea = chart.chartArea;
+				var opts = chart.options;
+				var animationOpts = opts.animation;
+				var centerX = (chartArea.left + chartArea.right) / 2;
+				var centerY = (chartArea.top + chartArea.bottom) / 2;
+				var startAngle = opts.rotation; // non reset case handled later
+				var endAngle = opts.rotation; // non reset case handled later
+				var dataset = me.getDataset();
+				var circumference = reset && animationOpts.animateRotate ? 0 : arc.hidden ? 0 : me.calculateCircumference(dataset.data[index]) * (opts.circumference / (2.0 * Math.PI));
+				var innerRadius = reset && animationOpts.animateScale ? 0 : me.innerRadius;
+				var outerRadius = reset && animationOpts.animateScale ? 0 : me.outerRadius;
+				var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
+
+				helpers.extend(arc, {
+					// Utility
+					_datasetIndex: me.index,
+					_index: index,
+
+					// Desired view properties
+					_model: {
+						x: centerX + chart.offsetX,
+						y: centerY + chart.offsetY,
+						startAngle: startAngle,
+						endAngle: endAngle,
+						circumference: circumference,
+						outerRadius: outerRadius,
+						innerRadius: innerRadius,
+						label: valueAtIndexOrDefault(dataset.label, index, chart.data.labels[index])
+					}
+				});
+
+				var model = arc._model;
+				// Resets the visual styles
+				this.removeHoverStyle(arc);
+
+				// Set correct angles if not resetting
+				if (!reset || !animationOpts.animateRotate) {
+					if (index === 0) {
+						model.startAngle = opts.rotation;
+					} else {
+						model.startAngle = me.getMeta().data[index - 1]._model.endAngle;
+					}
+
+					model.endAngle = model.startAngle + model.circumference;
+				}
+
+				arc.pivot();
+			},
+
+			removeHoverStyle: function(arc) {
+				Chart.DatasetController.prototype.removeHoverStyle.call(this, arc, this.chart.options.elements.arc);
+			},
+
+			calculateTotal: function() {
+				var dataset = this.getDataset();
+				var meta = this.getMeta();
+				var total = 0;
+				var value;
+
+				helpers.each(meta.data, function(element, index) {
+					value = dataset.data[index];
+					if (!isNaN(value) && !element.hidden) {
+						total += Math.abs(value);
+					}
+				});
+
+				/* if (total === 0) {
+					total = NaN;
+				}*/
+
+				return total;
+			},
+
+			calculateCircumference: function(value) {
+				var total = this.getMeta().total;
+				if (total > 0 && !isNaN(value)) {
+					return (Math.PI * 2.0) * (value / total);
+				}
+				return 0;
+			},
+
+			// gets the max border or hover width to properly scale pie charts
+			getMaxBorderWidth: function(arcs) {
+				var max = 0;
+				var index = this.index;
+				var length = arcs.length;
+				var borderWidth;
+				var hoverWidth;
+
+				for (var i = 0; i < length; i++) {
+					borderWidth = arcs[i]._model ? arcs[i]._model.borderWidth : 0;
+					hoverWidth = arcs[i]._chart ? arcs[i]._chart.config.data.datasets[index].hoverBorderWidth : 0;
+
+					max = borderWidth > max ? borderWidth : max;
+					max = hoverWidth > max ? hoverWidth : max;
+				}
+				return max;
+			}
+		});
+	};
+
+
+/***/ },
+/* 164 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var elements = __webpack_require__(19);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('line', {
+		showLines: true,
+		spanGaps: false,
+
+		hover: {
+			mode: 'label'
+		},
+
+		scales: {
+			xAxes: [{
+				type: 'category',
+				id: 'x-axis-0'
+			}],
+			yAxes: [{
+				type: 'linear',
+				id: 'y-axis-0'
+			}]
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		function lineEnabled(dataset, options) {
+			return helpers.valueOrDefault(dataset.showLine, options.showLines);
+		}
+
+		Chart.controllers.line = Chart.DatasetController.extend({
+
+			datasetElementType: elements.Line,
+
+			dataElementType: elements.Point,
+
+			update: function(reset) {
+				var me = this;
+				var meta = me.getMeta();
+				var line = meta.dataset;
+				var points = meta.data || [];
+				var options = me.chart.options;
+				var lineElementOptions = options.elements.line;
+				var scale = me.getScaleForId(meta.yAxisID);
+				var i, ilen, custom;
+				var dataset = me.getDataset();
+				var showLine = lineEnabled(dataset, options);
+
+				// Update Line
+				if (showLine) {
+					custom = line.custom || {};
+
+					// Compatibility: If the properties are defined with only the old name, use those values
+					if ((dataset.tension !== undefined) && (dataset.lineTension === undefined)) {
+						dataset.lineTension = dataset.tension;
+					}
+
+					// Utility
+					line._scale = scale;
+					line._datasetIndex = me.index;
+					// Data
+					line._children = points;
+					// Model
+					line._model = {
+						// Appearance
+						// The default behavior of lines is to break at null values, according
+						// to https://github.com/chartjs/Chart.js/issues/2435#issuecomment-216718158
+						// This option gives lines the ability to span gaps
+						spanGaps: dataset.spanGaps ? dataset.spanGaps : options.spanGaps,
+						tension: custom.tension ? custom.tension : helpers.valueOrDefault(dataset.lineTension, lineElementOptions.tension),
+						backgroundColor: custom.backgroundColor ? custom.backgroundColor : (dataset.backgroundColor || lineElementOptions.backgroundColor),
+						borderWidth: custom.borderWidth ? custom.borderWidth : (dataset.borderWidth || lineElementOptions.borderWidth),
+						borderColor: custom.borderColor ? custom.borderColor : (dataset.borderColor || lineElementOptions.borderColor),
+						borderCapStyle: custom.borderCapStyle ? custom.borderCapStyle : (dataset.borderCapStyle || lineElementOptions.borderCapStyle),
+						borderDash: custom.borderDash ? custom.borderDash : (dataset.borderDash || lineElementOptions.borderDash),
+						borderDashOffset: custom.borderDashOffset ? custom.borderDashOffset : (dataset.borderDashOffset || lineElementOptions.borderDashOffset),
+						borderJoinStyle: custom.borderJoinStyle ? custom.borderJoinStyle : (dataset.borderJoinStyle || lineElementOptions.borderJoinStyle),
+						fill: custom.fill ? custom.fill : (dataset.fill !== undefined ? dataset.fill : lineElementOptions.fill),
+						steppedLine: custom.steppedLine ? custom.steppedLine : helpers.valueOrDefault(dataset.steppedLine, lineElementOptions.stepped),
+						cubicInterpolationMode: custom.cubicInterpolationMode ? custom.cubicInterpolationMode : helpers.valueOrDefault(dataset.cubicInterpolationMode, lineElementOptions.cubicInterpolationMode),
+					};
+
+					line.pivot();
+				}
+
+				// Update Points
+				for (i = 0, ilen = points.length; i < ilen; ++i) {
+					me.updateElement(points[i], i, reset);
+				}
+
+				if (showLine && line._model.tension !== 0) {
+					me.updateBezierControlPoints();
+				}
+
+				// Now pivot the point for animation
+				for (i = 0, ilen = points.length; i < ilen; ++i) {
+					points[i].pivot();
+				}
+			},
+
+			getPointBackgroundColor: function(point, index) {
+				var backgroundColor = this.chart.options.elements.point.backgroundColor;
+				var dataset = this.getDataset();
+				var custom = point.custom || {};
+
+				if (custom.backgroundColor) {
+					backgroundColor = custom.backgroundColor;
+				} else if (dataset.pointBackgroundColor) {
+					backgroundColor = helpers.valueAtIndexOrDefault(dataset.pointBackgroundColor, index, backgroundColor);
+				} else if (dataset.backgroundColor) {
+					backgroundColor = dataset.backgroundColor;
+				}
+
+				return backgroundColor;
+			},
+
+			getPointBorderColor: function(point, index) {
+				var borderColor = this.chart.options.elements.point.borderColor;
+				var dataset = this.getDataset();
+				var custom = point.custom || {};
+
+				if (custom.borderColor) {
+					borderColor = custom.borderColor;
+				} else if (dataset.pointBorderColor) {
+					borderColor = helpers.valueAtIndexOrDefault(dataset.pointBorderColor, index, borderColor);
+				} else if (dataset.borderColor) {
+					borderColor = dataset.borderColor;
+				}
+
+				return borderColor;
+			},
+
+			getPointBorderWidth: function(point, index) {
+				var borderWidth = this.chart.options.elements.point.borderWidth;
+				var dataset = this.getDataset();
+				var custom = point.custom || {};
+
+				if (!isNaN(custom.borderWidth)) {
+					borderWidth = custom.borderWidth;
+				} else if (!isNaN(dataset.pointBorderWidth) || helpers.isArray(dataset.pointBorderWidth)) {
+					borderWidth = helpers.valueAtIndexOrDefault(dataset.pointBorderWidth, index, borderWidth);
+				} else if (!isNaN(dataset.borderWidth)) {
+					borderWidth = dataset.borderWidth;
+				}
+
+				return borderWidth;
+			},
+
+			updateElement: function(point, index, reset) {
+				var me = this;
+				var meta = me.getMeta();
+				var custom = point.custom || {};
+				var dataset = me.getDataset();
+				var datasetIndex = me.index;
+				var value = dataset.data[index];
+				var yScale = me.getScaleForId(meta.yAxisID);
+				var xScale = me.getScaleForId(meta.xAxisID);
+				var pointOptions = me.chart.options.elements.point;
+				var x, y;
+
+				// Compatibility: If the properties are defined with only the old name, use those values
+				if ((dataset.radius !== undefined) && (dataset.pointRadius === undefined)) {
+					dataset.pointRadius = dataset.radius;
+				}
+				if ((dataset.hitRadius !== undefined) && (dataset.pointHitRadius === undefined)) {
+					dataset.pointHitRadius = dataset.hitRadius;
+				}
+
+				x = xScale.getPixelForValue(typeof value === 'object' ? value : NaN, index, datasetIndex);
+				y = reset ? yScale.getBasePixel() : me.calculatePointY(value, index, datasetIndex);
+
+				// Utility
+				point._xScale = xScale;
+				point._yScale = yScale;
+				point._datasetIndex = datasetIndex;
+				point._index = index;
+
+				// Desired view properties
+				point._model = {
+					x: x,
+					y: y,
+					skip: custom.skip || isNaN(x) || isNaN(y),
+					// Appearance
+					radius: custom.radius || helpers.valueAtIndexOrDefault(dataset.pointRadius, index, pointOptions.radius),
+					pointStyle: custom.pointStyle || helpers.valueAtIndexOrDefault(dataset.pointStyle, index, pointOptions.pointStyle),
+					backgroundColor: me.getPointBackgroundColor(point, index),
+					borderColor: me.getPointBorderColor(point, index),
+					borderWidth: me.getPointBorderWidth(point, index),
+					tension: meta.dataset._model ? meta.dataset._model.tension : 0,
+					steppedLine: meta.dataset._model ? meta.dataset._model.steppedLine : false,
+					// Tooltip
+					hitRadius: custom.hitRadius || helpers.valueAtIndexOrDefault(dataset.pointHitRadius, index, pointOptions.hitRadius)
+				};
+			},
+
+			calculatePointY: function(value, index, datasetIndex) {
+				var me = this;
+				var chart = me.chart;
+				var meta = me.getMeta();
+				var yScale = me.getScaleForId(meta.yAxisID);
+				var sumPos = 0;
+				var sumNeg = 0;
+				var i, ds, dsMeta;
+
+				if (yScale.options.stacked) {
+					for (i = 0; i < datasetIndex; i++) {
+						ds = chart.data.datasets[i];
+						dsMeta = chart.getDatasetMeta(i);
+						if (dsMeta.type === 'line' && dsMeta.yAxisID === yScale.id && chart.isDatasetVisible(i)) {
+							var stackedRightValue = Number(yScale.getRightValue(ds.data[index]));
+							if (stackedRightValue < 0) {
+								sumNeg += stackedRightValue || 0;
+							} else {
+								sumPos += stackedRightValue || 0;
+							}
+						}
+					}
+
+					var rightValue = Number(yScale.getRightValue(value));
+					if (rightValue < 0) {
+						return yScale.getPixelForValue(sumNeg + rightValue);
+					}
+					return yScale.getPixelForValue(sumPos + rightValue);
+				}
+
+				return yScale.getPixelForValue(value);
+			},
+
+			updateBezierControlPoints: function() {
+				var me = this;
+				var meta = me.getMeta();
+				var area = me.chart.chartArea;
+				var points = (meta.data || []);
+				var i, ilen, point, model, controlPoints;
+
+				// Only consider points that are drawn in case the spanGaps option is used
+				if (meta.dataset._model.spanGaps) {
+					points = points.filter(function(pt) {
+						return !pt._model.skip;
+					});
+				}
+
+				function capControlPoint(pt, min, max) {
+					return Math.max(Math.min(pt, max), min);
+				}
+
+				if (meta.dataset._model.cubicInterpolationMode === 'monotone') {
+					helpers.splineCurveMonotone(points);
+				} else {
+					for (i = 0, ilen = points.length; i < ilen; ++i) {
+						point = points[i];
+						model = point._model;
+						controlPoints = helpers.splineCurve(
+							helpers.previousItem(points, i)._model,
+							model,
+							helpers.nextItem(points, i)._model,
+							meta.dataset._model.tension
+						);
+						model.controlPointPreviousX = controlPoints.previous.x;
+						model.controlPointPreviousY = controlPoints.previous.y;
+						model.controlPointNextX = controlPoints.next.x;
+						model.controlPointNextY = controlPoints.next.y;
+					}
+				}
+
+				if (me.chart.options.elements.line.capBezierPoints) {
+					for (i = 0, ilen = points.length; i < ilen; ++i) {
+						model = points[i]._model;
+						model.controlPointPreviousX = capControlPoint(model.controlPointPreviousX, area.left, area.right);
+						model.controlPointPreviousY = capControlPoint(model.controlPointPreviousY, area.top, area.bottom);
+						model.controlPointNextX = capControlPoint(model.controlPointNextX, area.left, area.right);
+						model.controlPointNextY = capControlPoint(model.controlPointNextY, area.top, area.bottom);
+					}
+				}
+			},
+
+			draw: function() {
+				var me = this;
+				var chart = me.chart;
+				var meta = me.getMeta();
+				var points = meta.data || [];
+				var area = chart.chartArea;
+				var ilen = points.length;
+				var i = 0;
+
+				helpers.canvas.clipArea(chart.ctx, area);
+
+				if (lineEnabled(me.getDataset(), chart.options)) {
+					meta.dataset.draw();
+				}
+
+				helpers.canvas.unclipArea(chart.ctx);
+
+				// Draw the points
+				for (; i < ilen; ++i) {
+					points[i].draw(area);
+				}
+			},
+
+			setHoverStyle: function(point) {
+				// Point
+				var dataset = this.chart.data.datasets[point._datasetIndex];
+				var index = point._index;
+				var custom = point.custom || {};
+				var model = point._model;
+
+				model.radius = custom.hoverRadius || helpers.valueAtIndexOrDefault(dataset.pointHoverRadius, index, this.chart.options.elements.point.hoverRadius);
+				model.backgroundColor = custom.hoverBackgroundColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor));
+				model.borderColor = custom.hoverBorderColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.getHoverColor(model.borderColor));
+				model.borderWidth = custom.hoverBorderWidth || helpers.valueAtIndexOrDefault(dataset.pointHoverBorderWidth, index, model.borderWidth);
+			},
+
+			removeHoverStyle: function(point) {
+				var me = this;
+				var dataset = me.chart.data.datasets[point._datasetIndex];
+				var index = point._index;
+				var custom = point.custom || {};
+				var model = point._model;
+
+				// Compatibility: If the properties are defined with only the old name, use those values
+				if ((dataset.radius !== undefined) && (dataset.pointRadius === undefined)) {
+					dataset.pointRadius = dataset.radius;
+				}
+
+				model.radius = custom.radius || helpers.valueAtIndexOrDefault(dataset.pointRadius, index, me.chart.options.elements.point.radius);
+				model.backgroundColor = me.getPointBackgroundColor(point, index);
+				model.borderColor = me.getPointBorderColor(point, index);
+				model.borderWidth = me.getPointBorderWidth(point, index);
+			}
+		});
+	};
+
+
+/***/ },
+/* 165 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var elements = __webpack_require__(19);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('polarArea', {
+		scale: {
+			type: 'radialLinear',
+			angleLines: {
+				display: false
+			},
+			gridLines: {
+				circular: true
+			},
+			pointLabels: {
+				display: false
+			},
+			ticks: {
+				beginAtZero: true
+			}
+		},
+
+		// Boolean - Whether to animate the rotation of the chart
+		animation: {
+			animateRotate: true,
+			animateScale: true
+		},
+
+		startAngle: -0.5 * Math.PI,
+		legendCallback: function(chart) {
+			var text = [];
+			text.push('<ul class="' + chart.id + '-legend">');
+
+			var data = chart.data;
+			var datasets = data.datasets;
+			var labels = data.labels;
+
+			if (datasets.length) {
+				for (var i = 0; i < datasets[0].data.length; ++i) {
+					text.push('<li><span style="background-color:' + datasets[0].backgroundColor[i] + '"></span>');
+					if (labels[i]) {
+						text.push(labels[i]);
+					}
+					text.push('</li>');
+				}
+			}
+
+			text.push('</ul>');
+			return text.join('');
+		},
+		legend: {
+			labels: {
+				generateLabels: function(chart) {
+					var data = chart.data;
+					if (data.labels.length && data.datasets.length) {
+						return data.labels.map(function(label, i) {
+							var meta = chart.getDatasetMeta(0);
+							var ds = data.datasets[0];
+							var arc = meta.data[i];
+							var custom = arc.custom || {};
+							var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
+							var arcOpts = chart.options.elements.arc;
+							var fill = custom.backgroundColor ? custom.backgroundColor : valueAtIndexOrDefault(ds.backgroundColor, i, arcOpts.backgroundColor);
+							var stroke = custom.borderColor ? custom.borderColor : valueAtIndexOrDefault(ds.borderColor, i, arcOpts.borderColor);
+							var bw = custom.borderWidth ? custom.borderWidth : valueAtIndexOrDefault(ds.borderWidth, i, arcOpts.borderWidth);
+
+							return {
+								text: label,
+								fillStyle: fill,
+								strokeStyle: stroke,
+								lineWidth: bw,
+								hidden: isNaN(ds.data[i]) || meta.data[i].hidden,
+
+								// Extra data used for toggling the correct item
+								index: i
+							};
+						});
+					}
+					return [];
+				}
+			},
+
+			onClick: function(e, legendItem) {
+				var index = legendItem.index;
+				var chart = this.chart;
+				var i, ilen, meta;
+
+				for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) {
+					meta = chart.getDatasetMeta(i);
+					meta.data[index].hidden = !meta.data[index].hidden;
+				}
+
+				chart.update();
+			}
+		},
+
+		// Need to override these to give a nice default
+		tooltips: {
+			callbacks: {
+				title: function() {
+					return '';
+				},
+				label: function(item, data) {
+					return data.labels[item.index] + ': ' + item.yLabel;
+				}
+			}
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		Chart.controllers.polarArea = Chart.DatasetController.extend({
+
+			dataElementType: elements.Arc,
+
+			linkScales: helpers.noop,
+
+			update: function(reset) {
+				var me = this;
+				var chart = me.chart;
+				var chartArea = chart.chartArea;
+				var meta = me.getMeta();
+				var opts = chart.options;
+				var arcOpts = opts.elements.arc;
+				var minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);
+				chart.outerRadius = Math.max((minSize - arcOpts.borderWidth / 2) / 2, 0);
+				chart.innerRadius = Math.max(opts.cutoutPercentage ? (chart.outerRadius / 100) * (opts.cutoutPercentage) : 1, 0);
+				chart.radiusLength = (chart.outerRadius - chart.innerRadius) / chart.getVisibleDatasetCount();
+
+				me.outerRadius = chart.outerRadius - (chart.radiusLength * me.index);
+				me.innerRadius = me.outerRadius - chart.radiusLength;
+
+				meta.count = me.countVisibleElements();
+
+				helpers.each(meta.data, function(arc, index) {
+					me.updateElement(arc, index, reset);
+				});
+			},
+
+			updateElement: function(arc, index, reset) {
+				var me = this;
+				var chart = me.chart;
+				var dataset = me.getDataset();
+				var opts = chart.options;
+				var animationOpts = opts.animation;
+				var scale = chart.scale;
+				var labels = chart.data.labels;
+
+				var circumference = me.calculateCircumference(dataset.data[index]);
+				var centerX = scale.xCenter;
+				var centerY = scale.yCenter;
+
+				// If there is NaN data before us, we need to calculate the starting angle correctly.
+				// We could be way more efficient here, but its unlikely that the polar area chart will have a lot of data
+				var visibleCount = 0;
+				var meta = me.getMeta();
+				for (var i = 0; i < index; ++i) {
+					if (!isNaN(dataset.data[i]) && !meta.data[i].hidden) {
+						++visibleCount;
+					}
+				}
+
+				// var negHalfPI = -0.5 * Math.PI;
+				var datasetStartAngle = opts.startAngle;
+				var distance = arc.hidden ? 0 : scale.getDistanceFromCenterForValue(dataset.data[index]);
+				var startAngle = datasetStartAngle + (circumference * visibleCount);
+				var endAngle = startAngle + (arc.hidden ? 0 : circumference);
+
+				var resetRadius = animationOpts.animateScale ? 0 : scale.getDistanceFromCenterForValue(dataset.data[index]);
+
+				helpers.extend(arc, {
+					// Utility
+					_datasetIndex: me.index,
+					_index: index,
+					_scale: scale,
+
+					// Desired view properties
+					_model: {
+						x: centerX,
+						y: centerY,
+						innerRadius: 0,
+						outerRadius: reset ? resetRadius : distance,
+						startAngle: reset && animationOpts.animateRotate ? datasetStartAngle : startAngle,
+						endAngle: reset && animationOpts.animateRotate ? datasetStartAngle : endAngle,
+						label: helpers.valueAtIndexOrDefault(labels, index, labels[index])
+					}
+				});
+
+				// Apply border and fill style
+				me.removeHoverStyle(arc);
+
+				arc.pivot();
+			},
+
+			removeHoverStyle: function(arc) {
+				Chart.DatasetController.prototype.removeHoverStyle.call(this, arc, this.chart.options.elements.arc);
+			},
+
+			countVisibleElements: function() {
+				var dataset = this.getDataset();
+				var meta = this.getMeta();
+				var count = 0;
+
+				helpers.each(meta.data, function(element, index) {
+					if (!isNaN(dataset.data[index]) && !element.hidden) {
+						count++;
+					}
+				});
+
+				return count;
+			},
+
+			calculateCircumference: function(value) {
+				var count = this.getMeta().count;
+				if (count > 0 && !isNaN(value)) {
+					return (2 * Math.PI) / count;
+				}
+				return 0;
+			}
+		});
+	};
+
+
+/***/ },
+/* 166 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var elements = __webpack_require__(19);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('radar', {
+		scale: {
+			type: 'radialLinear'
+		},
+		elements: {
+			line: {
+				tension: 0 // no bezier in radar
+			}
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		Chart.controllers.radar = Chart.DatasetController.extend({
+
+			datasetElementType: elements.Line,
+
+			dataElementType: elements.Point,
+
+			linkScales: helpers.noop,
+
+			update: function(reset) {
+				var me = this;
+				var meta = me.getMeta();
+				var line = meta.dataset;
+				var points = meta.data;
+				var custom = line.custom || {};
+				var dataset = me.getDataset();
+				var lineElementOptions = me.chart.options.elements.line;
+				var scale = me.chart.scale;
+
+				// Compatibility: If the properties are defined with only the old name, use those values
+				if ((dataset.tension !== undefined) && (dataset.lineTension === undefined)) {
+					dataset.lineTension = dataset.tension;
+				}
+
+				helpers.extend(meta.dataset, {
+					// Utility
+					_datasetIndex: me.index,
+					_scale: scale,
+					// Data
+					_children: points,
+					_loop: true,
+					// Model
+					_model: {
+						// Appearance
+						tension: custom.tension ? custom.tension : helpers.valueOrDefault(dataset.lineTension, lineElementOptions.tension),
+						backgroundColor: custom.backgroundColor ? custom.backgroundColor : (dataset.backgroundColor || lineElementOptions.backgroundColor),
+						borderWidth: custom.borderWidth ? custom.borderWidth : (dataset.borderWidth || lineElementOptions.borderWidth),
+						borderColor: custom.borderColor ? custom.borderColor : (dataset.borderColor || lineElementOptions.borderColor),
+						fill: custom.fill ? custom.fill : (dataset.fill !== undefined ? dataset.fill : lineElementOptions.fill),
+						borderCapStyle: custom.borderCapStyle ? custom.borderCapStyle : (dataset.borderCapStyle || lineElementOptions.borderCapStyle),
+						borderDash: custom.borderDash ? custom.borderDash : (dataset.borderDash || lineElementOptions.borderDash),
+						borderDashOffset: custom.borderDashOffset ? custom.borderDashOffset : (dataset.borderDashOffset || lineElementOptions.borderDashOffset),
+						borderJoinStyle: custom.borderJoinStyle ? custom.borderJoinStyle : (dataset.borderJoinStyle || lineElementOptions.borderJoinStyle),
+					}
+				});
+
+				meta.dataset.pivot();
+
+				// Update Points
+				helpers.each(points, function(point, index) {
+					me.updateElement(point, index, reset);
+				}, me);
+
+				// Update bezier control points
+				me.updateBezierControlPoints();
+			},
+			updateElement: function(point, index, reset) {
+				var me = this;
+				var custom = point.custom || {};
+				var dataset = me.getDataset();
+				var scale = me.chart.scale;
+				var pointElementOptions = me.chart.options.elements.point;
+				var pointPosition = scale.getPointPositionForValue(index, dataset.data[index]);
+
+				// Compatibility: If the properties are defined with only the old name, use those values
+				if ((dataset.radius !== undefined) && (dataset.pointRadius === undefined)) {
+					dataset.pointRadius = dataset.radius;
+				}
+				if ((dataset.hitRadius !== undefined) && (dataset.pointHitRadius === undefined)) {
+					dataset.pointHitRadius = dataset.hitRadius;
+				}
+
+				helpers.extend(point, {
+					// Utility
+					_datasetIndex: me.index,
+					_index: index,
+					_scale: scale,
+
+					// Desired view properties
+					_model: {
+						x: reset ? scale.xCenter : pointPosition.x, // value not used in dataset scale, but we want a consistent API between scales
+						y: reset ? scale.yCenter : pointPosition.y,
+
+						// Appearance
+						tension: custom.tension ? custom.tension : helpers.valueOrDefault(dataset.lineTension, me.chart.options.elements.line.tension),
+						radius: custom.radius ? custom.radius : helpers.valueAtIndexOrDefault(dataset.pointRadius, index, pointElementOptions.radius),
+						backgroundColor: custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.pointBackgroundColor, index, pointElementOptions.backgroundColor),
+						borderColor: custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.pointBorderColor, index, pointElementOptions.borderColor),
+						borderWidth: custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.pointBorderWidth, index, pointElementOptions.borderWidth),
+						pointStyle: custom.pointStyle ? custom.pointStyle : helpers.valueAtIndexOrDefault(dataset.pointStyle, index, pointElementOptions.pointStyle),
+
+						// Tooltip
+						hitRadius: custom.hitRadius ? custom.hitRadius : helpers.valueAtIndexOrDefault(dataset.pointHitRadius, index, pointElementOptions.hitRadius)
+					}
+				});
+
+				point._model.skip = custom.skip ? custom.skip : (isNaN(point._model.x) || isNaN(point._model.y));
+			},
+			updateBezierControlPoints: function() {
+				var chartArea = this.chart.chartArea;
+				var meta = this.getMeta();
+
+				helpers.each(meta.data, function(point, index) {
+					var model = point._model;
+					var controlPoints = helpers.splineCurve(
+						helpers.previousItem(meta.data, index, true)._model,
+						model,
+						helpers.nextItem(meta.data, index, true)._model,
+						model.tension
+					);
+
+					// Prevent the bezier going outside of the bounds of the graph
+					model.controlPointPreviousX = Math.max(Math.min(controlPoints.previous.x, chartArea.right), chartArea.left);
+					model.controlPointPreviousY = Math.max(Math.min(controlPoints.previous.y, chartArea.bottom), chartArea.top);
+
+					model.controlPointNextX = Math.max(Math.min(controlPoints.next.x, chartArea.right), chartArea.left);
+					model.controlPointNextY = Math.max(Math.min(controlPoints.next.y, chartArea.bottom), chartArea.top);
+
+					// Now pivot the point for animation
+					point.pivot();
+				});
+			},
+
+			setHoverStyle: function(point) {
+				// Point
+				var dataset = this.chart.data.datasets[point._datasetIndex];
+				var custom = point.custom || {};
+				var index = point._index;
+				var model = point._model;
+
+				model.radius = custom.hoverRadius ? custom.hoverRadius : helpers.valueAtIndexOrDefault(dataset.pointHoverRadius, index, this.chart.options.elements.point.hoverRadius);
+				model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor));
+				model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.getHoverColor(model.borderColor));
+				model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : helpers.valueAtIndexOrDefault(dataset.pointHoverBorderWidth, index, model.borderWidth);
+			},
+
+			removeHoverStyle: function(point) {
+				var dataset = this.chart.data.datasets[point._datasetIndex];
+				var custom = point.custom || {};
+				var index = point._index;
+				var model = point._model;
+				var pointElementOptions = this.chart.options.elements.point;
+
+				model.radius = custom.radius ? custom.radius : helpers.valueAtIndexOrDefault(dataset.pointRadius, index, pointElementOptions.radius);
+				model.backgroundColor = custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.pointBackgroundColor, index, pointElementOptions.backgroundColor);
+				model.borderColor = custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.pointBorderColor, index, pointElementOptions.borderColor);
+				model.borderWidth = custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.pointBorderWidth, index, pointElementOptions.borderWidth);
+			}
+		});
+	};
+
+
+/***/ },
+/* 167 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+
+	defaults._set('scatter', {
+		hover: {
+			mode: 'single'
+		},
+
+		scales: {
+			xAxes: [{
+				id: 'x-axis-1',    // need an ID so datasets can reference the scale
+				type: 'linear',    // scatter should not use a category axis
+				position: 'bottom'
+			}],
+			yAxes: [{
+				id: 'y-axis-1',
+				type: 'linear',
+				position: 'left'
+			}]
+		},
+
+		showLines: false,
+
+		tooltips: {
+			callbacks: {
+				title: function() {
+					return '';     // doesn't make sense for scatter since data are formatted as a point
+				},
+				label: function(item) {
+					return '(' + item.xLabel + ', ' + item.yLabel + ')';
+				}
+			}
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		// Scatter charts use line controllers
+		Chart.controllers.scatter = Chart.controllers.line;
+
+	};
+
+
+/***/ },
+/* 168 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+
+		Chart.Bar = function(context, config) {
+			config.type = 'bar';
+
+			return new Chart(context, config);
+		};
+
+	};
+
+
+/***/ },
+/* 169 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+
+		Chart.Bubble = function(context, config) {
+			config.type = 'bubble';
+			return new Chart(context, config);
+		};
+
+	};
+
+
+/***/ },
+/* 170 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+
+		Chart.Doughnut = function(context, config) {
+			config.type = 'doughnut';
+
+			return new Chart(context, config);
+		};
+
+	};
+
+
+/***/ },
+/* 171 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+
+		Chart.Line = function(context, config) {
+			config.type = 'line';
+
+			return new Chart(context, config);
+		};
+
+	};
+
+
+/***/ },
+/* 172 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+
+		Chart.PolarArea = function(context, config) {
+			config.type = 'polarArea';
+
+			return new Chart(context, config);
+		};
+
+	};
+
+
+/***/ },
+/* 173 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+
+		Chart.Radar = function(context, config) {
+			config.type = 'radar';
+
+			return new Chart(context, config);
+		};
+
+	};
+
+
+/***/ },
+/* 174 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function(Chart) {
+		Chart.Scatter = function(context, config) {
+			config.type = 'scatter';
+			return new Chart(context, config);
+		};
+	};
+
+
+/***/ },
+/* 175 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Plugin based on discussion from the following Chart.js issues:
+	 * @see https://github.com/chartjs/Chart.js/issues/2380#issuecomment-279961569
+	 * @see https://github.com/chartjs/Chart.js/issues/2440#issuecomment-256461897
+	 */
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var elements = __webpack_require__(19);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('global', {
+		plugins: {
+			filler: {
+				propagate: true
+			}
+		}
+	});
+
+	module.exports = function() {
+
+		var mappers = {
+			dataset: function(source) {
+				var index = source.fill;
+				var chart = source.chart;
+				var meta = chart.getDatasetMeta(index);
+				var visible = meta && chart.isDatasetVisible(index);
+				var points = (visible && meta.dataset._children) || [];
+				var length = points.length || 0;
+
+				return !length ? null : function(point, i) {
+					return (i < length && points[i]._view) || null;
+				};
+			},
+
+			boundary: function(source) {
+				var boundary = source.boundary;
+				var x = boundary ? boundary.x : null;
+				var y = boundary ? boundary.y : null;
+
+				return function(point) {
+					return {
+						x: x === null ? point.x : x,
+						y: y === null ? point.y : y,
+					};
+				};
+			}
+		};
+
+		// @todo if (fill[0] === '#')
+		function decodeFill(el, index, count) {
+			var model = el._model || {};
+			var fill = model.fill;
+			var target;
+
+			if (fill === undefined) {
+				fill = !!model.backgroundColor;
+			}
+
+			if (fill === false || fill === null) {
+				return false;
+			}
+
+			if (fill === true) {
+				return 'origin';
+			}
+
+			target = parseFloat(fill, 10);
+			if (isFinite(target) && Math.floor(target) === target) {
+				if (fill[0] === '-' || fill[0] === '+') {
+					target = index + target;
+				}
+
+				if (target === index || target < 0 || target >= count) {
+					return false;
+				}
+
+				return target;
+			}
+
+			switch (fill) {
+			// compatibility
+			case 'bottom':
+				return 'start';
+			case 'top':
+				return 'end';
+			case 'zero':
+				return 'origin';
+			// supported boundaries
+			case 'origin':
+			case 'start':
+			case 'end':
+				return fill;
+			// invalid fill values
+			default:
+				return false;
+			}
+		}
+
+		function computeBoundary(source) {
+			var model = source.el._model || {};
+			var scale = source.el._scale || {};
+			var fill = source.fill;
+			var target = null;
+			var horizontal;
+
+			if (isFinite(fill)) {
+				return null;
+			}
+
+			// Backward compatibility: until v3, we still need to support boundary values set on
+			// the model (scaleTop, scaleBottom and scaleZero) because some external plugins and
+			// controllers might still use it (e.g. the Smith chart).
+
+			if (fill === 'start') {
+				target = model.scaleBottom === undefined ? scale.bottom : model.scaleBottom;
+			} else if (fill === 'end') {
+				target = model.scaleTop === undefined ? scale.top : model.scaleTop;
+			} else if (model.scaleZero !== undefined) {
+				target = model.scaleZero;
+			} else if (scale.getBasePosition) {
+				target = scale.getBasePosition();
+			} else if (scale.getBasePixel) {
+				target = scale.getBasePixel();
+			}
+
+			if (target !== undefined && target !== null) {
+				if (target.x !== undefined && target.y !== undefined) {
+					return target;
+				}
+
+				if (typeof target === 'number' && isFinite(target)) {
+					horizontal = scale.isHorizontal();
+					return {
+						x: horizontal ? target : null,
+						y: horizontal ? null : target
+					};
+				}
+			}
+
+			return null;
+		}
+
+		function resolveTarget(sources, index, propagate) {
+			var source = sources[index];
+			var fill = source.fill;
+			var visited = [index];
+			var target;
+
+			if (!propagate) {
+				return fill;
+			}
+
+			while (fill !== false && visited.indexOf(fill) === -1) {
+				if (!isFinite(fill)) {
+					return fill;
+				}
+
+				target = sources[fill];
+				if (!target) {
+					return false;
+				}
+
+				if (target.visible) {
+					return fill;
+				}
+
+				visited.push(fill);
+				fill = target.fill;
+			}
+
+			return false;
+		}
+
+		function createMapper(source) {
+			var fill = source.fill;
+			var type = 'dataset';
+
+			if (fill === false) {
+				return null;
+			}
+
+			if (!isFinite(fill)) {
+				type = 'boundary';
+			}
+
+			return mappers[type](source);
+		}
+
+		function isDrawable(point) {
+			return point && !point.skip;
+		}
+
+		function drawArea(ctx, curve0, curve1, len0, len1) {
+			var i;
+
+			if (!len0 || !len1) {
+				return;
+			}
+
+			// building first area curve (normal)
+			ctx.moveTo(curve0[0].x, curve0[0].y);
+			for (i = 1; i < len0; ++i) {
+				helpers.canvas.lineTo(ctx, curve0[i - 1], curve0[i]);
+			}
+
+			// joining the two area curves
+			ctx.lineTo(curve1[len1 - 1].x, curve1[len1 - 1].y);
+
+			// building opposite area curve (reverse)
+			for (i = len1 - 1; i > 0; --i) {
+				helpers.canvas.lineTo(ctx, curve1[i], curve1[i - 1], true);
+			}
+		}
+
+		function doFill(ctx, points, mapper, view, color, loop) {
+			var count = points.length;
+			var span = view.spanGaps;
+			var curve0 = [];
+			var curve1 = [];
+			var len0 = 0;
+			var len1 = 0;
+			var i, ilen, index, p0, p1, d0, d1;
+
+			ctx.beginPath();
+
+			for (i = 0, ilen = (count + !!loop); i < ilen; ++i) {
+				index = i % count;
+				p0 = points[index]._view;
+				p1 = mapper(p0, index, view);
+				d0 = isDrawable(p0);
+				d1 = isDrawable(p1);
+
+				if (d0 && d1) {
+					len0 = curve0.push(p0);
+					len1 = curve1.push(p1);
+				} else if (len0 && len1) {
+					if (!span) {
+						drawArea(ctx, curve0, curve1, len0, len1);
+						len0 = len1 = 0;
+						curve0 = [];
+						curve1 = [];
+					} else {
+						if (d0) {
+							curve0.push(p0);
+						}
+						if (d1) {
+							curve1.push(p1);
+						}
+					}
+				}
+			}
+
+			drawArea(ctx, curve0, curve1, len0, len1);
+
+			ctx.closePath();
+			ctx.fillStyle = color;
+			ctx.fill();
+		}
+
+		return {
+			id: 'filler',
+
+			afterDatasetsUpdate: function(chart, options) {
+				var count = (chart.data.datasets || []).length;
+				var propagate = options.propagate;
+				var sources = [];
+				var meta, i, el, source;
+
+				for (i = 0; i < count; ++i) {
+					meta = chart.getDatasetMeta(i);
+					el = meta.dataset;
+					source = null;
+
+					if (el && el._model && el instanceof elements.Line) {
+						source = {
+							visible: chart.isDatasetVisible(i),
+							fill: decodeFill(el, i, count),
+							chart: chart,
+							el: el
+						};
+					}
+
+					meta.$filler = source;
+					sources.push(source);
+				}
+
+				for (i = 0; i < count; ++i) {
+					source = sources[i];
+					if (!source) {
+						continue;
+					}
+
+					source.fill = resolveTarget(sources, i, propagate);
+					source.boundary = computeBoundary(source);
+					source.mapper = createMapper(source);
+				}
+			},
+
+			beforeDatasetDraw: function(chart, args) {
+				var meta = args.meta.$filler;
+				if (!meta) {
+					return;
+				}
+
+				var ctx = chart.ctx;
+				var el = meta.el;
+				var view = el._view;
+				var points = el._children || [];
+				var mapper = meta.mapper;
+				var color = view.backgroundColor || defaults.global.defaultColor;
+
+				if (mapper && color && points.length) {
+					helpers.canvas.clipArea(ctx, chart.chartArea);
+					doFill(ctx, points, mapper, view, color, el._loop);
+					helpers.canvas.unclipArea(ctx);
+				}
+			}
+		};
+	};
+
+
+/***/ },
+/* 176 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('global', {
+		legend: {
+			display: true,
+			position: 'top',
+			fullWidth: true,
+			reverse: false,
+			weight: 1000,
+
+			// a callback that will handle
+			onClick: function(e, legendItem) {
+				var index = legendItem.datasetIndex;
+				var ci = this.chart;
+				var meta = ci.getDatasetMeta(index);
+
+				// See controller.isDatasetVisible comment
+				meta.hidden = meta.hidden === null ? !ci.data.datasets[index].hidden : null;
+
+				// We hid a dataset ... rerender the chart
+				ci.update();
+			},
+
+			onHover: null,
+
+			labels: {
+				boxWidth: 40,
+				padding: 10,
+				// Generates labels shown in the legend
+				// Valid properties to return:
+				// text : text to display
+				// fillStyle : fill of coloured box
+				// strokeStyle: stroke of coloured box
+				// hidden : if this legend item refers to a hidden item
+				// lineCap : cap style for line
+				// lineDash
+				// lineDashOffset :
+				// lineJoin :
+				// lineWidth :
+				generateLabels: function(chart) {
+					var data = chart.data;
+					return helpers.isArray(data.datasets) ? data.datasets.map(function(dataset, i) {
+						return {
+							text: dataset.label,
+							fillStyle: (!helpers.isArray(dataset.backgroundColor) ? dataset.backgroundColor : dataset.backgroundColor[0]),
+							hidden: !chart.isDatasetVisible(i),
+							lineCap: dataset.borderCapStyle,
+							lineDash: dataset.borderDash,
+							lineDashOffset: dataset.borderDashOffset,
+							lineJoin: dataset.borderJoinStyle,
+							lineWidth: dataset.borderWidth,
+							strokeStyle: dataset.borderColor,
+							pointStyle: dataset.pointStyle,
+
+							// Below is extra data used for toggling the datasets
+							datasetIndex: i
+						};
+					}, this) : [];
+				}
+			}
+		},
+
+		legendCallback: function(chart) {
+			var text = [];
+			text.push('<ul class="' + chart.id + '-legend">');
+			for (var i = 0; i < chart.data.datasets.length; i++) {
+				text.push('<li><span style="background-color:' + chart.data.datasets[i].backgroundColor + '"></span>');
+				if (chart.data.datasets[i].label) {
+					text.push(chart.data.datasets[i].label);
+				}
+				text.push('</li>');
+			}
+			text.push('</ul>');
+			return text.join('');
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		var layout = Chart.layoutService;
+		var noop = helpers.noop;
+
+		/**
+		 * Helper function to get the box width based on the usePointStyle option
+		 * @param labelopts {Object} the label options on the legend
+		 * @param fontSize {Number} the label font size
+		 * @return {Number} width of the color box area
+		 */
+		function getBoxWidth(labelOpts, fontSize) {
+			return labelOpts.usePointStyle ?
+				fontSize * Math.SQRT2 :
+				labelOpts.boxWidth;
+		}
+
+		Chart.Legend = Element.extend({
+
+			initialize: function(config) {
+				helpers.extend(this, config);
+
+				// Contains hit boxes for each dataset (in dataset order)
+				this.legendHitBoxes = [];
+
+				// Are we in doughnut mode which has a different data type
+				this.doughnutMode = false;
+			},
+
+			// These methods are ordered by lifecycle. Utilities then follow.
+			// Any function defined here is inherited by all legend types.
+			// Any function can be extended by the legend type
+
+			beforeUpdate: noop,
+			update: function(maxWidth, maxHeight, margins) {
+				var me = this;
+
+				// Update Lifecycle - Probably don't want to ever extend or overwrite this function ;)
+				me.beforeUpdate();
+
+				// Absorb the master measurements
+				me.maxWidth = maxWidth;
+				me.maxHeight = maxHeight;
+				me.margins = margins;
+
+				// Dimensions
+				me.beforeSetDimensions();
+				me.setDimensions();
+				me.afterSetDimensions();
+				// Labels
+				me.beforeBuildLabels();
+				me.buildLabels();
+				me.afterBuildLabels();
+
+				// Fit
+				me.beforeFit();
+				me.fit();
+				me.afterFit();
+				//
+				me.afterUpdate();
+
+				return me.minSize;
+			},
+			afterUpdate: noop,
+
+			//
+
+			beforeSetDimensions: noop,
+			setDimensions: function() {
+				var me = this;
+				// Set the unconstrained dimension before label rotation
+				if (me.isHorizontal()) {
+					// Reset position before calculating rotation
+					me.width = me.maxWidth;
+					me.left = 0;
+					me.right = me.width;
+				} else {
+					me.height = me.maxHeight;
+
+					// Reset position before calculating rotation
+					me.top = 0;
+					me.bottom = me.height;
+				}
+
+				// Reset padding
+				me.paddingLeft = 0;
+				me.paddingTop = 0;
+				me.paddingRight = 0;
+				me.paddingBottom = 0;
+
+				// Reset minSize
+				me.minSize = {
+					width: 0,
+					height: 0
+				};
+			},
+			afterSetDimensions: noop,
+
+			//
+
+			beforeBuildLabels: noop,
+			buildLabels: function() {
+				var me = this;
+				var labelOpts = me.options.labels || {};
+				var legendItems = helpers.callback(labelOpts.generateLabels, [me.chart], me) || [];
+
+				if (labelOpts.filter) {
+					legendItems = legendItems.filter(function(item) {
+						return labelOpts.filter(item, me.chart.data);
+					});
+				}
+
+				if (me.options.reverse) {
+					legendItems.reverse();
+				}
+
+				me.legendItems = legendItems;
+			},
+			afterBuildLabels: noop,
+
+			//
+
+			beforeFit: noop,
+			fit: function() {
+				var me = this;
+				var opts = me.options;
+				var labelOpts = opts.labels;
+				var display = opts.display;
+
+				var ctx = me.ctx;
+
+				var globalDefault = defaults.global;
+				var valueOrDefault = helpers.valueOrDefault;
+				var fontSize = valueOrDefault(labelOpts.fontSize, globalDefault.defaultFontSize);
+				var fontStyle = valueOrDefault(labelOpts.fontStyle, globalDefault.defaultFontStyle);
+				var fontFamily = valueOrDefault(labelOpts.fontFamily, globalDefault.defaultFontFamily);
+				var labelFont = helpers.fontString(fontSize, fontStyle, fontFamily);
+
+				// Reset hit boxes
+				var hitboxes = me.legendHitBoxes = [];
+
+				var minSize = me.minSize;
+				var isHorizontal = me.isHorizontal();
+
+				if (isHorizontal) {
+					minSize.width = me.maxWidth; // fill all the width
+					minSize.height = display ? 10 : 0;
+				} else {
+					minSize.width = display ? 10 : 0;
+					minSize.height = me.maxHeight; // fill all the height
+				}
+
+				// Increase sizes here
+				if (display) {
+					ctx.font = labelFont;
+
+					if (isHorizontal) {
+						// Labels
+
+						// Width of each line of legend boxes. Labels wrap onto multiple lines when there are too many to fit on one
+						var lineWidths = me.lineWidths = [0];
+						var totalHeight = me.legendItems.length ? fontSize + (labelOpts.padding) : 0;
+
+						ctx.textAlign = 'left';
+						ctx.textBaseline = 'top';
+
+						helpers.each(me.legendItems, function(legendItem, i) {
+							var boxWidth = getBoxWidth(labelOpts, fontSize);
+							var width = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;
+
+							if (lineWidths[lineWidths.length - 1] + width + labelOpts.padding >= me.width) {
+								totalHeight += fontSize + (labelOpts.padding);
+								lineWidths[lineWidths.length] = me.left;
+							}
+
+							// Store the hitbox width and height here. Final position will be updated in `draw`
+							hitboxes[i] = {
+								left: 0,
+								top: 0,
+								width: width,
+								height: fontSize
+							};
+
+							lineWidths[lineWidths.length - 1] += width + labelOpts.padding;
+						});
+
+						minSize.height += totalHeight;
+
+					} else {
+						var vPadding = labelOpts.padding;
+						var columnWidths = me.columnWidths = [];
+						var totalWidth = labelOpts.padding;
+						var currentColWidth = 0;
+						var currentColHeight = 0;
+						var itemHeight = fontSize + vPadding;
+
+						helpers.each(me.legendItems, function(legendItem, i) {
+							var boxWidth = getBoxWidth(labelOpts, fontSize);
+							var itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;
+
+							// If too tall, go to new column
+							if (currentColHeight + itemHeight > minSize.height) {
+								totalWidth += currentColWidth + labelOpts.padding;
+								columnWidths.push(currentColWidth); // previous column width
+
+								currentColWidth = 0;
+								currentColHeight = 0;
+							}
+
+							// Get max width
+							currentColWidth = Math.max(currentColWidth, itemWidth);
+							currentColHeight += itemHeight;
+
+							// Store the hitbox width and height here. Final position will be updated in `draw`
+							hitboxes[i] = {
+								left: 0,
+								top: 0,
+								width: itemWidth,
+								height: fontSize
+							};
+						});
+
+						totalWidth += currentColWidth;
+						columnWidths.push(currentColWidth);
+						minSize.width += totalWidth;
+					}
+				}
+
+				me.width = minSize.width;
+				me.height = minSize.height;
+			},
+			afterFit: noop,
+
+			// Shared Methods
+			isHorizontal: function() {
+				return this.options.position === 'top' || this.options.position === 'bottom';
+			},
+
+			// Actually draw the legend on the canvas
+			draw: function() {
+				var me = this;
+				var opts = me.options;
+				var labelOpts = opts.labels;
+				var globalDefault = defaults.global;
+				var lineDefault = globalDefault.elements.line;
+				var legendWidth = me.width;
+				var lineWidths = me.lineWidths;
+
+				if (opts.display) {
+					var ctx = me.ctx;
+					var valueOrDefault = helpers.valueOrDefault;
+					var fontColor = valueOrDefault(labelOpts.fontColor, globalDefault.defaultFontColor);
+					var fontSize = valueOrDefault(labelOpts.fontSize, globalDefault.defaultFontSize);
+					var fontStyle = valueOrDefault(labelOpts.fontStyle, globalDefault.defaultFontStyle);
+					var fontFamily = valueOrDefault(labelOpts.fontFamily, globalDefault.defaultFontFamily);
+					var labelFont = helpers.fontString(fontSize, fontStyle, fontFamily);
+					var cursor;
+
+					// Canvas setup
+					ctx.textAlign = 'left';
+					ctx.textBaseline = 'middle';
+					ctx.lineWidth = 0.5;
+					ctx.strokeStyle = fontColor; // for strikethrough effect
+					ctx.fillStyle = fontColor; // render in correct colour
+					ctx.font = labelFont;
+
+					var boxWidth = getBoxWidth(labelOpts, fontSize);
+					var hitboxes = me.legendHitBoxes;
+
+					// current position
+					var drawLegendBox = function(x, y, legendItem) {
+						if (isNaN(boxWidth) || boxWidth <= 0) {
+							return;
+						}
+
+						// Set the ctx for the box
+						ctx.save();
+
+						ctx.fillStyle = valueOrDefault(legendItem.fillStyle, globalDefault.defaultColor);
+						ctx.lineCap = valueOrDefault(legendItem.lineCap, lineDefault.borderCapStyle);
+						ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, lineDefault.borderDashOffset);
+						ctx.lineJoin = valueOrDefault(legendItem.lineJoin, lineDefault.borderJoinStyle);
+						ctx.lineWidth = valueOrDefault(legendItem.lineWidth, lineDefault.borderWidth);
+						ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, globalDefault.defaultColor);
+						var isLineWidthZero = (valueOrDefault(legendItem.lineWidth, lineDefault.borderWidth) === 0);
+
+						if (ctx.setLineDash) {
+							// IE 9 and 10 do not support line dash
+							ctx.setLineDash(valueOrDefault(legendItem.lineDash, lineDefault.borderDash));
+						}
+
+						if (opts.labels && opts.labels.usePointStyle) {
+							// Recalculate x and y for drawPoint() because its expecting
+							// x and y to be center of figure (instead of top left)
+							var radius = fontSize * Math.SQRT2 / 2;
+							var offSet = radius / Math.SQRT2;
+							var centerX = x + offSet;
+							var centerY = y + offSet;
+
+							// Draw pointStyle as legend symbol
+							helpers.canvas.drawPoint(ctx, legendItem.pointStyle, radius, centerX, centerY);
+						} else {
+							// Draw box as legend symbol
+							if (!isLineWidthZero) {
+								ctx.strokeRect(x, y, boxWidth, fontSize);
+							}
+							ctx.fillRect(x, y, boxWidth, fontSize);
+						}
+
+						ctx.restore();
+					};
+					var fillText = function(x, y, legendItem, textWidth) {
+						var halfFontSize = fontSize / 2;
+						var xLeft = boxWidth + halfFontSize + x;
+						var yMiddle = y + halfFontSize;
+
+						ctx.fillText(legendItem.text, xLeft, yMiddle);
+
+						if (legendItem.hidden) {
+							// Strikethrough the text if hidden
+							ctx.beginPath();
+							ctx.lineWidth = 2;
+							ctx.moveTo(xLeft, yMiddle);
+							ctx.lineTo(xLeft + textWidth, yMiddle);
+							ctx.stroke();
+						}
+					};
+
+					// Horizontal
+					var isHorizontal = me.isHorizontal();
+					if (isHorizontal) {
+						cursor = {
+							x: me.left + ((legendWidth - lineWidths[0]) / 2),
+							y: me.top + labelOpts.padding,
+							line: 0
+						};
+					} else {
+						cursor = {
+							x: me.left + labelOpts.padding,
+							y: me.top + labelOpts.padding,
+							line: 0
+						};
+					}
+
+					var itemHeight = fontSize + labelOpts.padding;
+					helpers.each(me.legendItems, function(legendItem, i) {
+						var textWidth = ctx.measureText(legendItem.text).width;
+						var width = boxWidth + (fontSize / 2) + textWidth;
+						var x = cursor.x;
+						var y = cursor.y;
+
+						if (isHorizontal) {
+							if (x + width >= legendWidth) {
+								y = cursor.y += itemHeight;
+								cursor.line++;
+								x = cursor.x = me.left + ((legendWidth - lineWidths[cursor.line]) / 2);
+							}
+						} else if (y + itemHeight > me.bottom) {
+							x = cursor.x = x + me.columnWidths[cursor.line] + labelOpts.padding;
+							y = cursor.y = me.top + labelOpts.padding;
+							cursor.line++;
+						}
+
+						drawLegendBox(x, y, legendItem);
+
+						hitboxes[i].left = x;
+						hitboxes[i].top = y;
+
+						// Fill the actual label
+						fillText(x, y, legendItem, textWidth);
+
+						if (isHorizontal) {
+							cursor.x += width + (labelOpts.padding);
+						} else {
+							cursor.y += itemHeight;
+						}
+
+					});
+				}
+			},
+
+			/**
+			 * Handle an event
+			 * @private
+			 * @param {IEvent} event - The event to handle
+			 * @return {Boolean} true if a change occured
+			 */
+			handleEvent: function(e) {
+				var me = this;
+				var opts = me.options;
+				var type = e.type === 'mouseup' ? 'click' : e.type;
+				var changed = false;
+
+				if (type === 'mousemove') {
+					if (!opts.onHover) {
+						return;
+					}
+				} else if (type === 'click') {
+					if (!opts.onClick) {
+						return;
+					}
+				} else {
+					return;
+				}
+
+				// Chart event already has relative position in it
+				var x = e.x;
+				var y = e.y;
+
+				if (x >= me.left && x <= me.right && y >= me.top && y <= me.bottom) {
+					// See if we are touching one of the dataset boxes
+					var lh = me.legendHitBoxes;
+					for (var i = 0; i < lh.length; ++i) {
+						var hitBox = lh[i];
+
+						if (x >= hitBox.left && x <= hitBox.left + hitBox.width && y >= hitBox.top && y <= hitBox.top + hitBox.height) {
+							// Touching an element
+							if (type === 'click') {
+								// use e.native for backwards compatibility
+								opts.onClick.call(me, e.native, me.legendItems[i]);
+								changed = true;
+								break;
+							} else if (type === 'mousemove') {
+								// use e.native for backwards compatibility
+								opts.onHover.call(me, e.native, me.legendItems[i]);
+								changed = true;
+								break;
+							}
+						}
+					}
+				}
+
+				return changed;
+			}
+		});
+
+		function createNewLegendAndAttach(chart, legendOpts) {
+			var legend = new Chart.Legend({
+				ctx: chart.ctx,
+				options: legendOpts,
+				chart: chart
+			});
+
+			layout.configure(chart, legend, legendOpts);
+			layout.addBox(chart, legend);
+			chart.legend = legend;
+		}
+
+		return {
+			id: 'legend',
+
+			beforeInit: function(chart) {
+				var legendOpts = chart.options.legend;
+
+				if (legendOpts) {
+					createNewLegendAndAttach(chart, legendOpts);
+				}
+			},
+
+			beforeUpdate: function(chart) {
+				var legendOpts = chart.options.legend;
+				var legend = chart.legend;
+
+				if (legendOpts) {
+					helpers.mergeIf(legendOpts, defaults.global.legend);
+
+					if (legend) {
+						layout.configure(chart, legend, legendOpts);
+						legend.options = legendOpts;
+					} else {
+						createNewLegendAndAttach(chart, legendOpts);
+					}
+				} else if (legend) {
+					layout.removeBox(chart, legend);
+					delete chart.legend;
+				}
+			},
+
+			afterEvent: function(chart, e) {
+				var legend = chart.legend;
+				if (legend) {
+					legend.handleEvent(e);
+				}
+			}
+		};
+	};
+
+
+/***/ },
+/* 177 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var defaults = __webpack_require__(6);
+	var Element = __webpack_require__(18);
+	var helpers = __webpack_require__(7);
+
+	defaults._set('global', {
+		title: {
+			display: false,
+			fontStyle: 'bold',
+			fullWidth: true,
+			lineHeight: 1.2,
+			padding: 10,
+			position: 'top',
+			text: '',
+			weight: 2000         // by default greater than legend (1000) to be above
+		}
+	});
+
+	module.exports = function(Chart) {
+
+		var layout = Chart.layoutService;
+		var noop = helpers.noop;
+
+		Chart.Title = Element.extend({
+			initialize: function(config) {
+				var me = this;
+				helpers.extend(me, config);
+
+				// Contains hit boxes for each dataset (in dataset order)
+				me.legendHitBoxes = [];
+			},
+
+			// These methods are ordered by lifecycle. Utilities then follow.
+
+			beforeUpdate: noop,
+			update: function(maxWidth, maxHeight, margins) {
+				var me = this;
+
+				// Update Lifecycle - Probably don't want to ever extend or overwrite this function ;)
+				me.beforeUpdate();
+
+				// Absorb the master measurements
+				me.maxWidth = maxWidth;
+				me.maxHeight = maxHeight;
+				me.margins = margins;
+
+				// Dimensions
+				me.beforeSetDimensions();
+				me.setDimensions();
+				me.afterSetDimensions();
+				// Labels
+				me.beforeBuildLabels();
+				me.buildLabels();
+				me.afterBuildLabels();
+
+				// Fit
+				me.beforeFit();
+				me.fit();
+				me.afterFit();
+				//
+				me.afterUpdate();
+
+				return me.minSize;
+
+			},
+			afterUpdate: noop,
+
+			//
+
+			beforeSetDimensions: noop,
+			setDimensions: function() {
+				var me = this;
+				// Set the unconstrained dimension before label rotation
+				if (me.isHorizontal()) {
+					// Reset position before calculating rotation
+					me.width = me.maxWidth;
+					me.left = 0;
+					me.right = me.width;
+				} else {
+					me.height = me.maxHeight;
+
+					// Reset position before calculating rotation
+					me.top = 0;
+					me.bottom = me.height;
+				}
+
+				// Reset padding
+				me.paddingLeft = 0;
+				me.paddingTop = 0;
+				me.paddingRight = 0;
+				me.paddingBottom = 0;
+
+				// Reset minSize
+				me.minSize = {
+					width: 0,
+					height: 0
+				};
+			},
+			afterSetDimensions: noop,
+
+			//
+
+			beforeBuildLabels: noop,
+			buildLabels: noop,
+			afterBuildLabels: noop,
+
+			//
+
+			beforeFit: noop,
+			fit: function() {
+				var me = this;
+				var valueOrDefault = helpers.valueOrDefault;
+				var opts = me.options;
+				var display = opts.display;
+				var fontSize = valueOrDefault(opts.fontSize, defaults.global.defaultFontSize);
+				var minSize = me.minSize;
+				var lineCount = helpers.isArray(opts.text) ? opts.text.length : 1;
+				var lineHeight = helpers.options.toLineHeight(opts.lineHeight, fontSize);
+				var textSize = display ? (lineCount * lineHeight) + (opts.padding * 2) : 0;
+
+				if (me.isHorizontal()) {
+					minSize.width = me.maxWidth; // fill all the width
+					minSize.height = textSize;
+				} else {
+					minSize.width = textSize;
+					minSize.height = me.maxHeight; // fill all the height
+				}
+
+				me.width = minSize.width;
+				me.height = minSize.height;
+
+			},
+			afterFit: noop,
+
+			// Shared Methods
+			isHorizontal: function() {
+				var pos = this.options.position;
+				return pos === 'top' || pos === 'bottom';
+			},
+
+			// Actually draw the title block on the canvas
+			draw: function() {
+				var me = this;
+				var ctx = me.ctx;
+				var valueOrDefault = helpers.valueOrDefault;
+				var opts = me.options;
+				var globalDefaults = defaults.global;
+
+				if (opts.display) {
+					var fontSize = valueOrDefault(opts.fontSize, globalDefaults.defaultFontSize);
+					var fontStyle = valueOrDefault(opts.fontStyle, globalDefaults.defaultFontStyle);
+					var fontFamily = valueOrDefault(opts.fontFamily, globalDefaults.defaultFontFamily);
+					var titleFont = helpers.fontString(fontSize, fontStyle, fontFamily);
+					var lineHeight = helpers.options.toLineHeight(opts.lineHeight, fontSize);
+					var offset = lineHeight / 2 + opts.padding;
+					var rotation = 0;
+					var top = me.top;
+					var left = me.left;
+					var bottom = me.bottom;
+					var right = me.right;
+					var maxWidth, titleX, titleY;
+
+					ctx.fillStyle = valueOrDefault(opts.fontColor, globalDefaults.defaultFontColor); // render in correct colour
+					ctx.font = titleFont;
+
+					// Horizontal
+					if (me.isHorizontal()) {
+						titleX = left + ((right - left) / 2); // midpoint of the width
+						titleY = top + offset;
+						maxWidth = right - left;
+					} else {
+						titleX = opts.position === 'left' ? left + offset : right - offset;
+						titleY = top + ((bottom - top) / 2);
+						maxWidth = bottom - top;
+						rotation = Math.PI * (opts.position === 'left' ? -0.5 : 0.5);
+					}
+
+					ctx.save();
+					ctx.translate(titleX, titleY);
+					ctx.rotate(rotation);
+					ctx.textAlign = 'center';
+					ctx.textBaseline = 'middle';
+
+					var text = opts.text;
+					if (helpers.isArray(text)) {
+						var y = 0;
+						for (var i = 0; i < text.length; ++i) {
+							ctx.fillText(text[i], 0, y, maxWidth);
+							y += lineHeight;
+						}
+					} else {
+						ctx.fillText(text, 0, 0, maxWidth);
+					}
+
+					ctx.restore();
+				}
+			}
+		});
+
+		function createNewTitleBlockAndAttach(chart, titleOpts) {
+			var title = new Chart.Title({
+				ctx: chart.ctx,
+				options: titleOpts,
+				chart: chart
+			});
+
+			layout.configure(chart, title, titleOpts);
+			layout.addBox(chart, title);
+			chart.titleBlock = title;
+		}
+
+		return {
+			id: 'title',
+
+			beforeInit: function(chart) {
+				var titleOpts = chart.options.title;
+
+				if (titleOpts) {
+					createNewTitleBlockAndAttach(chart, titleOpts);
+				}
+			},
+
+			beforeUpdate: function(chart) {
+				var titleOpts = chart.options.title;
+				var titleBlock = chart.titleBlock;
+
+				if (titleOpts) {
+					helpers.mergeIf(titleOpts, defaults.global.title);
+
+					if (titleBlock) {
+						layout.configure(chart, titleBlock, titleOpts);
+						titleBlock.options = titleOpts;
+					} else {
+						createNewTitleBlockAndAttach(chart, titleOpts);
+					}
+				} else if (titleBlock) {
+					Chart.layoutService.removeBox(chart, titleBlock);
+					delete chart.titleBlock;
+				}
+			}
+		};
+	};
+
+
+/***/ },
+/* 178 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.mergeOptions = mergeOptions;
+
+	var _lodash = __webpack_require__(179);
+
+	var _lodash2 = _interopRequireDefault(_lodash);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function mergeOptions(obj, src) {
+	  return (0, _lodash2.default)(obj, src);
+	}
+
+/***/ },
+/* 179 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(global, module) {/**
+	 * lodash (Custom Build) <https://lodash.com/>
+	 * Build: `lodash modularize exports="npm" -o ./`
+	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	 * Released under MIT license <https://lodash.com/license>
+	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	 */
+
+	/** Used as the size to enable large array optimizations. */
+	var LARGE_ARRAY_SIZE = 200;
+
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER = 9007199254740991;
+
+	/** `Object#toString` result references. */
+	var argsTag = '[object Arguments]',
+	    arrayTag = '[object Array]',
+	    boolTag = '[object Boolean]',
+	    dateTag = '[object Date]',
+	    errorTag = '[object Error]',
+	    funcTag = '[object Function]',
+	    genTag = '[object GeneratorFunction]',
+	    mapTag = '[object Map]',
+	    numberTag = '[object Number]',
+	    objectTag = '[object Object]',
+	    promiseTag = '[object Promise]',
+	    regexpTag = '[object RegExp]',
+	    setTag = '[object Set]',
+	    stringTag = '[object String]',
+	    symbolTag = '[object Symbol]',
+	    weakMapTag = '[object WeakMap]';
+
+	var arrayBufferTag = '[object ArrayBuffer]',
+	    dataViewTag = '[object DataView]',
+	    float32Tag = '[object Float32Array]',
+	    float64Tag = '[object Float64Array]',
+	    int8Tag = '[object Int8Array]',
+	    int16Tag = '[object Int16Array]',
+	    int32Tag = '[object Int32Array]',
+	    uint8Tag = '[object Uint8Array]',
+	    uint8ClampedTag = '[object Uint8ClampedArray]',
+	    uint16Tag = '[object Uint16Array]',
+	    uint32Tag = '[object Uint32Array]';
+
+	/**
+	 * Used to match `RegExp`
+	 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	 */
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+	/** Used to match `RegExp` flags from their coerced string values. */
+	var reFlags = /\w*$/;
+
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+	/** Used to detect unsigned integer values. */
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+	/** Used to identify `toStringTag` values of typed arrays. */
+	var typedArrayTags = {};
+	typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+	typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+	typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+	typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+	typedArrayTags[uint32Tag] = true;
+	typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+	typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+	typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+	typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+	typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+	typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+	typedArrayTags[setTag] = typedArrayTags[stringTag] =
+	typedArrayTags[weakMapTag] = false;
+
+	/** Used to identify `toStringTag` values supported by `_.clone`. */
+	var cloneableTags = {};
+	cloneableTags[argsTag] = cloneableTags[arrayTag] =
+	cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+	cloneableTags[boolTag] = cloneableTags[dateTag] =
+	cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+	cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+	cloneableTags[int32Tag] = cloneableTags[mapTag] =
+	cloneableTags[numberTag] = cloneableTags[objectTag] =
+	cloneableTags[regexpTag] = cloneableTags[setTag] =
+	cloneableTags[stringTag] = cloneableTags[symbolTag] =
+	cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+	cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+	cloneableTags[errorTag] = cloneableTags[funcTag] =
+	cloneableTags[weakMapTag] = false;
+
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function('return this')();
+
+	/** Detect free variable `exports`. */
+	var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+	/** Detect free variable `module`. */
+	var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+	/** Detect the popular CommonJS extension `module.exports`. */
+	var moduleExports = freeModule && freeModule.exports === freeExports;
+
+	/** Detect free variable `process` from Node.js. */
+	var freeProcess = moduleExports && freeGlobal.process;
+
+	/** Used to access faster Node.js helpers. */
+	var nodeUtil = (function() {
+	  try {
+	    return freeProcess && freeProcess.binding('util');
+	  } catch (e) {}
+	}());
+
+	/* Node.js helper references. */
+	var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+	/**
+	 * Adds the key-value `pair` to `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to modify.
+	 * @param {Array} pair The key-value pair to add.
+	 * @returns {Object} Returns `map`.
+	 */
+	function addMapEntry(map, pair) {
+	  // Don't return `map.set` because it's not chainable in IE 11.
+	  map.set(pair[0], pair[1]);
+	  return map;
+	}
+
+	/**
+	 * Adds `value` to `set`.
+	 *
+	 * @private
+	 * @param {Object} set The set to modify.
+	 * @param {*} value The value to add.
+	 * @returns {Object} Returns `set`.
+	 */
+	function addSetEntry(set, value) {
+	  // Don't return `set.add` because it's not chainable in IE 11.
+	  set.add(value);
+	  return set;
+	}
+
+	/**
+	 * A faster alternative to `Function#apply`, this function invokes `func`
+	 * with the `this` binding of `thisArg` and the arguments of `args`.
+	 *
+	 * @private
+	 * @param {Function} func The function to invoke.
+	 * @param {*} thisArg The `this` binding of `func`.
+	 * @param {Array} args The arguments to invoke `func` with.
+	 * @returns {*} Returns the result of `func`.
+	 */
+	function apply(func, thisArg, args) {
+	  switch (args.length) {
+	    case 0: return func.call(thisArg);
+	    case 1: return func.call(thisArg, args[0]);
+	    case 2: return func.call(thisArg, args[0], args[1]);
+	    case 3: return func.call(thisArg, args[0], args[1], args[2]);
+	  }
+	  return func.apply(thisArg, args);
+	}
+
+	/**
+	 * A specialized version of `_.forEach` for arrays without support for
+	 * iteratee shorthands.
+	 *
+	 * @private
+	 * @param {Array} [array] The array to iterate over.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @returns {Array} Returns `array`.
+	 */
+	function arrayEach(array, iteratee) {
+	  var index = -1,
+	      length = array ? array.length : 0;
+
+	  while (++index < length) {
+	    if (iteratee(array[index], index, array) === false) {
+	      break;
+	    }
+	  }
+	  return array;
+	}
+
+	/**
+	 * Appends the elements of `values` to `array`.
+	 *
+	 * @private
+	 * @param {Array} array The array to modify.
+	 * @param {Array} values The values to append.
+	 * @returns {Array} Returns `array`.
+	 */
+	function arrayPush(array, values) {
+	  var index = -1,
+	      length = values.length,
+	      offset = array.length;
+
+	  while (++index < length) {
+	    array[offset + index] = values[index];
+	  }
+	  return array;
+	}
+
+	/**
+	 * A specialized version of `_.reduce` for arrays without support for
+	 * iteratee shorthands.
+	 *
+	 * @private
+	 * @param {Array} [array] The array to iterate over.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @param {*} [accumulator] The initial value.
+	 * @param {boolean} [initAccum] Specify using the first element of `array` as
+	 *  the initial value.
+	 * @returns {*} Returns the accumulated value.
+	 */
+	function arrayReduce(array, iteratee, accumulator, initAccum) {
+	  var index = -1,
+	      length = array ? array.length : 0;
+
+	  if (initAccum && length) {
+	    accumulator = array[++index];
+	  }
+	  while (++index < length) {
+	    accumulator = iteratee(accumulator, array[index], index, array);
+	  }
+	  return accumulator;
+	}
+
+	/**
+	 * The base implementation of `_.times` without support for iteratee shorthands
+	 * or max array length checks.
+	 *
+	 * @private
+	 * @param {number} n The number of times to invoke `iteratee`.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @returns {Array} Returns the array of results.
+	 */
+	function baseTimes(n, iteratee) {
+	  var index = -1,
+	      result = Array(n);
+
+	  while (++index < n) {
+	    result[index] = iteratee(index);
+	  }
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.unary` without support for storing metadata.
+	 *
+	 * @private
+	 * @param {Function} func The function to cap arguments for.
+	 * @returns {Function} Returns the new capped function.
+	 */
+	function baseUnary(func) {
+	  return function(value) {
+	    return func(value);
+	  };
+	}
+
+	/**
+	 * Gets the value at `key` of `object`.
+	 *
+	 * @private
+	 * @param {Object} [object] The object to query.
+	 * @param {string} key The key of the property to get.
+	 * @returns {*} Returns the property value.
+	 */
+	function getValue(object, key) {
+	  return object == null ? undefined : object[key];
+	}
+
+	/**
+	 * Checks if `value` is a host object in IE < 9.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+	 */
+	function isHostObject(value) {
+	  // Many host objects are `Object` objects that can coerce to strings
+	  // despite having improperly defined `toString` methods.
+	  var result = false;
+	  if (value != null && typeof value.toString != 'function') {
+	    try {
+	      result = !!(value + '');
+	    } catch (e) {}
+	  }
+	  return result;
+	}
+
+	/**
+	 * Converts `map` to its key-value pairs.
+	 *
+	 * @private
+	 * @param {Object} map The map to convert.
+	 * @returns {Array} Returns the key-value pairs.
+	 */
+	function mapToArray(map) {
+	  var index = -1,
+	      result = Array(map.size);
+
+	  map.forEach(function(value, key) {
+	    result[++index] = [key, value];
+	  });
+	  return result;
+	}
+
+	/**
+	 * Creates a unary function that invokes `func` with its argument transformed.
+	 *
+	 * @private
+	 * @param {Function} func The function to wrap.
+	 * @param {Function} transform The argument transform.
+	 * @returns {Function} Returns the new function.
+	 */
+	function overArg(func, transform) {
+	  return function(arg) {
+	    return func(transform(arg));
+	  };
+	}
+
+	/**
+	 * Converts `set` to an array of its values.
+	 *
+	 * @private
+	 * @param {Object} set The set to convert.
+	 * @returns {Array} Returns the values.
+	 */
+	function setToArray(set) {
+	  var index = -1,
+	      result = Array(set.size);
+
+	  set.forEach(function(value) {
+	    result[++index] = value;
+	  });
+	  return result;
+	}
+
+	/** Used for built-in method references. */
+	var arrayProto = Array.prototype,
+	    funcProto = Function.prototype,
+	    objectProto = Object.prototype;
+
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData = root['__core-js_shared__'];
+
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = (function() {
+	  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+	  return uid ? ('Symbol(src)_1.' + uid) : '';
+	}());
+
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/** Used to infer the `Object` constructor. */
+	var objectCtorString = funcToString.call(Object);
+
+	/**
+	 * Used to resolve the
+	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	 * of values.
+	 */
+	var objectToString = objectProto.toString;
+
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp('^' +
+	  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+	);
+
+	/** Built-in value references. */
+	var Buffer = moduleExports ? root.Buffer : undefined,
+	    Symbol = root.Symbol,
+	    Uint8Array = root.Uint8Array,
+	    getPrototype = overArg(Object.getPrototypeOf, Object),
+	    objectCreate = Object.create,
+	    propertyIsEnumerable = objectProto.propertyIsEnumerable,
+	    splice = arrayProto.splice;
+
+	/* Built-in method references for those with the same name as other `lodash` methods. */
+	var nativeGetSymbols = Object.getOwnPropertySymbols,
+	    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+	    nativeKeys = overArg(Object.keys, Object),
+	    nativeMax = Math.max;
+
+	/* Built-in method references that are verified to be native. */
+	var DataView = getNative(root, 'DataView'),
+	    Map = getNative(root, 'Map'),
+	    Promise = getNative(root, 'Promise'),
+	    Set = getNative(root, 'Set'),
+	    WeakMap = getNative(root, 'WeakMap'),
+	    nativeCreate = getNative(Object, 'create');
+
+	/** Used to detect maps, sets, and weakmaps. */
+	var dataViewCtorString = toSource(DataView),
+	    mapCtorString = toSource(Map),
+	    promiseCtorString = toSource(Promise),
+	    setCtorString = toSource(Set),
+	    weakMapCtorString = toSource(WeakMap);
+
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : undefined,
+	    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+	/**
+	 * Creates a hash object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function Hash(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the hash.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf Hash
+	 */
+	function hashClear() {
+	  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+	}
+
+	/**
+	 * Removes `key` and its value from the hash.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf Hash
+	 * @param {Object} hash The hash to modify.
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function hashDelete(key) {
+	  return this.has(key) && delete this.__data__[key];
+	}
+
+	/**
+	 * Gets the hash value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf Hash
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function hashGet(key) {
+	  var data = this.__data__;
+	  if (nativeCreate) {
+	    var result = data[key];
+	    return result === HASH_UNDEFINED ? undefined : result;
+	  }
+	  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+	}
+
+	/**
+	 * Checks if a hash value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf Hash
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function hashHas(key) {
+	  var data = this.__data__;
+	  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+	}
+
+	/**
+	 * Sets the hash `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf Hash
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the hash instance.
+	 */
+	function hashSet(key, value) {
+	  var data = this.__data__;
+	  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+	  return this;
+	}
+
+	// Add methods to `Hash`.
+	Hash.prototype.clear = hashClear;
+	Hash.prototype['delete'] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+
+	/**
+	 * Creates an list cache object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function ListCache(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the list cache.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf ListCache
+	 */
+	function listCacheClear() {
+	  this.__data__ = [];
+	}
+
+	/**
+	 * Removes `key` and its value from the list cache.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function listCacheDelete(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    return false;
+	  }
+	  var lastIndex = data.length - 1;
+	  if (index == lastIndex) {
+	    data.pop();
+	  } else {
+	    splice.call(data, index, 1);
+	  }
+	  return true;
+	}
+
+	/**
+	 * Gets the list cache value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function listCacheGet(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  return index < 0 ? undefined : data[index][1];
+	}
+
+	/**
+	 * Checks if a list cache value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf ListCache
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function listCacheHas(key) {
+	  return assocIndexOf(this.__data__, key) > -1;
+	}
+
+	/**
+	 * Sets the list cache `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the list cache instance.
+	 */
+	function listCacheSet(key, value) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    data.push([key, value]);
+	  } else {
+	    data[index][1] = value;
+	  }
+	  return this;
+	}
+
+	// Add methods to `ListCache`.
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype['delete'] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+
+	/**
+	 * Creates a map cache object to store key-value pairs.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function MapCache(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the map.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf MapCache
+	 */
+	function mapCacheClear() {
+	  this.__data__ = {
+	    'hash': new Hash,
+	    'map': new (Map || ListCache),
+	    'string': new Hash
+	  };
+	}
+
+	/**
+	 * Removes `key` and its value from the map.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function mapCacheDelete(key) {
+	  return getMapData(this, key)['delete'](key);
+	}
+
+	/**
+	 * Gets the map value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function mapCacheGet(key) {
+	  return getMapData(this, key).get(key);
+	}
+
+	/**
+	 * Checks if a map value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf MapCache
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function mapCacheHas(key) {
+	  return getMapData(this, key).has(key);
+	}
+
+	/**
+	 * Sets the map `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the map cache instance.
+	 */
+	function mapCacheSet(key, value) {
+	  getMapData(this, key).set(key, value);
+	  return this;
+	}
+
+	// Add methods to `MapCache`.
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype['delete'] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+
+	/**
+	 * Creates a stack cache object to store key-value pairs.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function Stack(entries) {
+	  this.__data__ = new ListCache(entries);
+	}
+
+	/**
+	 * Removes all key-value entries from the stack.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf Stack
+	 */
+	function stackClear() {
+	  this.__data__ = new ListCache;
+	}
+
+	/**
+	 * Removes `key` and its value from the stack.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function stackDelete(key) {
+	  return this.__data__['delete'](key);
+	}
+
+	/**
+	 * Gets the stack value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function stackGet(key) {
+	  return this.__data__.get(key);
+	}
+
+	/**
+	 * Checks if a stack value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf Stack
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function stackHas(key) {
+	  return this.__data__.has(key);
+	}
+
+	/**
+	 * Sets the stack `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the stack cache instance.
+	 */
+	function stackSet(key, value) {
+	  var cache = this.__data__;
+	  if (cache instanceof ListCache) {
+	    var pairs = cache.__data__;
+	    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+	      pairs.push([key, value]);
+	      return this;
+	    }
+	    cache = this.__data__ = new MapCache(pairs);
+	  }
+	  cache.set(key, value);
+	  return this;
+	}
+
+	// Add methods to `Stack`.
+	Stack.prototype.clear = stackClear;
+	Stack.prototype['delete'] = stackDelete;
+	Stack.prototype.get = stackGet;
+	Stack.prototype.has = stackHas;
+	Stack.prototype.set = stackSet;
+
+	/**
+	 * Creates an array of the enumerable property names of the array-like `value`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @param {boolean} inherited Specify returning inherited property names.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function arrayLikeKeys(value, inherited) {
+	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+	  // Safari 9 makes `arguments.length` enumerable in strict mode.
+	  var result = (isArray(value) || isArguments(value))
+	    ? baseTimes(value.length, String)
+	    : [];
+
+	  var length = result.length,
+	      skipIndexes = !!length;
+
+	  for (var key in value) {
+	    if ((inherited || hasOwnProperty.call(value, key)) &&
+	        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * This function is like `assignValue` except that it doesn't assign
+	 * `undefined` values.
+	 *
+	 * @private
+	 * @param {Object} object The object to modify.
+	 * @param {string} key The key of the property to assign.
+	 * @param {*} value The value to assign.
+	 */
+	function assignMergeValue(object, key, value) {
+	  if ((value !== undefined && !eq(object[key], value)) ||
+	      (typeof key == 'number' && value === undefined && !(key in object))) {
+	    object[key] = value;
+	  }
+	}
+
+	/**
+	 * Assigns `value` to `key` of `object` if the existing value is not equivalent
+	 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	 * for equality comparisons.
+	 *
+	 * @private
+	 * @param {Object} object The object to modify.
+	 * @param {string} key The key of the property to assign.
+	 * @param {*} value The value to assign.
+	 */
+	function assignValue(object, key, value) {
+	  var objValue = object[key];
+	  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+	      (value === undefined && !(key in object))) {
+	    object[key] = value;
+	  }
+	}
+
+	/**
+	 * Gets the index at which the `key` is found in `array` of key-value pairs.
+	 *
+	 * @private
+	 * @param {Array} array The array to inspect.
+	 * @param {*} key The key to search for.
+	 * @returns {number} Returns the index of the matched value, else `-1`.
+	 */
+	function assocIndexOf(array, key) {
+	  var length = array.length;
+	  while (length--) {
+	    if (eq(array[length][0], key)) {
+	      return length;
+	    }
+	  }
+	  return -1;
+	}
+
+	/**
+	 * The base implementation of `_.assign` without support for multiple sources
+	 * or `customizer` functions.
+	 *
+	 * @private
+	 * @param {Object} object The destination object.
+	 * @param {Object} source The source object.
+	 * @returns {Object} Returns `object`.
+	 */
+	function baseAssign(object, source) {
+	  return object && copyObject(source, keys(source), object);
+	}
+
+	/**
+	 * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+	 * traversed objects.
+	 *
+	 * @private
+	 * @param {*} value The value to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @param {boolean} [isFull] Specify a clone including symbols.
+	 * @param {Function} [customizer] The function to customize cloning.
+	 * @param {string} [key] The key of `value`.
+	 * @param {Object} [object] The parent object of `value`.
+	 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+	 * @returns {*} Returns the cloned value.
+	 */
+	function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
+	  var result;
+	  if (customizer) {
+	    result = object ? customizer(value, key, object, stack) : customizer(value);
+	  }
+	  if (result !== undefined) {
+	    return result;
+	  }
+	  if (!isObject(value)) {
+	    return value;
+	  }
+	  var isArr = isArray(value);
+	  if (isArr) {
+	    result = initCloneArray(value);
+	    if (!isDeep) {
+	      return copyArray(value, result);
+	    }
+	  } else {
+	    var tag = getTag(value),
+	        isFunc = tag == funcTag || tag == genTag;
+
+	    if (isBuffer(value)) {
+	      return cloneBuffer(value, isDeep);
+	    }
+	    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+	      if (isHostObject(value)) {
+	        return object ? value : {};
+	      }
+	      result = initCloneObject(isFunc ? {} : value);
+	      if (!isDeep) {
+	        return copySymbols(value, baseAssign(result, value));
+	      }
+	    } else {
+	      if (!cloneableTags[tag]) {
+	        return object ? value : {};
+	      }
+	      result = initCloneByTag(value, tag, baseClone, isDeep);
+	    }
+	  }
+	  // Check for circular references and return its corresponding clone.
+	  stack || (stack = new Stack);
+	  var stacked = stack.get(value);
+	  if (stacked) {
+	    return stacked;
+	  }
+	  stack.set(value, result);
+
+	  if (!isArr) {
+	    var props = isFull ? getAllKeys(value) : keys(value);
+	  }
+	  arrayEach(props || value, function(subValue, key) {
+	    if (props) {
+	      key = subValue;
+	      subValue = value[key];
+	    }
+	    // Recursively populate clone (susceptible to call stack limits).
+	    assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+	  });
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.create` without support for assigning
+	 * properties to the created object.
+	 *
+	 * @private
+	 * @param {Object} prototype The object to inherit from.
+	 * @returns {Object} Returns the new object.
+	 */
+	function baseCreate(proto) {
+	  return isObject(proto) ? objectCreate(proto) : {};
+	}
+
+	/**
+	 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+	 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+	 * symbols of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {Function} keysFunc The function to get the keys of `object`.
+	 * @param {Function} symbolsFunc The function to get the symbols of `object`.
+	 * @returns {Array} Returns the array of property names and symbols.
+	 */
+	function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+	  var result = keysFunc(object);
+	  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+	}
+
+	/**
+	 * The base implementation of `getTag`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	function baseGetTag(value) {
+	  return objectToString.call(value);
+	}
+
+	/**
+	 * The base implementation of `_.isNative` without bad shim checks.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a native function,
+	 *  else `false`.
+	 */
+	function baseIsNative(value) {
+	  if (!isObject(value) || isMasked(value)) {
+	    return false;
+	  }
+	  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+	  return pattern.test(toSource(value));
+	}
+
+	/**
+	 * The base implementation of `_.isTypedArray` without Node.js optimizations.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	 */
+	function baseIsTypedArray(value) {
+	  return isObjectLike(value) &&
+	    isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+	}
+
+	/**
+	 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function baseKeys(object) {
+	  if (!isPrototype(object)) {
+	    return nativeKeys(object);
+	  }
+	  var result = [];
+	  for (var key in Object(object)) {
+	    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function baseKeysIn(object) {
+	  if (!isObject(object)) {
+	    return nativeKeysIn(object);
+	  }
+	  var isProto = isPrototype(object),
+	      result = [];
+
+	  for (var key in object) {
+	    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.merge` without support for multiple sources.
+	 *
+	 * @private
+	 * @param {Object} object The destination object.
+	 * @param {Object} source The source object.
+	 * @param {number} srcIndex The index of `source`.
+	 * @param {Function} [customizer] The function to customize merged values.
+	 * @param {Object} [stack] Tracks traversed source values and their merged
+	 *  counterparts.
+	 */
+	function baseMerge(object, source, srcIndex, customizer, stack) {
+	  if (object === source) {
+	    return;
+	  }
+	  if (!(isArray(source) || isTypedArray(source))) {
+	    var props = baseKeysIn(source);
+	  }
+	  arrayEach(props || source, function(srcValue, key) {
+	    if (props) {
+	      key = srcValue;
+	      srcValue = source[key];
+	    }
+	    if (isObject(srcValue)) {
+	      stack || (stack = new Stack);
+	      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+	    }
+	    else {
+	      var newValue = customizer
+	        ? customizer(object[key], srcValue, (key + ''), object, source, stack)
+	        : undefined;
+
+	      if (newValue === undefined) {
+	        newValue = srcValue;
+	      }
+	      assignMergeValue(object, key, newValue);
+	    }
+	  });
+	}
+
+	/**
+	 * A specialized version of `baseMerge` for arrays and objects which performs
+	 * deep merges and tracks traversed objects enabling objects with circular
+	 * references to be merged.
+	 *
+	 * @private
+	 * @param {Object} object The destination object.
+	 * @param {Object} source The source object.
+	 * @param {string} key The key of the value to merge.
+	 * @param {number} srcIndex The index of `source`.
+	 * @param {Function} mergeFunc The function to merge values.
+	 * @param {Function} [customizer] The function to customize assigned values.
+	 * @param {Object} [stack] Tracks traversed source values and their merged
+	 *  counterparts.
+	 */
+	function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+	  var objValue = object[key],
+	      srcValue = source[key],
+	      stacked = stack.get(srcValue);
+
+	  if (stacked) {
+	    assignMergeValue(object, key, stacked);
+	    return;
+	  }
+	  var newValue = customizer
+	    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+	    : undefined;
+
+	  var isCommon = newValue === undefined;
+
+	  if (isCommon) {
+	    newValue = srcValue;
+	    if (isArray(srcValue) || isTypedArray(srcValue)) {
+	      if (isArray(objValue)) {
+	        newValue = objValue;
+	      }
+	      else if (isArrayLikeObject(objValue)) {
+	        newValue = copyArray(objValue);
+	      }
+	      else {
+	        isCommon = false;
+	        newValue = baseClone(srcValue, true);
+	      }
+	    }
+	    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+	      if (isArguments(objValue)) {
+	        newValue = toPlainObject(objValue);
+	      }
+	      else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
+	        isCommon = false;
+	        newValue = baseClone(srcValue, true);
+	      }
+	      else {
+	        newValue = objValue;
+	      }
+	    }
+	    else {
+	      isCommon = false;
+	    }
+	  }
+	  if (isCommon) {
+	    // Recursively merge objects and arrays (susceptible to call stack limits).
+	    stack.set(srcValue, newValue);
+	    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+	    stack['delete'](srcValue);
+	  }
+	  assignMergeValue(object, key, newValue);
+	}
+
+	/**
+	 * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+	 *
+	 * @private
+	 * @param {Function} func The function to apply a rest parameter to.
+	 * @param {number} [start=func.length-1] The start position of the rest parameter.
+	 * @returns {Function} Returns the new function.
+	 */
+	function baseRest(func, start) {
+	  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+	  return function() {
+	    var args = arguments,
+	        index = -1,
+	        length = nativeMax(args.length - start, 0),
+	        array = Array(length);
+
+	    while (++index < length) {
+	      array[index] = args[start + index];
+	    }
+	    index = -1;
+	    var otherArgs = Array(start + 1);
+	    while (++index < start) {
+	      otherArgs[index] = args[index];
+	    }
+	    otherArgs[start] = array;
+	    return apply(func, this, otherArgs);
+	  };
+	}
+
+	/**
+	 * Creates a clone of  `buffer`.
+	 *
+	 * @private
+	 * @param {Buffer} buffer The buffer to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Buffer} Returns the cloned buffer.
+	 */
+	function cloneBuffer(buffer, isDeep) {
+	  if (isDeep) {
+	    return buffer.slice();
+	  }
+	  var result = new buffer.constructor(buffer.length);
+	  buffer.copy(result);
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `arrayBuffer`.
+	 *
+	 * @private
+	 * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+	 * @returns {ArrayBuffer} Returns the cloned array buffer.
+	 */
+	function cloneArrayBuffer(arrayBuffer) {
+	  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+	  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `dataView`.
+	 *
+	 * @private
+	 * @param {Object} dataView The data view to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned data view.
+	 */
+	function cloneDataView(dataView, isDeep) {
+	  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+	  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+	}
+
+	/**
+	 * Creates a clone of `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned map.
+	 */
+	function cloneMap(map, isDeep, cloneFunc) {
+	  var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
+	  return arrayReduce(array, addMapEntry, new map.constructor);
+	}
+
+	/**
+	 * Creates a clone of `regexp`.
+	 *
+	 * @private
+	 * @param {Object} regexp The regexp to clone.
+	 * @returns {Object} Returns the cloned regexp.
+	 */
+	function cloneRegExp(regexp) {
+	  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+	  result.lastIndex = regexp.lastIndex;
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `set`.
+	 *
+	 * @private
+	 * @param {Object} set The set to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned set.
+	 */
+	function cloneSet(set, isDeep, cloneFunc) {
+	  var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
+	  return arrayReduce(array, addSetEntry, new set.constructor);
+	}
+
+	/**
+	 * Creates a clone of the `symbol` object.
+	 *
+	 * @private
+	 * @param {Object} symbol The symbol object to clone.
+	 * @returns {Object} Returns the cloned symbol object.
+	 */
+	function cloneSymbol(symbol) {
+	  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+	}
+
+	/**
+	 * Creates a clone of `typedArray`.
+	 *
+	 * @private
+	 * @param {Object} typedArray The typed array to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned typed array.
+	 */
+	function cloneTypedArray(typedArray, isDeep) {
+	  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+	  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+	}
+
+	/**
+	 * Copies the values of `source` to `array`.
+	 *
+	 * @private
+	 * @param {Array} source The array to copy values from.
+	 * @param {Array} [array=[]] The array to copy values to.
+	 * @returns {Array} Returns `array`.
+	 */
+	function copyArray(source, array) {
+	  var index = -1,
+	      length = source.length;
+
+	  array || (array = Array(length));
+	  while (++index < length) {
+	    array[index] = source[index];
+	  }
+	  return array;
+	}
+
+	/**
+	 * Copies properties of `source` to `object`.
+	 *
+	 * @private
+	 * @param {Object} source The object to copy properties from.
+	 * @param {Array} props The property identifiers to copy.
+	 * @param {Object} [object={}] The object to copy properties to.
+	 * @param {Function} [customizer] The function to customize copied values.
+	 * @returns {Object} Returns `object`.
+	 */
+	function copyObject(source, props, object, customizer) {
+	  object || (object = {});
+
+	  var index = -1,
+	      length = props.length;
+
+	  while (++index < length) {
+	    var key = props[index];
+
+	    var newValue = customizer
+	      ? customizer(object[key], source[key], key, object, source)
+	      : undefined;
+
+	    assignValue(object, key, newValue === undefined ? source[key] : newValue);
+	  }
+	  return object;
+	}
+
+	/**
+	 * Copies own symbol properties of `source` to `object`.
+	 *
+	 * @private
+	 * @param {Object} source The object to copy symbols from.
+	 * @param {Object} [object={}] The object to copy symbols to.
+	 * @returns {Object} Returns `object`.
+	 */
+	function copySymbols(source, object) {
+	  return copyObject(source, getSymbols(source), object);
+	}
+
+	/**
+	 * Creates a function like `_.assign`.
+	 *
+	 * @private
+	 * @param {Function} assigner The function to assign values.
+	 * @returns {Function} Returns the new assigner function.
+	 */
+	function createAssigner(assigner) {
+	  return baseRest(function(object, sources) {
+	    var index = -1,
+	        length = sources.length,
+	        customizer = length > 1 ? sources[length - 1] : undefined,
+	        guard = length > 2 ? sources[2] : undefined;
+
+	    customizer = (assigner.length > 3 && typeof customizer == 'function')
+	      ? (length--, customizer)
+	      : undefined;
+
+	    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+	      customizer = length < 3 ? undefined : customizer;
+	      length = 1;
+	    }
+	    object = Object(object);
+	    while (++index < length) {
+	      var source = sources[index];
+	      if (source) {
+	        assigner(object, source, index, customizer);
+	      }
+	    }
+	    return object;
+	  });
+	}
+
+	/**
+	 * Creates an array of own enumerable property names and symbols of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names and symbols.
+	 */
+	function getAllKeys(object) {
+	  return baseGetAllKeys(object, keys, getSymbols);
+	}
+
+	/**
+	 * Gets the data for `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to query.
+	 * @param {string} key The reference key.
+	 * @returns {*} Returns the map data.
+	 */
+	function getMapData(map, key) {
+	  var data = map.__data__;
+	  return isKeyable(key)
+	    ? data[typeof key == 'string' ? 'string' : 'hash']
+	    : data.map;
+	}
+
+	/**
+	 * Gets the native function at `key` of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {string} key The key of the method to get.
+	 * @returns {*} Returns the function if it's native, else `undefined`.
+	 */
+	function getNative(object, key) {
+	  var value = getValue(object, key);
+	  return baseIsNative(value) ? value : undefined;
+	}
+
+	/**
+	 * Creates an array of the own enumerable symbol properties of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of symbols.
+	 */
+	var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
+
+	/**
+	 * Gets the `toStringTag` of `value`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	var getTag = baseGetTag;
+
+	// Fallback for data views, maps, sets, and weak maps in IE 11,
+	// for data views in Edge < 14, and promises in Node.js.
+	if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+	    (Map && getTag(new Map) != mapTag) ||
+	    (Promise && getTag(Promise.resolve()) != promiseTag) ||
+	    (Set && getTag(new Set) != setTag) ||
+	    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+	  getTag = function(value) {
+	    var result = objectToString.call(value),
+	        Ctor = result == objectTag ? value.constructor : undefined,
+	        ctorString = Ctor ? toSource(Ctor) : undefined;
+
+	    if (ctorString) {
+	      switch (ctorString) {
+	        case dataViewCtorString: return dataViewTag;
+	        case mapCtorString: return mapTag;
+	        case promiseCtorString: return promiseTag;
+	        case setCtorString: return setTag;
+	        case weakMapCtorString: return weakMapTag;
+	      }
+	    }
+	    return result;
+	  };
+	}
+
+	/**
+	 * Initializes an array clone.
+	 *
+	 * @private
+	 * @param {Array} array The array to clone.
+	 * @returns {Array} Returns the initialized clone.
+	 */
+	function initCloneArray(array) {
+	  var length = array.length,
+	      result = array.constructor(length);
+
+	  // Add properties assigned by `RegExp#exec`.
+	  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+	    result.index = array.index;
+	    result.input = array.input;
+	  }
+	  return result;
+	}
+
+	/**
+	 * Initializes an object clone.
+	 *
+	 * @private
+	 * @param {Object} object The object to clone.
+	 * @returns {Object} Returns the initialized clone.
+	 */
+	function initCloneObject(object) {
+	  return (typeof object.constructor == 'function' && !isPrototype(object))
+	    ? baseCreate(getPrototype(object))
+	    : {};
+	}
+
+	/**
+	 * Initializes an object clone based on its `toStringTag`.
+	 *
+	 * **Note:** This function only supports cloning values with tags of
+	 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+	 *
+	 * @private
+	 * @param {Object} object The object to clone.
+	 * @param {string} tag The `toStringTag` of the object to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the initialized clone.
+	 */
+	function initCloneByTag(object, tag, cloneFunc, isDeep) {
+	  var Ctor = object.constructor;
+	  switch (tag) {
+	    case arrayBufferTag:
+	      return cloneArrayBuffer(object);
+
+	    case boolTag:
+	    case dateTag:
+	      return new Ctor(+object);
+
+	    case dataViewTag:
+	      return cloneDataView(object, isDeep);
+
+	    case float32Tag: case float64Tag:
+	    case int8Tag: case int16Tag: case int32Tag:
+	    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+	      return cloneTypedArray(object, isDeep);
+
+	    case mapTag:
+	      return cloneMap(object, isDeep, cloneFunc);
+
+	    case numberTag:
+	    case stringTag:
+	      return new Ctor(object);
+
+	    case regexpTag:
+	      return cloneRegExp(object);
+
+	    case setTag:
+	      return cloneSet(object, isDeep, cloneFunc);
+
+	    case symbolTag:
+	      return cloneSymbol(object);
+	  }
+	}
+
+	/**
+	 * Checks if `value` is a valid array-like index.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+	 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+	 */
+	function isIndex(value, length) {
+	  length = length == null ? MAX_SAFE_INTEGER : length;
+	  return !!length &&
+	    (typeof value == 'number' || reIsUint.test(value)) &&
+	    (value > -1 && value % 1 == 0 && value < length);
+	}
+
+	/**
+	 * Checks if the given arguments are from an iteratee call.
+	 *
+	 * @private
+	 * @param {*} value The potential iteratee value argument.
+	 * @param {*} index The potential iteratee index or key argument.
+	 * @param {*} object The potential iteratee object argument.
+	 * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+	 *  else `false`.
+	 */
+	function isIterateeCall(value, index, object) {
+	  if (!isObject(object)) {
+	    return false;
+	  }
+	  var type = typeof index;
+	  if (type == 'number'
+	        ? (isArrayLike(object) && isIndex(index, object.length))
+	        : (type == 'string' && index in object)
+	      ) {
+	    return eq(object[index], value);
+	  }
+	  return false;
+	}
+
+	/**
+	 * Checks if `value` is suitable for use as unique object key.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	 */
+	function isKeyable(value) {
+	  var type = typeof value;
+	  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+	    ? (value !== '__proto__')
+	    : (value === null);
+	}
+
+	/**
+	 * Checks if `func` has its source masked.
+	 *
+	 * @private
+	 * @param {Function} func The function to check.
+	 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	 */
+	function isMasked(func) {
+	  return !!maskSrcKey && (maskSrcKey in func);
+	}
+
+	/**
+	 * Checks if `value` is likely a prototype object.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+	 */
+	function isPrototype(value) {
+	  var Ctor = value && value.constructor,
+	      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+	  return value === proto;
+	}
+
+	/**
+	 * This function is like
+	 * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+	 * except that it includes inherited enumerable properties.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function nativeKeysIn(object) {
+	  var result = [];
+	  if (object != null) {
+	    for (var key in Object(object)) {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * Converts `func` to its source code.
+	 *
+	 * @private
+	 * @param {Function} func The function to process.
+	 * @returns {string} Returns the source code.
+	 */
+	function toSource(func) {
+	  if (func != null) {
+	    try {
+	      return funcToString.call(func);
+	    } catch (e) {}
+	    try {
+	      return (func + '');
+	    } catch (e) {}
+	  }
+	  return '';
+	}
+
+	/**
+	 * Performs a
+	 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	 * comparison between two values to determine if they are equivalent.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to compare.
+	 * @param {*} other The other value to compare.
+	 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	 * @example
+	 *
+	 * var object = { 'a': 1 };
+	 * var other = { 'a': 1 };
+	 *
+	 * _.eq(object, object);
+	 * // => true
+	 *
+	 * _.eq(object, other);
+	 * // => false
+	 *
+	 * _.eq('a', 'a');
+	 * // => true
+	 *
+	 * _.eq('a', Object('a'));
+	 * // => false
+	 *
+	 * _.eq(NaN, NaN);
+	 * // => true
+	 */
+	function eq(value, other) {
+	  return value === other || (value !== value && other !== other);
+	}
+
+	/**
+	 * Checks if `value` is likely an `arguments` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	 *  else `false`.
+	 * @example
+	 *
+	 * _.isArguments(function() { return arguments; }());
+	 * // => true
+	 *
+	 * _.isArguments([1, 2, 3]);
+	 * // => false
+	 */
+	function isArguments(value) {
+	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+	  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+	    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+	}
+
+	/**
+	 * Checks if `value` is classified as an `Array` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	 * @example
+	 *
+	 * _.isArray([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArray(document.body.children);
+	 * // => false
+	 *
+	 * _.isArray('abc');
+	 * // => false
+	 *
+	 * _.isArray(_.noop);
+	 * // => false
+	 */
+	var isArray = Array.isArray;
+
+	/**
+	 * Checks if `value` is array-like. A value is considered array-like if it's
+	 * not a function and has a `value.length` that's an integer greater than or
+	 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	 * @example
+	 *
+	 * _.isArrayLike([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArrayLike(document.body.children);
+	 * // => true
+	 *
+	 * _.isArrayLike('abc');
+	 * // => true
+	 *
+	 * _.isArrayLike(_.noop);
+	 * // => false
+	 */
+	function isArrayLike(value) {
+	  return value != null && isLength(value.length) && !isFunction(value);
+	}
+
+	/**
+	 * This method is like `_.isArrayLike` except that it also checks if `value`
+	 * is an object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an array-like object,
+	 *  else `false`.
+	 * @example
+	 *
+	 * _.isArrayLikeObject([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArrayLikeObject(document.body.children);
+	 * // => true
+	 *
+	 * _.isArrayLikeObject('abc');
+	 * // => false
+	 *
+	 * _.isArrayLikeObject(_.noop);
+	 * // => false
+	 */
+	function isArrayLikeObject(value) {
+	  return isObjectLike(value) && isArrayLike(value);
+	}
+
+	/**
+	 * Checks if `value` is a buffer.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.3.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+	 * @example
+	 *
+	 * _.isBuffer(new Buffer(2));
+	 * // => true
+	 *
+	 * _.isBuffer(new Uint8Array(2));
+	 * // => false
+	 */
+	var isBuffer = nativeIsBuffer || stubFalse;
+
+	/**
+	 * Checks if `value` is classified as a `Function` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	 * @example
+	 *
+	 * _.isFunction(_);
+	 * // => true
+	 *
+	 * _.isFunction(/abc/);
+	 * // => false
+	 */
+	function isFunction(value) {
+	  // The use of `Object#toString` avoids issues with the `typeof` operator
+	  // in Safari 8-9 which returns 'object' for typed array and other constructors.
+	  var tag = isObject(value) ? objectToString.call(value) : '';
+	  return tag == funcTag || tag == genTag;
+	}
+
+	/**
+	 * Checks if `value` is a valid array-like length.
+	 *
+	 * **Note:** This method is loosely based on
+	 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	 * @example
+	 *
+	 * _.isLength(3);
+	 * // => true
+	 *
+	 * _.isLength(Number.MIN_VALUE);
+	 * // => false
+	 *
+	 * _.isLength(Infinity);
+	 * // => false
+	 *
+	 * _.isLength('3');
+	 * // => false
+	 */
+	function isLength(value) {
+	  return typeof value == 'number' &&
+	    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+
+	/**
+	 * Checks if `value` is the
+	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	 * @example
+	 *
+	 * _.isObject({});
+	 * // => true
+	 *
+	 * _.isObject([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isObject(_.noop);
+	 * // => true
+	 *
+	 * _.isObject(null);
+	 * // => false
+	 */
+	function isObject(value) {
+	  var type = typeof value;
+	  return !!value && (type == 'object' || type == 'function');
+	}
+
+	/**
+	 * Checks if `value` is object-like. A value is object-like if it's not `null`
+	 * and has a `typeof` result of "object".
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	 * @example
+	 *
+	 * _.isObjectLike({});
+	 * // => true
+	 *
+	 * _.isObjectLike([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isObjectLike(_.noop);
+	 * // => false
+	 *
+	 * _.isObjectLike(null);
+	 * // => false
+	 */
+	function isObjectLike(value) {
+	  return !!value && typeof value == 'object';
+	}
+
+	/**
+	 * Checks if `value` is a plain object, that is, an object created by the
+	 * `Object` constructor or one with a `[[Prototype]]` of `null`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.8.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1;
+	 * }
+	 *
+	 * _.isPlainObject(new Foo);
+	 * // => false
+	 *
+	 * _.isPlainObject([1, 2, 3]);
+	 * // => false
+	 *
+	 * _.isPlainObject({ 'x': 0, 'y': 0 });
+	 * // => true
+	 *
+	 * _.isPlainObject(Object.create(null));
+	 * // => true
+	 */
+	function isPlainObject(value) {
+	  if (!isObjectLike(value) ||
+	      objectToString.call(value) != objectTag || isHostObject(value)) {
+	    return false;
+	  }
+	  var proto = getPrototype(value);
+	  if (proto === null) {
+	    return true;
+	  }
+	  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+	  return (typeof Ctor == 'function' &&
+	    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
+	}
+
+	/**
+	 * Checks if `value` is classified as a typed array.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	 * @example
+	 *
+	 * _.isTypedArray(new Uint8Array);
+	 * // => true
+	 *
+	 * _.isTypedArray([]);
+	 * // => false
+	 */
+	var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+	/**
+	 * Converts `value` to a plain object flattening inherited enumerable string
+	 * keyed properties of `value` to own properties of the plain object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.0.0
+	 * @category Lang
+	 * @param {*} value The value to convert.
+	 * @returns {Object} Returns the converted plain object.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.b = 2;
+	 * }
+	 *
+	 * Foo.prototype.c = 3;
+	 *
+	 * _.assign({ 'a': 1 }, new Foo);
+	 * // => { 'a': 1, 'b': 2 }
+	 *
+	 * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+	 * // => { 'a': 1, 'b': 2, 'c': 3 }
+	 */
+	function toPlainObject(value) {
+	  return copyObject(value, keysIn(value));
+	}
+
+	/**
+	 * Creates an array of the own enumerable property names of `object`.
+	 *
+	 * **Note:** Non-object values are coerced to objects. See the
+	 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+	 * for more details.
+	 *
+	 * @static
+	 * @since 0.1.0
+	 * @memberOf _
+	 * @category Object
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1;
+	 *   this.b = 2;
+	 * }
+	 *
+	 * Foo.prototype.c = 3;
+	 *
+	 * _.keys(new Foo);
+	 * // => ['a', 'b'] (iteration order is not guaranteed)
+	 *
+	 * _.keys('hi');
+	 * // => ['0', '1']
+	 */
+	function keys(object) {
+	  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+	}
+
+	/**
+	 * Creates an array of the own and inherited enumerable property names of `object`.
+	 *
+	 * **Note:** Non-object values are coerced to objects.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.0.0
+	 * @category Object
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1;
+	 *   this.b = 2;
+	 * }
+	 *
+	 * Foo.prototype.c = 3;
+	 *
+	 * _.keysIn(new Foo);
+	 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+	 */
+	function keysIn(object) {
+	  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+	}
+
+	/**
+	 * This method is like `_.assign` except that it recursively merges own and
+	 * inherited enumerable string keyed properties of source objects into the
+	 * destination object. Source properties that resolve to `undefined` are
+	 * skipped if a destination value exists. Array and plain object properties
+	 * are merged recursively. Other objects and value types are overridden by
+	 * assignment. Source objects are applied from left to right. Subsequent
+	 * sources overwrite property assignments of previous sources.
+	 *
+	 * **Note:** This method mutates `object`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.5.0
+	 * @category Object
+	 * @param {Object} object The destination object.
+	 * @param {...Object} [sources] The source objects.
+	 * @returns {Object} Returns `object`.
+	 * @example
+	 *
+	 * var object = {
+	 *   'a': [{ 'b': 2 }, { 'd': 4 }]
+	 * };
+	 *
+	 * var other = {
+	 *   'a': [{ 'c': 3 }, { 'e': 5 }]
+	 * };
+	 *
+	 * _.merge(object, other);
+	 * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+	 */
+	var merge = createAssigner(function(object, source, srcIndex) {
+	  baseMerge(object, source, srcIndex);
+	});
+
+	/**
+	 * This method returns a new empty array.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.13.0
+	 * @category Util
+	 * @returns {Array} Returns the new empty array.
+	 * @example
+	 *
+	 * var arrays = _.times(2, _.stubArray);
+	 *
+	 * console.log(arrays);
+	 * // => [[], []]
+	 *
+	 * console.log(arrays[0] === arrays[1]);
+	 * // => false
+	 */
+	function stubArray() {
+	  return [];
+	}
+
+	/**
+	 * This method returns `false`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.13.0
+	 * @category Util
+	 * @returns {boolean} Returns `false`.
+	 * @example
+	 *
+	 * _.times(2, _.stubFalse);
+	 * // => [false, false]
+	 */
+	function stubFalse() {
+	  return false;
+	}
+
+	module.exports = merge;
+
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(44)(module)))
+
+/***/ },
+/* 180 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'horizontalbar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            },
+	            categoryPercentage: 0.5,
+	            barPercentage: 0.2
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options, type) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'horizontalBar',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 181 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'doughnut-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'doughnut',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 182 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'line-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            }
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'line',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 183 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'pie-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'pie',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 184 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'polar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'polarArea',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 185 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'radar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'radar',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 186 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'bubble-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            },
+	            categoryPercentage: 0.5,
+	            barPercentage: 0.2
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'bubble',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 187 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(4);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(178);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'scatter-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          xAxes: [{
+	            type: 'linear',
+	            position: 'bottom'
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'scatter',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 188 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _reactiveData = __webpack_require__(189);
+
+	var _reactiveData2 = _interopRequireDefault(_reactiveData);
+
+	var _reactiveProp = __webpack_require__(227);
+
+	var _reactiveProp2 = _interopRequireDefault(_reactiveProp);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = {
+	  reactiveData: _reactiveData2.default,
+	  reactiveProp: _reactiveProp2.default
+	};
+
+/***/ },
+/* 189 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _keys = __webpack_require__(190);
+
+	var _keys2 = _interopRequireDefault(_keys);
+
+	var _stringify = __webpack_require__(225);
+
+	var _stringify2 = _interopRequireDefault(_stringify);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	module.exports = {
+	  data: function data() {
+	    return {
+	      chartData: null
+	    };
+	  },
+
+	  watch: {
+	    'chartData': {
+	      handler: function handler(newData, oldData) {
+	        if (oldData) {
+	          var chart = this._chart;
+
+	          var newDatasetLabels = newData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldDatasetLabels = oldData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldLabels = (0, _stringify2.default)(oldDatasetLabels);
+	          var newLabels = (0, _stringify2.default)(newDatasetLabels);
+
+	          if (newLabels === oldLabels && oldData.datasets.length === newData.datasets.length) {
+	            newData.datasets.forEach(function (dataset, i) {
+	              var oldDatasetKeys = (0, _keys2.default)(oldData.datasets[i]);
+	              var newDatasetKeys = (0, _keys2.default)(dataset);
+
+	              var deletionKeys = oldDatasetKeys.filter(function (key) {
+	                return key !== '_meta' && newDatasetKeys.indexOf(key) === -1;
+	              });
+
+	              deletionKeys.forEach(function (deletionKey) {
+	                delete chart.data.datasets[i][deletionKey];
+	              });
+
+	              for (var attribute in dataset) {
+	                if (dataset.hasOwnProperty(attribute)) {
+	                  chart.data.datasets[i][attribute] = dataset[attribute];
+	                }
+	              }
+	            });
+
+	            if (newData.hasOwnProperty('labels')) {
+	              chart.data.labels = newData.labels;
+	            }
+	            if (newData.hasOwnProperty('xLabels')) {
+	              chart.data.xLabels = newData.xLabels;
+	            }
+	            if (newData.hasOwnProperty('yLabels')) {
+	              chart.data.yLabels = newData.yLabels;
+	            }
+	            chart.update();
+	          } else {
+	            chart.destroy();
+	            this.renderChart(this.chartData, this.options);
+	          }
+	        } else {
+	          this.renderChart(this.chartData, this.options);
+	        }
+	      }
+	    }
+	  }
+	};
+
+/***/ },
+/* 190 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = { "default": __webpack_require__(191), __esModule: true };
+
+/***/ },
+/* 191 */
+/***/ function(module, exports, __webpack_require__) {
+
+	__webpack_require__(192);
+	module.exports = __webpack_require__(212).Object.keys;
+
+/***/ },
+/* 192 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 19.1.2.14 Object.keys(O)
+	var toObject = __webpack_require__(193)
+	  , $keys    = __webpack_require__(195);
+
+	__webpack_require__(210)('keys', function(){
+	  return function keys(it){
+	    return $keys(toObject(it));
+	  };
+	});
+
+/***/ },
+/* 193 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 7.1.13 ToObject(argument)
+	var defined = __webpack_require__(194);
+	module.exports = function(it){
+	  return Object(defined(it));
+	};
+
+/***/ },
+/* 194 */
+/***/ function(module, exports) {
+
+	// 7.2.1 RequireObjectCoercible(argument)
+	module.exports = function(it){
+	  if(it == undefined)throw TypeError("Can't call method on  " + it);
+	  return it;
+	};
+
+/***/ },
+/* 195 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+	var $keys       = __webpack_require__(196)
+	  , enumBugKeys = __webpack_require__(209);
+
+	module.exports = Object.keys || function keys(O){
+	  return $keys(O, enumBugKeys);
+	};
+
+/***/ },
+/* 196 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var has          = __webpack_require__(197)
+	  , toIObject    = __webpack_require__(198)
+	  , arrayIndexOf = __webpack_require__(201)(false)
+	  , IE_PROTO     = __webpack_require__(205)('IE_PROTO');
+
+	module.exports = function(object, names){
+	  var O      = toIObject(object)
+	    , i      = 0
+	    , result = []
+	    , key;
+	  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
+	  // Don't enum bug & hidden keys
+	  while(names.length > i)if(has(O, key = names[i++])){
+	    ~arrayIndexOf(result, key) || result.push(key);
+	  }
+	  return result;
+	};
+
+/***/ },
+/* 197 */
+/***/ function(module, exports) {
+
+	var hasOwnProperty = {}.hasOwnProperty;
+	module.exports = function(it, key){
+	  return hasOwnProperty.call(it, key);
+	};
+
+/***/ },
+/* 198 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// to indexed object, toObject with fallback for non-array-like ES3 strings
+	var IObject = __webpack_require__(199)
+	  , defined = __webpack_require__(194);
+	module.exports = function(it){
+	  return IObject(defined(it));
+	};
+
+/***/ },
+/* 199 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// fallback for non-array-like ES3 and non-enumerable old V8 strings
+	var cof = __webpack_require__(200);
+	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
+	  return cof(it) == 'String' ? it.split('') : Object(it);
+	};
+
+/***/ },
+/* 200 */
+/***/ function(module, exports) {
+
+	var toString = {}.toString;
+
+	module.exports = function(it){
+	  return toString.call(it).slice(8, -1);
+	};
+
+/***/ },
+/* 201 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// false -> Array#indexOf
+	// true  -> Array#includes
+	var toIObject = __webpack_require__(198)
+	  , toLength  = __webpack_require__(202)
+	  , toIndex   = __webpack_require__(204);
+	module.exports = function(IS_INCLUDES){
+	  return function($this, el, fromIndex){
+	    var O      = toIObject($this)
+	      , length = toLength(O.length)
+	      , index  = toIndex(fromIndex, length)
+	      , value;
+	    // Array#includes uses SameValueZero equality algorithm
+	    if(IS_INCLUDES && el != el)while(length > index){
+	      value = O[index++];
+	      if(value != value)return true;
+	    // Array#toIndex ignores holes, Array#includes - not
+	    } else for(;length > index; index++)if(IS_INCLUDES || index in O){
+	      if(O[index] === el)return IS_INCLUDES || index || 0;
+	    } return !IS_INCLUDES && -1;
+	  };
+	};
+
+/***/ },
+/* 202 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 7.1.15 ToLength
+	var toInteger = __webpack_require__(203)
+	  , min       = Math.min;
+	module.exports = function(it){
+	  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+	};
+
+/***/ },
+/* 203 */
+/***/ function(module, exports) {
+
+	// 7.1.4 ToInteger
+	var ceil  = Math.ceil
+	  , floor = Math.floor;
+	module.exports = function(it){
+	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+	};
+
+/***/ },
+/* 204 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var toInteger = __webpack_require__(203)
+	  , max       = Math.max
+	  , min       = Math.min;
+	module.exports = function(index, length){
+	  index = toInteger(index);
+	  return index < 0 ? max(index + length, 0) : min(index, length);
+	};
+
+/***/ },
+/* 205 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var shared = __webpack_require__(206)('keys')
+	  , uid    = __webpack_require__(208);
+	module.exports = function(key){
+	  return shared[key] || (shared[key] = uid(key));
+	};
+
+/***/ },
+/* 206 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var global = __webpack_require__(207)
+	  , SHARED = '__core-js_shared__'
+	  , store  = global[SHARED] || (global[SHARED] = {});
+	module.exports = function(key){
+	  return store[key] || (store[key] = {});
+	};
+
+/***/ },
+/* 207 */
+/***/ function(module, exports) {
+
+	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+	var global = module.exports = typeof window != 'undefined' && window.Math == Math
+	  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
+	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
+
+/***/ },
+/* 208 */
+/***/ function(module, exports) {
+
+	var id = 0
+	  , px = Math.random();
+	module.exports = function(key){
+	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+	};
+
+/***/ },
+/* 209 */
+/***/ function(module, exports) {
+
+	// IE 8- don't enum bug keys
+	module.exports = (
+	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+	).split(',');
+
+/***/ },
+/* 210 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// most Object methods by ES6 should accept primitives
+	var $export = __webpack_require__(211)
+	  , core    = __webpack_require__(212)
+	  , fails   = __webpack_require__(221);
+	module.exports = function(KEY, exec){
+	  var fn  = (core.Object || {})[KEY] || Object[KEY]
+	    , exp = {};
+	  exp[KEY] = exec(fn);
+	  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
+	};
+
+/***/ },
+/* 211 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var global    = __webpack_require__(207)
+	  , core      = __webpack_require__(212)
+	  , ctx       = __webpack_require__(213)
+	  , hide      = __webpack_require__(215)
+	  , PROTOTYPE = 'prototype';
+
+	var $export = function(type, name, source){
+	  var IS_FORCED = type & $export.F
+	    , IS_GLOBAL = type & $export.G
+	    , IS_STATIC = type & $export.S
+	    , IS_PROTO  = type & $export.P
+	    , IS_BIND   = type & $export.B
+	    , IS_WRAP   = type & $export.W
+	    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
+	    , expProto  = exports[PROTOTYPE]
+	    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
+	    , key, own, out;
+	  if(IS_GLOBAL)source = name;
+	  for(key in source){
+	    // contains in native
+	    own = !IS_FORCED && target && target[key] !== undefined;
+	    if(own && key in exports)continue;
+	    // export native or passed
+	    out = own ? target[key] : source[key];
+	    // prevent global pollution for namespaces
+	    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
+	    // bind timers to global for call from export context
+	    : IS_BIND && own ? ctx(out, global)
+	    // wrap global constructors for prevent change them in library
+	    : IS_WRAP && target[key] == out ? (function(C){
+	      var F = function(a, b, c){
+	        if(this instanceof C){
+	          switch(arguments.length){
+	            case 0: return new C;
+	            case 1: return new C(a);
+	            case 2: return new C(a, b);
+	          } return new C(a, b, c);
+	        } return C.apply(this, arguments);
+	      };
+	      F[PROTOTYPE] = C[PROTOTYPE];
+	      return F;
+	    // make static versions for prototype methods
+	    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+	    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
+	    if(IS_PROTO){
+	      (exports.virtual || (exports.virtual = {}))[key] = out;
+	      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
+	      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);
+	    }
+	  }
+	};
+	// type bitmap
+	$export.F = 1;   // forced
+	$export.G = 2;   // global
+	$export.S = 4;   // static
+	$export.P = 8;   // proto
+	$export.B = 16;  // bind
+	$export.W = 32;  // wrap
+	$export.U = 64;  // safe
+	$export.R = 128; // real proto method for `library` 
+	module.exports = $export;
+
+/***/ },
+/* 212 */
+/***/ function(module, exports) {
+
+	var core = module.exports = {version: '2.4.0'};
+	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
+
+/***/ },
+/* 213 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// optional / simple context binding
+	var aFunction = __webpack_require__(214);
+	module.exports = function(fn, that, length){
+	  aFunction(fn);
+	  if(that === undefined)return fn;
+	  switch(length){
+	    case 1: return function(a){
+	      return fn.call(that, a);
+	    };
+	    case 2: return function(a, b){
+	      return fn.call(that, a, b);
+	    };
+	    case 3: return function(a, b, c){
+	      return fn.call(that, a, b, c);
+	    };
+	  }
+	  return function(/* ...args */){
+	    return fn.apply(that, arguments);
+	  };
+	};
+
+/***/ },
+/* 214 */
+/***/ function(module, exports) {
+
+	module.exports = function(it){
+	  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
+	  return it;
+	};
+
+/***/ },
+/* 215 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var dP         = __webpack_require__(216)
+	  , createDesc = __webpack_require__(224);
+	module.exports = __webpack_require__(220) ? function(object, key, value){
+	  return dP.f(object, key, createDesc(1, value));
+	} : function(object, key, value){
+	  object[key] = value;
+	  return object;
+	};
+
+/***/ },
+/* 216 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var anObject       = __webpack_require__(217)
+	  , IE8_DOM_DEFINE = __webpack_require__(219)
+	  , toPrimitive    = __webpack_require__(223)
+	  , dP             = Object.defineProperty;
+
+	exports.f = __webpack_require__(220) ? Object.defineProperty : function defineProperty(O, P, Attributes){
+	  anObject(O);
+	  P = toPrimitive(P, true);
+	  anObject(Attributes);
+	  if(IE8_DOM_DEFINE)try {
+	    return dP(O, P, Attributes);
+	  } catch(e){ /* empty */ }
+	  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
+	  if('value' in Attributes)O[P] = Attributes.value;
+	  return O;
+	};
+
+/***/ },
+/* 217 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var isObject = __webpack_require__(218);
+	module.exports = function(it){
+	  if(!isObject(it))throw TypeError(it + ' is not an object!');
+	  return it;
+	};
+
+/***/ },
+/* 218 */
+/***/ function(module, exports) {
+
+	module.exports = function(it){
+	  return typeof it === 'object' ? it !== null : typeof it === 'function';
+	};
+
+/***/ },
+/* 219 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = !__webpack_require__(220) && !__webpack_require__(221)(function(){
+	  return Object.defineProperty(__webpack_require__(222)('div'), 'a', {get: function(){ return 7; }}).a != 7;
+	});
+
+/***/ },
+/* 220 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Thank's IE8 for his funny defineProperty
+	module.exports = !__webpack_require__(221)(function(){
+	  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
+	});
+
+/***/ },
+/* 221 */
+/***/ function(module, exports) {
+
+	module.exports = function(exec){
+	  try {
+	    return !!exec();
+	  } catch(e){
+	    return true;
+	  }
+	};
+
+/***/ },
+/* 222 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var isObject = __webpack_require__(218)
+	  , document = __webpack_require__(207).document
+	  // in old IE typeof document.createElement is 'object'
+	  , is = isObject(document) && isObject(document.createElement);
+	module.exports = function(it){
+	  return is ? document.createElement(it) : {};
+	};
+
+/***/ },
+/* 223 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 7.1.1 ToPrimitive(input [, PreferredType])
+	var isObject = __webpack_require__(218);
+	// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+	// and the second argument - flag - preferred type is a string
+	module.exports = function(it, S){
+	  if(!isObject(it))return it;
+	  var fn, val;
+	  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+	  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
+	  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+	  throw TypeError("Can't convert object to primitive value");
+	};
+
+/***/ },
+/* 224 */
+/***/ function(module, exports) {
+
+	module.exports = function(bitmap, value){
+	  return {
+	    enumerable  : !(bitmap & 1),
+	    configurable: !(bitmap & 2),
+	    writable    : !(bitmap & 4),
+	    value       : value
+	  };
+	};
+
+/***/ },
+/* 225 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = { "default": __webpack_require__(226), __esModule: true };
+
+/***/ },
+/* 226 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var core  = __webpack_require__(212)
+	  , $JSON = core.JSON || (core.JSON = {stringify: JSON.stringify});
+	module.exports = function stringify(it){ // eslint-disable-line no-unused-vars
+	  return $JSON.stringify.apply($JSON, arguments);
+	};
+
+/***/ },
+/* 227 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _keys = __webpack_require__(190);
+
+	var _keys2 = _interopRequireDefault(_keys);
+
+	var _stringify = __webpack_require__(225);
+
+	var _stringify2 = _interopRequireDefault(_stringify);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	module.exports = {
+	  props: {
+	    chartData: {
+	      required: true
+	    }
+	  },
+	  watch: {
+	    'chartData': {
+	      handler: function handler(newData, oldData) {
+	        if (oldData) {
+	          var chart = this._chart;
+
+	          var newDatasetLabels = newData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldDatasetLabels = oldData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldLabels = (0, _stringify2.default)(oldDatasetLabels);
+	          var newLabels = (0, _stringify2.default)(newDatasetLabels);
+
+	          if (newLabels === oldLabels && oldData.datasets.length === newData.datasets.length) {
+	            newData.datasets.forEach(function (dataset, i) {
+	              var oldDatasetKeys = (0, _keys2.default)(oldData.datasets[i]);
+	              var newDatasetKeys = (0, _keys2.default)(dataset);
+
+	              var deletionKeys = oldDatasetKeys.filter(function (key) {
+	                return key !== '_meta' && newDatasetKeys.indexOf(key) === -1;
+	              });
+
+	              deletionKeys.forEach(function (deletionKey) {
+	                delete chart.data.datasets[i][deletionKey];
+	              });
+
+	              for (var attribute in dataset) {
+	                if (dataset.hasOwnProperty(attribute)) {
+	                  chart.data.datasets[i][attribute] = dataset[attribute];
+	                }
+	              }
+	            });
+
+	            if (newData.hasOwnProperty('labels')) {
+	              chart.data.labels = newData.labels;
+	            }
+	            if (newData.hasOwnProperty('xLabels')) {
+	              chart.data.xLabels = newData.xLabels;
+	            }
+	            if (newData.hasOwnProperty('yLabels')) {
+	              chart.data.yLabels = newData.yLabels;
+	            }
+	            chart.update();
+	          } else {
+	            chart.destroy();
+	            this.renderChart(this.chartData, this.options);
+	          }
+	        } else {
+	          this.renderChart(this.chartData, this.options);
+	        }
+	      }
+	    }
+	  }
+	};
+
+/***/ },
+/* 228 */
+/***/ function(module, exports) {
+
+	module.exports = {
+		"name": "vue-chartjs",
+		"version": "2.8.7",
+		"description": "Vue.js wrapper for chart.js for creating beautiful charts.",
+		"author": "Jakub Juszczak <jakub@posteo.de>",
+		"homepage": "http://vue-chartjs.org",
+		"license": "MIT",
+		"contributors": [
+			{
+				"name": "Thorsten Lünborg",
+				"web": "https://github.com/LinusBorg"
+			},
+			{
+				"name": "Juan Carlos Alonso",
+				"web": "https://github.com/jcalonso"
+			}
+		],
+		"maintainers": [
+			{
+				"name": "Jakub Juszczak",
+				"email": "jakub@posteo.de",
+				"web": "http://www.jakubjuszczak.de"
+			}
+		],
+		"repository": {
+			"type": "git",
+			"url": "git+ssh://git@github.com:apertureless/vue-chartjs.git"
+		},
+		"bugs": {
+			"url": "https://github.com/apertureless/vue-chartjs/issues"
+		},
+		"keywords": [
+			"ChartJs",
+			"Vue",
+			"Visualisation",
+			"Wrapper",
+			"Charts"
+		],
+		"main": "dist/vue-chartjs.js",
+		"unpkg": "dist/vue-chartjs.full.min.js",
+		"module": "es/index.js",
+		"jsnext:main": "es/index.js",
+		"files": [
+			"src",
+			"dist",
+			"es"
+		],
+		"scripts": {
+			"dev": "node build/dev-server.js",
+			"build": "yarn run release && yarn run build:es",
+			"build:es": "cross-env BABEL_ENV=es babel src --out-dir es",
+			"unit": "karma start test/unit/karma.conf.js --single-run",
+			"e2e": "node test/e2e/runner.js",
+			"test": "npm run unit",
+			"lint": "eslint --ext .js,.vue src test/unit/specs test/e2e/specs",
+			"release": "webpack --progress --hide-modules --config  ./build/webpack.release.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.min.js && webpack --progress --hide-modules --config  ./build/webpack.release.full.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.full.min.js",
+			"prepublish": "yarn run lint && yarn run test && yarn run build"
+		},
+		"dependencies": {
+			"lodash.merge": "^4.6.0"
+		},
+		"peerDependencies": {
+			"chart.js": "^2.7.0",
+			"vue": "^2.4.4"
+		},
+		"devDependencies": {
+			"babel-cli": "^6.24.1",
+			"babel-core": "^6.25.0",
+			"babel-loader": "^7.0.0",
+			"babel-plugin-transform-object-assign": "^6.22.0",
+			"babel-plugin-transform-runtime": "^6.23.0",
+			"babel-preset-es2015": "^6.24.1",
+			"babel-preset-stage-2": "^6.24.1",
+			"babel-runtime": "^6.23.0",
+			"chai": "^3.5.0",
+			"chart.js": "^2.7.0",
+			"chromedriver": "^2.28.0",
+			"connect-history-api-fallback": "^1.1.0",
+			"cross-env": "^3.2.4",
+			"cross-spawn": "^5.1.0",
+			"css-loader": "^0.28.0",
+			"eslint": "^3.19.0",
+			"eslint-config-standard": "^10.2.1",
+			"eslint-friendly-formatter": "^2.0.7",
+			"eslint-loader": "^1.7.1",
+			"eslint-plugin-html": "^2.0.1",
+			"eslint-plugin-import": "^2.2.0",
+			"eslint-plugin-node": "^4.2.2",
+			"eslint-plugin-promise": "^3.5.0",
+			"eslint-plugin-standard": "^3.0.1",
+			"eventsource-polyfill": "^0.9.6",
+			"express": "^4.15.2",
+			"extract-text-webpack-plugin": "^1.0.1",
+			"file-loader": "^0.10.1",
+			"function-bind": "^1.0.2",
+			"html-webpack-plugin": "^2.28.0",
+			"http-proxy-middleware": "^0.17.4",
+			"inject-loader": "^3.0.0",
+			"isparta-loader": "^2.0.0",
+			"jasmine-core": "^2.5.2",
+			"json-loader": "^0.5.4",
+			"karma": "^1.5.0",
+			"karma-coverage": "^1.1.1",
+			"karma-jasmine": "^1.0.2",
+			"karma-mocha": "^1.2.0",
+			"karma-phantomjs-launcher": "^1.0.4",
+			"karma-sinon-chai": "^1.2.0",
+			"karma-sourcemap-loader": "^0.3.7",
+			"karma-spec-reporter": "0.0.30",
+			"karma-webpack": "1.8.1",
+			"lolex": "^1.6.0",
+			"mocha": "^3.1.0",
+			"nightwatch": "^0.9.14",
+			"ora": "^1.2.0",
+			"phantomjs-prebuilt": "^2.1.13",
+			"selenium-server": "^3.3.1",
+			"shelljs": "^0.7.7",
+			"sinon": "^2.1.0",
+			"sinon-chai": "^2.9.0",
+			"url-loader": "^0.5.8",
+			"vue": "^2.4.4",
+			"vue-hot-reload-api": "^2.1.0",
+			"vue-html-loader": "^1.2.4",
+			"vue-loader": "^12.2.2",
+			"vue-style-loader": "^3.0.1",
+			"vue-template-compiler": "^2.4.2",
+			"webpack": "^1.13.2",
+			"webpack-dev-middleware": "^1.10.1",
+			"webpack-hot-middleware": "^2.17.1",
+			"webpack-merge": "1.1.1"
+		},
+		"engines": {
+			"node": ">=6.9.0"
+		},
+		"babel": {
+			"presets": [
+				"es2015"
+			]
+		},
+		"browserify": {
+			"transform": [
+				"babelify"
+			]
+		},
+		"greenkeeper": {
+			"ignore": [
+				"extract-text-webpack-plugin",
+				"karma-webpack",
+				"webpack",
+				"webpack-merge"
+			]
+		}
+	};
+
+/***/ }
+/******/ ])
+});
+;
\ No newline at end of file
diff --git a/dist/vue-chartjs.full.min.js b/dist/vue-chartjs.full.min.js
new file mode 100644
index 00000000..a4779fe0
--- /dev/null
+++ b/dist/vue-chartjs.full.min.js
@@ -0,0 +1,20 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define("VueChartJs",[],t):"object"==typeof exports?exports.VueChartJs=t():e.VueChartJs=t()}(this,function(){return function(e){function t(a){if(n[a])return n[a].exports;var r=n[a]={exports:{},id:a,loaded:!1};return e[a].call(r.exports,r,r.exports,t),r.loaded=!0,r.exports}var n={};return t.m=e,t.c=n,t.p="",t(0)}([function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0}),t.mixins=t.Scatter=t.Bubble=t.Radar=t.PolarArea=t.Pie=t.Line=t.Doughnut=t.HorizontalBar=t.Bar=t.VueCharts=void 0;var r=n(140),i=a(r),o=n(143),s=a(o),d=n(142),u=a(d),l=n(144),c=a(l),h=n(145),_=a(h),m=n(146),f=a(m),p=n(147),y=a(p),g=n(141),v=a(g),M=n(148),L=a(M),b=n(149),k=a(b),Y=n(225),D=a(Y),w={version:D.default.version,Bar:i.default,HorizontalBar:s.default,Doughnut:u.default,Line:c.default,Pie:_.default,PolarArea:f.default,Radar:y.default,Bubble:v.default,Scatter:L.default,mixins:k.default};t.default=w,t.VueCharts=w,t.Bar=i.default,t.HorizontalBar=s.default,t.Doughnut=u.default,t.Line=c.default,t.Pie=_.default,t.PolarArea=f.default,t.Radar=y.default,t.Bubble=v.default,t.Scatter=L.default,t.mixins=k.default},function(e,t,n){(function(e){!function(t,n){e.exports=n()}(this,function(){"use strict";function t(){return La.apply(null,arguments)}function a(e){La=e}function r(e){return e instanceof Array||"[object Array]"===Object.prototype.toString.call(e)}function i(e){return null!=e&&"[object Object]"===Object.prototype.toString.call(e)}function o(e){var t;for(t in e)return!1;return!0}function s(e){return void 0===e}function d(e){return"number"==typeof e||"[object Number]"===Object.prototype.toString.call(e)}function u(e){return e instanceof Date||"[object Date]"===Object.prototype.toString.call(e)}function l(e,t){var n,a=[];for(n=0;n<e.length;++n)a.push(t(e[n],n));return a}function c(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function h(e,t){for(var n in t)c(t,n)&&(e[n]=t[n]);return c(t,"toString")&&(e.toString=t.toString),c(t,"valueOf")&&(e.valueOf=t.valueOf),e}function _(e,t,n,a){return Mt(e,t,n,a,!0).utc()}function m(){return{empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1,parsedDateParts:[],meridiem:null,rfc2822:!1,weekdayMismatch:!1}}function f(e){return null==e._pf&&(e._pf=m()),e._pf}function p(e){if(null==e._isValid){var t=f(e),n=ka.call(t.parsedDateParts,function(e){return null!=e}),a=!isNaN(e._d.getTime())&&t.overflow<0&&!t.empty&&!t.invalidMonth&&!t.invalidWeekday&&!t.nullInput&&!t.invalidFormat&&!t.userInvalidated&&(!t.meridiem||t.meridiem&&n);if(e._strict&&(a=a&&0===t.charsLeftOver&&0===t.unusedTokens.length&&void 0===t.bigHour),null!=Object.isFrozen&&Object.isFrozen(e))return a;e._isValid=a}return e._isValid}function y(e){var t=_(NaN);return null!=e?h(f(t),e):f(t).userInvalidated=!0,t}function g(e,t){var n,a,r;if(s(t._isAMomentObject)||(e._isAMomentObject=t._isAMomentObject),s(t._i)||(e._i=t._i),s(t._f)||(e._f=t._f),s(t._l)||(e._l=t._l),s(t._strict)||(e._strict=t._strict),s(t._tzm)||(e._tzm=t._tzm),s(t._isUTC)||(e._isUTC=t._isUTC),s(t._offset)||(e._offset=t._offset),s(t._pf)||(e._pf=f(t)),s(t._locale)||(e._locale=t._locale),Ya.length>0)for(n=0;n<Ya.length;n++)a=Ya[n],r=t[a],s(r)||(e[a]=r);return e}function v(e){g(this,e),this._d=new Date(null!=e._d?e._d.getTime():NaN),this.isValid()||(this._d=new Date(NaN)),Da===!1&&(Da=!0,t.updateOffset(this),Da=!1)}function M(e){return e instanceof v||null!=e&&null!=e._isAMomentObject}function L(e){return e<0?Math.ceil(e)||0:Math.floor(e)}function b(e){var t=+e,n=0;return 0!==t&&isFinite(t)&&(n=L(t)),n}function k(e,t,n){var a,r=Math.min(e.length,t.length),i=Math.abs(e.length-t.length),o=0;for(a=0;a<r;a++)(n&&e[a]!==t[a]||!n&&b(e[a])!==b(t[a]))&&o++;return o+i}function Y(e){t.suppressDeprecationWarnings===!1&&"undefined"!=typeof console&&console.warn&&console.warn("Deprecation warning: "+e)}function D(e,n){var a=!0;return h(function(){if(null!=t.deprecationHandler&&t.deprecationHandler(null,e),a){for(var r,i=[],o=0;o<arguments.length;o++){if(r="","object"==typeof arguments[o]){r+="\n["+o+"] ";for(var s in arguments[0])r+=s+": "+arguments[0][s]+", ";r=r.slice(0,-2)}else r=arguments[o];i.push(r)}Y(e+"\nArguments: "+Array.prototype.slice.call(i).join("")+"\n"+(new Error).stack),a=!1}return n.apply(this,arguments)},n)}function w(e,n){null!=t.deprecationHandler&&t.deprecationHandler(e,n),wa[e]||(Y(n),wa[e]=!0)}function x(e){return e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}function T(e){var t,n;for(n in e)t=e[n],x(t)?this[n]=t:this["_"+n]=t;this._config=e,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)}function S(e,t){var n,a=h({},e);for(n in t)c(t,n)&&(i(e[n])&&i(t[n])?(a[n]={},h(a[n],e[n]),h(a[n],t[n])):null!=t[n]?a[n]=t[n]:delete a[n]);for(n in e)c(e,n)&&!c(t,n)&&i(e[n])&&(a[n]=h({},a[n]));return a}function j(e){null!=e&&this.set(e)}function H(e,t,n){var a=this._calendar[e]||this._calendar.sameElse;return x(a)?a.call(t,n):a}function O(e){var t=this._longDateFormat[e],n=this._longDateFormat[e.toUpperCase()];return t||!n?t:(this._longDateFormat[e]=n.replace(/MMMM|MM|DD|dddd/g,function(e){return e.slice(1)}),this._longDateFormat[e])}function P(){return this._invalidDate}function A(e){return this._ordinal.replace("%d",e)}function C(e,t,n,a){var r=this._relativeTime[n];return x(r)?r(e,t,n,a):r.replace(/%d/i,e)}function E(e,t){var n=this._relativeTime[e>0?"future":"past"];return x(n)?n(t):n.replace(/%s/i,t)}function F(e,t){var n=e.toLowerCase();Ea[n]=Ea[n+"s"]=Ea[t]=e}function W(e){return"string"==typeof e?Ea[e]||Ea[e.toLowerCase()]:void 0}function I(e){var t,n,a={};for(n in e)c(e,n)&&(t=W(n),t&&(a[t]=e[n]));return a}function N(e,t){Fa[e]=t}function z(e){var t=[];for(var n in e)t.push({unit:n,priority:Fa[n]});return t.sort(function(e,t){return e.priority-t.priority}),t}function R(e,n){return function(a){return null!=a?(B(this,e,a),t.updateOffset(this,n),this):V(this,e)}}function V(e,t){return e.isValid()?e._d["get"+(e._isUTC?"UTC":"")+t]():NaN}function B(e,t,n){e.isValid()&&e._d["set"+(e._isUTC?"UTC":"")+t](n)}function $(e){return e=W(e),x(this[e])?this[e]():this}function J(e,t){if("object"==typeof e){e=I(e);for(var n=z(e),a=0;a<n.length;a++)this[n[a].unit](e[n[a].unit])}else if(e=W(e),x(this[e]))return this[e](t);return this}function U(e,t,n){var a=""+Math.abs(e),r=t-a.length,i=e>=0;return(i?n?"+":"":"-")+Math.pow(10,Math.max(0,r)).toString().substr(1)+a}function G(e,t,n,a){var r=a;"string"==typeof a&&(r=function(){return this[a]()}),e&&(za[e]=r),t&&(za[t[0]]=function(){return U(r.apply(this,arguments),t[1],t[2])}),n&&(za[n]=function(){return this.localeData().ordinal(r.apply(this,arguments),e)})}function q(e){return e.match(/\[[\s\S]/)?e.replace(/^\[|\]$/g,""):e.replace(/\\/g,"")}function K(e){var t,n,a=e.match(Wa);for(t=0,n=a.length;t<n;t++)za[a[t]]?a[t]=za[a[t]]:a[t]=q(a[t]);return function(t){var r,i="";for(r=0;r<n;r++)i+=x(a[r])?a[r].call(t,e):a[r];return i}}function Z(e,t){return e.isValid()?(t=Q(t,e.localeData()),Na[t]=Na[t]||K(t),Na[t](e)):e.localeData().invalidDate()}function Q(e,t){function n(e){return t.longDateFormat(e)||e}var a=5;for(Ia.lastIndex=0;a>=0&&Ia.test(e);)e=e.replace(Ia,n),Ia.lastIndex=0,a-=1;return e}function X(e,t,n){ir[e]=x(t)?t:function(e,a){return e&&n?n:t}}function ee(e,t){return c(ir,e)?ir[e](t._strict,t._locale):new RegExp(te(e))}function te(e){return ne(e.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(e,t,n,a,r){return t||n||a||r}))}function ne(e){return e.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}function ae(e,t){var n,a=t;for("string"==typeof e&&(e=[e]),d(t)&&(a=function(e,n){n[t]=b(e)}),n=0;n<e.length;n++)or[e[n]]=a}function re(e,t){ae(e,function(e,n,a,r){a._w=a._w||{},t(e,a._w,a,r)})}function ie(e,t,n){null!=t&&c(or,e)&&or[e](t,n._a,n,e)}function oe(e,t){return new Date(Date.UTC(e,t+1,0)).getUTCDate()}function se(e,t){return e?r(this._months)?this._months[e.month()]:this._months[(this._months.isFormat||yr).test(t)?"format":"standalone"][e.month()]:r(this._months)?this._months:this._months.standalone}function de(e,t){return e?r(this._monthsShort)?this._monthsShort[e.month()]:this._monthsShort[yr.test(t)?"format":"standalone"][e.month()]:r(this._monthsShort)?this._monthsShort:this._monthsShort.standalone}function ue(e,t,n){var a,r,i,o=e.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],a=0;a<12;++a)i=_([2e3,a]),this._shortMonthsParse[a]=this.monthsShort(i,"").toLocaleLowerCase(),this._longMonthsParse[a]=this.months(i,"").toLocaleLowerCase();return n?"MMM"===t?(r=pr.call(this._shortMonthsParse,o),r!==-1?r:null):(r=pr.call(this._longMonthsParse,o),r!==-1?r:null):"MMM"===t?(r=pr.call(this._shortMonthsParse,o),r!==-1?r:(r=pr.call(this._longMonthsParse,o),r!==-1?r:null)):(r=pr.call(this._longMonthsParse,o),r!==-1?r:(r=pr.call(this._shortMonthsParse,o),r!==-1?r:null))}function le(e,t,n){var a,r,i;if(this._monthsParseExact)return ue.call(this,e,t,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),a=0;a<12;a++){if(r=_([2e3,a]),n&&!this._longMonthsParse[a]&&(this._longMonthsParse[a]=new RegExp("^"+this.months(r,"").replace(".","")+"$","i"),this._shortMonthsParse[a]=new RegExp("^"+this.monthsShort(r,"").replace(".","")+"$","i")),n||this._monthsParse[a]||(i="^"+this.months(r,"")+"|^"+this.monthsShort(r,""),this._monthsParse[a]=new RegExp(i.replace(".",""),"i")),n&&"MMMM"===t&&this._longMonthsParse[a].test(e))return a;if(n&&"MMM"===t&&this._shortMonthsParse[a].test(e))return a;if(!n&&this._monthsParse[a].test(e))return a}}function ce(e,t){var n;if(!e.isValid())return e;if("string"==typeof t)if(/^\d+$/.test(t))t=b(t);else if(t=e.localeData().monthsParse(t),!d(t))return e;return n=Math.min(e.date(),oe(e.year(),t)),e._d["set"+(e._isUTC?"UTC":"")+"Month"](t,n),e}function he(e){return null!=e?(ce(this,e),t.updateOffset(this,!0),this):V(this,"Month")}function _e(){return oe(this.year(),this.month())}function me(e){return this._monthsParseExact?(c(this,"_monthsRegex")||pe.call(this),e?this._monthsShortStrictRegex:this._monthsShortRegex):(c(this,"_monthsShortRegex")||(this._monthsShortRegex=Mr),this._monthsShortStrictRegex&&e?this._monthsShortStrictRegex:this._monthsShortRegex)}function fe(e){return this._monthsParseExact?(c(this,"_monthsRegex")||pe.call(this),e?this._monthsStrictRegex:this._monthsRegex):(c(this,"_monthsRegex")||(this._monthsRegex=Lr),this._monthsStrictRegex&&e?this._monthsStrictRegex:this._monthsRegex)}function pe(){function e(e,t){return t.length-e.length}var t,n,a=[],r=[],i=[];for(t=0;t<12;t++)n=_([2e3,t]),a.push(this.monthsShort(n,"")),r.push(this.months(n,"")),i.push(this.months(n,"")),i.push(this.monthsShort(n,""));for(a.sort(e),r.sort(e),i.sort(e),t=0;t<12;t++)a[t]=ne(a[t]),r[t]=ne(r[t]);for(t=0;t<24;t++)i[t]=ne(i[t]);this._monthsRegex=new RegExp("^("+i.join("|")+")","i"),this._monthsShortRegex=this._monthsRegex,this._monthsStrictRegex=new RegExp("^("+r.join("|")+")","i"),this._monthsShortStrictRegex=new RegExp("^("+a.join("|")+")","i")}function ye(e){return ge(e)?366:365}function ge(e){return e%4===0&&e%100!==0||e%400===0}function ve(){return ge(this.year())}function Me(e,t,n,a,r,i,o){var s=new Date(e,t,n,a,r,i,o);return e<100&&e>=0&&isFinite(s.getFullYear())&&s.setFullYear(e),s}function Le(e){var t=new Date(Date.UTC.apply(null,arguments));return e<100&&e>=0&&isFinite(t.getUTCFullYear())&&t.setUTCFullYear(e),t}function be(e,t,n){var a=7+t-n,r=(7+Le(e,0,a).getUTCDay()-t)%7;return-r+a-1}function ke(e,t,n,a,r){var i,o,s=(7+n-a)%7,d=be(e,a,r),u=1+7*(t-1)+s+d;return u<=0?(i=e-1,o=ye(i)+u):u>ye(e)?(i=e+1,o=u-ye(e)):(i=e,o=u),{year:i,dayOfYear:o}}function Ye(e,t,n){var a,r,i=be(e.year(),t,n),o=Math.floor((e.dayOfYear()-i-1)/7)+1;return o<1?(r=e.year()-1,a=o+De(r,t,n)):o>De(e.year(),t,n)?(a=o-De(e.year(),t,n),r=e.year()+1):(r=e.year(),a=o),{week:a,year:r}}function De(e,t,n){var a=be(e,t,n),r=be(e+1,t,n);return(ye(e)-a+r)/7}function we(e){return Ye(e,this._week.dow,this._week.doy).week}function xe(){return this._week.dow}function Te(){return this._week.doy}function Se(e){var t=this.localeData().week(this);return null==e?t:this.add(7*(e-t),"d")}function je(e){var t=Ye(this,1,4).week;return null==e?t:this.add(7*(e-t),"d")}function He(e,t){return"string"!=typeof e?e:isNaN(e)?(e=t.weekdaysParse(e),"number"==typeof e?e:null):parseInt(e,10)}function Oe(e,t){return"string"==typeof e?t.weekdaysParse(e)%7||7:isNaN(e)?null:e}function Pe(e,t){return e?r(this._weekdays)?this._weekdays[e.day()]:this._weekdays[this._weekdays.isFormat.test(t)?"format":"standalone"][e.day()]:r(this._weekdays)?this._weekdays:this._weekdays.standalone}function Ae(e){return e?this._weekdaysShort[e.day()]:this._weekdaysShort}function Ce(e){return e?this._weekdaysMin[e.day()]:this._weekdaysMin}function Ee(e,t,n){var a,r,i,o=e.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],a=0;a<7;++a)i=_([2e3,1]).day(a),this._minWeekdaysParse[a]=this.weekdaysMin(i,"").toLocaleLowerCase(),this._shortWeekdaysParse[a]=this.weekdaysShort(i,"").toLocaleLowerCase(),this._weekdaysParse[a]=this.weekdays(i,"").toLocaleLowerCase();return n?"dddd"===t?(r=pr.call(this._weekdaysParse,o),r!==-1?r:null):"ddd"===t?(r=pr.call(this._shortWeekdaysParse,o),r!==-1?r:null):(r=pr.call(this._minWeekdaysParse,o),r!==-1?r:null):"dddd"===t?(r=pr.call(this._weekdaysParse,o),r!==-1?r:(r=pr.call(this._shortWeekdaysParse,o),r!==-1?r:(r=pr.call(this._minWeekdaysParse,o),r!==-1?r:null))):"ddd"===t?(r=pr.call(this._shortWeekdaysParse,o),r!==-1?r:(r=pr.call(this._weekdaysParse,o),r!==-1?r:(r=pr.call(this._minWeekdaysParse,o),r!==-1?r:null))):(r=pr.call(this._minWeekdaysParse,o),r!==-1?r:(r=pr.call(this._weekdaysParse,o),r!==-1?r:(r=pr.call(this._shortWeekdaysParse,o),r!==-1?r:null)))}function Fe(e,t,n){var a,r,i;if(this._weekdaysParseExact)return Ee.call(this,e,t,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),a=0;a<7;a++){if(r=_([2e3,1]).day(a),n&&!this._fullWeekdaysParse[a]&&(this._fullWeekdaysParse[a]=new RegExp("^"+this.weekdays(r,"").replace(".",".?")+"$","i"),this._shortWeekdaysParse[a]=new RegExp("^"+this.weekdaysShort(r,"").replace(".",".?")+"$","i"),this._minWeekdaysParse[a]=new RegExp("^"+this.weekdaysMin(r,"").replace(".",".?")+"$","i")),this._weekdaysParse[a]||(i="^"+this.weekdays(r,"")+"|^"+this.weekdaysShort(r,"")+"|^"+this.weekdaysMin(r,""),this._weekdaysParse[a]=new RegExp(i.replace(".",""),"i")),n&&"dddd"===t&&this._fullWeekdaysParse[a].test(e))return a;if(n&&"ddd"===t&&this._shortWeekdaysParse[a].test(e))return a;if(n&&"dd"===t&&this._minWeekdaysParse[a].test(e))return a;if(!n&&this._weekdaysParse[a].test(e))return a}}function We(e){if(!this.isValid())return null!=e?this:NaN;var t=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=e?(e=He(e,this.localeData()),this.add(e-t,"d")):t}function Ie(e){if(!this.isValid())return null!=e?this:NaN;var t=(this.day()+7-this.localeData()._week.dow)%7;return null==e?t:this.add(e-t,"d")}function Ne(e){if(!this.isValid())return null!=e?this:NaN;if(null!=e){var t=Oe(e,this.localeData());return this.day(this.day()%7?t:t-7)}return this.day()||7}function ze(e){return this._weekdaysParseExact?(c(this,"_weekdaysRegex")||Be.call(this),e?this._weekdaysStrictRegex:this._weekdaysRegex):(c(this,"_weekdaysRegex")||(this._weekdaysRegex=xr),this._weekdaysStrictRegex&&e?this._weekdaysStrictRegex:this._weekdaysRegex)}function Re(e){return this._weekdaysParseExact?(c(this,"_weekdaysRegex")||Be.call(this),e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(c(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=Tr),this._weekdaysShortStrictRegex&&e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)}function Ve(e){return this._weekdaysParseExact?(c(this,"_weekdaysRegex")||Be.call(this),e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(c(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=Sr),this._weekdaysMinStrictRegex&&e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)}function Be(){function e(e,t){return t.length-e.length}var t,n,a,r,i,o=[],s=[],d=[],u=[];for(t=0;t<7;t++)n=_([2e3,1]).day(t),a=this.weekdaysMin(n,""),r=this.weekdaysShort(n,""),i=this.weekdays(n,""),o.push(a),s.push(r),d.push(i),u.push(a),u.push(r),u.push(i);for(o.sort(e),s.sort(e),d.sort(e),u.sort(e),t=0;t<7;t++)s[t]=ne(s[t]),d[t]=ne(d[t]),u[t]=ne(u[t]);this._weekdaysRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+d.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+s.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+o.join("|")+")","i")}function $e(){return this.hours()%12||12}function Je(){return this.hours()||24}function Ue(e,t){G(e,0,0,function(){return this.localeData().meridiem(this.hours(),this.minutes(),t)})}function Ge(e,t){return t._meridiemParse}function qe(e){return"p"===(e+"").toLowerCase().charAt(0)}function Ke(e,t,n){return e>11?n?"pm":"PM":n?"am":"AM"}function Ze(e){return e?e.toLowerCase().replace("_","-"):e}function Qe(e){for(var t,n,a,r,i=0;i<e.length;){for(r=Ze(e[i]).split("-"),t=r.length,n=Ze(e[i+1]),n=n?n.split("-"):null;t>0;){if(a=Xe(r.slice(0,t).join("-")))return a;if(n&&n.length>=t&&k(r,n,!0)>=t-1)break;t--}i++}return null}function Xe(t){var a=null;if(!Ar[t]&&"undefined"!=typeof e&&e&&e.exports)try{a=jr._abbr,n(227)("./"+t),et(a)}catch(e){}return Ar[t]}function et(e,t){var n;return e&&(n=s(t)?at(e):tt(e,t),n&&(jr=n)),jr._abbr}function tt(e,t){if(null!==t){var n=Pr;if(t.abbr=e,null!=Ar[e])w("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),n=Ar[e]._config;else if(null!=t.parentLocale){if(null==Ar[t.parentLocale])return Cr[t.parentLocale]||(Cr[t.parentLocale]=[]),Cr[t.parentLocale].push({name:e,config:t}),null;n=Ar[t.parentLocale]._config}return Ar[e]=new j(S(n,t)),Cr[e]&&Cr[e].forEach(function(e){tt(e.name,e.config)}),et(e),Ar[e]}return delete Ar[e],null}function nt(e,t){if(null!=t){var n,a=Pr;null!=Ar[e]&&(a=Ar[e]._config),t=S(a,t),n=new j(t),n.parentLocale=Ar[e],Ar[e]=n,et(e)}else null!=Ar[e]&&(null!=Ar[e].parentLocale?Ar[e]=Ar[e].parentLocale:null!=Ar[e]&&delete Ar[e]);return Ar[e]}function at(e){var t;if(e&&e._locale&&e._locale._abbr&&(e=e._locale._abbr),!e)return jr;if(!r(e)){if(t=Xe(e))return t;e=[e]}return Qe(e)}function rt(){return Sa(Ar)}function it(e){var t,n=e._a;return n&&f(e).overflow===-2&&(t=n[dr]<0||n[dr]>11?dr:n[ur]<1||n[ur]>oe(n[sr],n[dr])?ur:n[lr]<0||n[lr]>24||24===n[lr]&&(0!==n[cr]||0!==n[hr]||0!==n[_r])?lr:n[cr]<0||n[cr]>59?cr:n[hr]<0||n[hr]>59?hr:n[_r]<0||n[_r]>999?_r:-1,f(e)._overflowDayOfYear&&(t<sr||t>ur)&&(t=ur),f(e)._overflowWeeks&&t===-1&&(t=mr),f(e)._overflowWeekday&&t===-1&&(t=fr),f(e).overflow=t),e}function ot(e){var t,n,a,r,i,o,s=e._i,d=Er.exec(s)||Fr.exec(s);if(d){for(f(e).iso=!0,t=0,n=Ir.length;t<n;t++)if(Ir[t][1].exec(d[1])){r=Ir[t][0],a=Ir[t][2]!==!1;break}if(null==r)return void(e._isValid=!1);if(d[3]){for(t=0,n=Nr.length;t<n;t++)if(Nr[t][1].exec(d[3])){i=(d[2]||" ")+Nr[t][0];break}if(null==i)return void(e._isValid=!1)}if(!a&&null!=i)return void(e._isValid=!1);if(d[4]){if(!Wr.exec(d[4]))return void(e._isValid=!1);o="Z"}e._f=r+(i||"")+(o||""),_t(e)}else e._isValid=!1}function st(e){var t,n,a,r,i,o,s,d,u={" GMT":" +0000"," EDT":" -0400"," EST":" -0500"," CDT":" -0500"," CST":" -0600"," MDT":" -0600"," MST":" -0700"," PDT":" -0700"," PST":" -0800"},l="YXWVUTSRQPONZABCDEFGHIKLM";if(t=e._i.replace(/\([^\)]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").replace(/^\s|\s$/g,""),n=Rr.exec(t)){if(a=n[1]?"ddd"+(5===n[1].length?", ":" "):"",r="D MMM "+(n[2].length>10?"YYYY ":"YY "),i="HH:mm"+(n[4]?":ss":""),n[1]){var c=new Date(n[2]),h=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"][c.getDay()];if(n[1].substr(0,3)!==h)return f(e).weekdayMismatch=!0,void(e._isValid=!1)}switch(n[5].length){case 2:0===d?s=" +0000":(d=l.indexOf(n[5][1].toUpperCase())-12,s=(d<0?" -":" +")+(""+d).replace(/^-?/,"0").match(/..$/)[0]+"00");break;case 4:s=u[n[5]];break;default:s=u[" GMT"]}n[5]=s,e._i=n.splice(1).join(""),o=" ZZ",e._f=a+r+i+o,_t(e),f(e).rfc2822=!0}else e._isValid=!1}function dt(e){var n=zr.exec(e._i);return null!==n?void(e._d=new Date(+n[1])):(ot(e),void(e._isValid===!1&&(delete e._isValid,st(e),e._isValid===!1&&(delete e._isValid,t.createFromInputFallback(e)))))}function ut(e,t,n){return null!=e?e:null!=t?t:n}function lt(e){var n=new Date(t.now());return e._useUTC?[n.getUTCFullYear(),n.getUTCMonth(),n.getUTCDate()]:[n.getFullYear(),n.getMonth(),n.getDate()]}function ct(e){var t,n,a,r,i=[];if(!e._d){for(a=lt(e),e._w&&null==e._a[ur]&&null==e._a[dr]&&ht(e),null!=e._dayOfYear&&(r=ut(e._a[sr],a[sr]),(e._dayOfYear>ye(r)||0===e._dayOfYear)&&(f(e)._overflowDayOfYear=!0),n=Le(r,0,e._dayOfYear),e._a[dr]=n.getUTCMonth(),e._a[ur]=n.getUTCDate()),t=0;t<3&&null==e._a[t];++t)e._a[t]=i[t]=a[t];for(;t<7;t++)e._a[t]=i[t]=null==e._a[t]?2===t?1:0:e._a[t];24===e._a[lr]&&0===e._a[cr]&&0===e._a[hr]&&0===e._a[_r]&&(e._nextDay=!0,e._a[lr]=0),e._d=(e._useUTC?Le:Me).apply(null,i),null!=e._tzm&&e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),e._nextDay&&(e._a[lr]=24)}}function ht(e){var t,n,a,r,i,o,s,d;if(t=e._w,null!=t.GG||null!=t.W||null!=t.E)i=1,o=4,n=ut(t.GG,e._a[sr],Ye(Lt(),1,4).year),a=ut(t.W,1),r=ut(t.E,1),(r<1||r>7)&&(d=!0);else{i=e._locale._week.dow,o=e._locale._week.doy;var u=Ye(Lt(),i,o);n=ut(t.gg,e._a[sr],u.year),a=ut(t.w,u.week),null!=t.d?(r=t.d,(r<0||r>6)&&(d=!0)):null!=t.e?(r=t.e+i,(t.e<0||t.e>6)&&(d=!0)):r=i}a<1||a>De(n,i,o)?f(e)._overflowWeeks=!0:null!=d?f(e)._overflowWeekday=!0:(s=ke(n,a,r,i,o),e._a[sr]=s.year,e._dayOfYear=s.dayOfYear)}function _t(e){if(e._f===t.ISO_8601)return void ot(e);if(e._f===t.RFC_2822)return void st(e);e._a=[],f(e).empty=!0;var n,a,r,i,o,s=""+e._i,d=s.length,u=0;for(r=Q(e._f,e._locale).match(Wa)||[],n=0;n<r.length;n++)i=r[n],a=(s.match(ee(i,e))||[])[0],a&&(o=s.substr(0,s.indexOf(a)),o.length>0&&f(e).unusedInput.push(o),s=s.slice(s.indexOf(a)+a.length),u+=a.length),za[i]?(a?f(e).empty=!1:f(e).unusedTokens.push(i),ie(i,a,e)):e._strict&&!a&&f(e).unusedTokens.push(i);f(e).charsLeftOver=d-u,s.length>0&&f(e).unusedInput.push(s),e._a[lr]<=12&&f(e).bigHour===!0&&e._a[lr]>0&&(f(e).bigHour=void 0),f(e).parsedDateParts=e._a.slice(0),f(e).meridiem=e._meridiem,e._a[lr]=mt(e._locale,e._a[lr],e._meridiem),ct(e),it(e)}function mt(e,t,n){var a;return null==n?t:null!=e.meridiemHour?e.meridiemHour(t,n):null!=e.isPM?(a=e.isPM(n),a&&t<12&&(t+=12),a||12!==t||(t=0),t):t}function ft(e){var t,n,a,r,i;if(0===e._f.length)return f(e).invalidFormat=!0,void(e._d=new Date(NaN));for(r=0;r<e._f.length;r++)i=0,t=g({},e),null!=e._useUTC&&(t._useUTC=e._useUTC),t._f=e._f[r],_t(t),p(t)&&(i+=f(t).charsLeftOver,i+=10*f(t).unusedTokens.length,f(t).score=i,(null==a||i<a)&&(a=i,n=t));h(e,n||t)}function pt(e){if(!e._d){var t=I(e._i);e._a=l([t.year,t.month,t.day||t.date,t.hour,t.minute,t.second,t.millisecond],function(e){return e&&parseInt(e,10)}),ct(e)}}function yt(e){var t=new v(it(gt(e)));return t._nextDay&&(t.add(1,"d"),t._nextDay=void 0),t}function gt(e){var t=e._i,n=e._f;return e._locale=e._locale||at(e._l),null===t||void 0===n&&""===t?y({nullInput:!0}):("string"==typeof t&&(e._i=t=e._locale.preparse(t)),M(t)?new v(it(t)):(u(t)?e._d=t:r(n)?ft(e):n?_t(e):vt(e),p(e)||(e._d=null),e))}function vt(e){var n=e._i;s(n)?e._d=new Date(t.now()):u(n)?e._d=new Date(n.valueOf()):"string"==typeof n?dt(e):r(n)?(e._a=l(n.slice(0),function(e){return parseInt(e,10)}),ct(e)):i(n)?pt(e):d(n)?e._d=new Date(n):t.createFromInputFallback(e)}function Mt(e,t,n,a,s){var d={};return n!==!0&&n!==!1||(a=n,n=void 0),(i(e)&&o(e)||r(e)&&0===e.length)&&(e=void 0),d._isAMomentObject=!0,d._useUTC=d._isUTC=s,d._l=n,d._i=e,d._f=t,d._strict=a,yt(d)}function Lt(e,t,n,a){return Mt(e,t,n,a,!1)}function bt(e,t){var n,a;if(1===t.length&&r(t[0])&&(t=t[0]),!t.length)return Lt();for(n=t[0],a=1;a<t.length;++a)t[a].isValid()&&!t[a][e](n)||(n=t[a]);return n}function kt(){var e=[].slice.call(arguments,0);return bt("isBefore",e)}function Yt(){var e=[].slice.call(arguments,0);return bt("isAfter",e)}function Dt(e){for(var t in e)if(Jr.indexOf(t)===-1||null!=e[t]&&isNaN(e[t]))return!1;for(var n=!1,a=0;a<Jr.length;++a)if(e[Jr[a]]){if(n)return!1;parseFloat(e[Jr[a]])!==b(e[Jr[a]])&&(n=!0)}return!0}function wt(){return this._isValid}function xt(){return Jt(NaN)}function Tt(e){var t=I(e),n=t.year||0,a=t.quarter||0,r=t.month||0,i=t.week||0,o=t.day||0,s=t.hour||0,d=t.minute||0,u=t.second||0,l=t.millisecond||0;this._isValid=Dt(t),this._milliseconds=+l+1e3*u+6e4*d+1e3*s*60*60,this._days=+o+7*i,this._months=+r+3*a+12*n,this._data={},this._locale=at(),this._bubble()}function St(e){return e instanceof Tt}function jt(e){return e<0?Math.round(-1*e)*-1:Math.round(e)}function Ht(e,t){G(e,0,0,function(){var e=this.utcOffset(),n="+";return e<0&&(e=-e,n="-"),n+U(~~(e/60),2)+t+U(~~e%60,2)})}function Ot(e,t){var n=(t||"").match(e);if(null===n)return null;var a=n[n.length-1]||[],r=(a+"").match(Ur)||["-",0,0],i=+(60*r[1])+b(r[2]);return 0===i?0:"+"===r[0]?i:-i}function Pt(e,n){var a,r;return n._isUTC?(a=n.clone(),r=(M(e)||u(e)?e.valueOf():Lt(e).valueOf())-a.valueOf(),a._d.setTime(a._d.valueOf()+r),t.updateOffset(a,!1),a):Lt(e).local()}function At(e){return 15*-Math.round(e._d.getTimezoneOffset()/15)}function Ct(e,n,a){var r,i=this._offset||0;if(!this.isValid())return null!=e?this:NaN;if(null!=e){if("string"==typeof e){if(e=Ot(nr,e),null===e)return this}else Math.abs(e)<16&&!a&&(e*=60);return!this._isUTC&&n&&(r=At(this)),this._offset=e,this._isUTC=!0,null!=r&&this.add(r,"m"),i!==e&&(!n||this._changeInProgress?Zt(this,Jt(e-i,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,t.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?i:At(this)}function Et(e,t){return null!=e?("string"!=typeof e&&(e=-e),this.utcOffset(e,t),this):-this.utcOffset()}function Ft(e){return this.utcOffset(0,e)}function Wt(e){return this._isUTC&&(this.utcOffset(0,e),this._isUTC=!1,e&&this.subtract(At(this),"m")),this}function It(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var e=Ot(tr,this._i);null!=e?this.utcOffset(e):this.utcOffset(0,!0)}return this}function Nt(e){return!!this.isValid()&&(e=e?Lt(e).utcOffset():0,(this.utcOffset()-e)%60===0)}function zt(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()}function Rt(){if(!s(this._isDSTShifted))return this._isDSTShifted;var e={};if(g(e,this),e=gt(e),e._a){var t=e._isUTC?_(e._a):Lt(e._a);this._isDSTShifted=this.isValid()&&k(e._a,t.toArray())>0}else this._isDSTShifted=!1;return this._isDSTShifted}function Vt(){return!!this.isValid()&&!this._isUTC}function Bt(){return!!this.isValid()&&this._isUTC}function $t(){return!!this.isValid()&&(this._isUTC&&0===this._offset)}function Jt(e,t){var n,a,r,i=e,o=null;return St(e)?i={ms:e._milliseconds,d:e._days,M:e._months}:d(e)?(i={},t?i[t]=e:i.milliseconds=e):(o=Gr.exec(e))?(n="-"===o[1]?-1:1,i={y:0,d:b(o[ur])*n,h:b(o[lr])*n,m:b(o[cr])*n,s:b(o[hr])*n,ms:b(jt(1e3*o[_r]))*n}):(o=qr.exec(e))?(n="-"===o[1]?-1:1,i={y:Ut(o[2],n),M:Ut(o[3],n),w:Ut(o[4],n),d:Ut(o[5],n),h:Ut(o[6],n),m:Ut(o[7],n),s:Ut(o[8],n)}):null==i?i={}:"object"==typeof i&&("from"in i||"to"in i)&&(r=qt(Lt(i.from),Lt(i.to)),i={},i.ms=r.milliseconds,i.M=r.months),a=new Tt(i),St(e)&&c(e,"_locale")&&(a._locale=e._locale),a}function Ut(e,t){var n=e&&parseFloat(e.replace(",","."));return(isNaN(n)?0:n)*t}function Gt(e,t){var n={milliseconds:0,months:0};return n.months=t.month()-e.month()+12*(t.year()-e.year()),e.clone().add(n.months,"M").isAfter(t)&&--n.months,n.milliseconds=+t-+e.clone().add(n.months,"M"),n}function qt(e,t){var n;return e.isValid()&&t.isValid()?(t=Pt(t,e),e.isBefore(t)?n=Gt(e,t):(n=Gt(t,e),n.milliseconds=-n.milliseconds,n.months=-n.months),n):{milliseconds:0,months:0}}function Kt(e,t){return function(n,a){var r,i;return null===a||isNaN(+a)||(w(t,"moment()."+t+"(period, number) is deprecated. Please use moment()."+t+"(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."),i=n,n=a,a=i),n="string"==typeof n?+n:n,r=Jt(n,a),Zt(this,r,e),this}}function Zt(e,n,a,r){var i=n._milliseconds,o=jt(n._days),s=jt(n._months);e.isValid()&&(r=null==r||r,i&&e._d.setTime(e._d.valueOf()+i*a),o&&B(e,"Date",V(e,"Date")+o*a),s&&ce(e,V(e,"Month")+s*a),r&&t.updateOffset(e,o||s))}function Qt(e,t){var n=e.diff(t,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"}function Xt(e,n){var a=e||Lt(),r=Pt(a,this).startOf("day"),i=t.calendarFormat(this,r)||"sameElse",o=n&&(x(n[i])?n[i].call(this,a):n[i]);return this.format(o||this.localeData().calendar(i,this,Lt(a)))}function en(){return new v(this)}function tn(e,t){var n=M(e)?e:Lt(e);return!(!this.isValid()||!n.isValid())&&(t=W(s(t)?"millisecond":t),"millisecond"===t?this.valueOf()>n.valueOf():n.valueOf()<this.clone().startOf(t).valueOf())}function nn(e,t){var n=M(e)?e:Lt(e);return!(!this.isValid()||!n.isValid())&&(t=W(s(t)?"millisecond":t),"millisecond"===t?this.valueOf()<n.valueOf():this.clone().endOf(t).valueOf()<n.valueOf())}function an(e,t,n,a){return a=a||"()",("("===a[0]?this.isAfter(e,n):!this.isBefore(e,n))&&(")"===a[1]?this.isBefore(t,n):!this.isAfter(t,n))}function rn(e,t){var n,a=M(e)?e:Lt(e);return!(!this.isValid()||!a.isValid())&&(t=W(t||"millisecond"),"millisecond"===t?this.valueOf()===a.valueOf():(n=a.valueOf(),this.clone().startOf(t).valueOf()<=n&&n<=this.clone().endOf(t).valueOf()))}function on(e,t){return this.isSame(e,t)||this.isAfter(e,t)}function sn(e,t){return this.isSame(e,t)||this.isBefore(e,t)}function dn(e,t,n){var a,r,i,o;return this.isValid()?(a=Pt(e,this),a.isValid()?(r=6e4*(a.utcOffset()-this.utcOffset()),t=W(t),"year"===t||"month"===t||"quarter"===t?(o=un(this,a),"quarter"===t?o/=3:"year"===t&&(o/=12)):(i=this-a,o="second"===t?i/1e3:"minute"===t?i/6e4:"hour"===t?i/36e5:"day"===t?(i-r)/864e5:"week"===t?(i-r)/6048e5:i),n?o:L(o)):NaN):NaN}function un(e,t){var n,a,r=12*(t.year()-e.year())+(t.month()-e.month()),i=e.clone().add(r,"months");return t-i<0?(n=e.clone().add(r-1,"months"),a=(t-i)/(i-n)):(n=e.clone().add(r+1,"months"),a=(t-i)/(n-i)),-(r+a)||0}function ln(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")}function cn(){if(!this.isValid())return null;var e=this.clone().utc();return e.year()<0||e.year()>9999?Z(e,"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]"):x(Date.prototype.toISOString)?this.toDate().toISOString():Z(e,"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]")}function hn(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var e="moment",t="";this.isLocal()||(e=0===this.utcOffset()?"moment.utc":"moment.parseZone",t="Z");var n="["+e+'("]',a=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",r="-MM-DD[T]HH:mm:ss.SSS",i=t+'[")]';return this.format(n+a+r+i)}function _n(e){e||(e=this.isUtc()?t.defaultFormatUtc:t.defaultFormat);var n=Z(this,e);return this.localeData().postformat(n)}function mn(e,t){return this.isValid()&&(M(e)&&e.isValid()||Lt(e).isValid())?Jt({to:this,from:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function fn(e){return this.from(Lt(),e)}function pn(e,t){return this.isValid()&&(M(e)&&e.isValid()||Lt(e).isValid())?Jt({from:this,to:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function yn(e){return this.to(Lt(),e)}function gn(e){
+var t;return void 0===e?this._locale._abbr:(t=at(e),null!=t&&(this._locale=t),this)}function vn(){return this._locale}function Mn(e){switch(e=W(e)){case"year":this.month(0);case"quarter":case"month":this.date(1);case"week":case"isoWeek":case"day":case"date":this.hours(0);case"hour":this.minutes(0);case"minute":this.seconds(0);case"second":this.milliseconds(0)}return"week"===e&&this.weekday(0),"isoWeek"===e&&this.isoWeekday(1),"quarter"===e&&this.month(3*Math.floor(this.month()/3)),this}function Ln(e){return e=W(e),void 0===e||"millisecond"===e?this:("date"===e&&(e="day"),this.startOf(e).add(1,"isoWeek"===e?"week":e).subtract(1,"ms"))}function bn(){return this._d.valueOf()-6e4*(this._offset||0)}function kn(){return Math.floor(this.valueOf()/1e3)}function Yn(){return new Date(this.valueOf())}function Dn(){var e=this;return[e.year(),e.month(),e.date(),e.hour(),e.minute(),e.second(),e.millisecond()]}function wn(){var e=this;return{years:e.year(),months:e.month(),date:e.date(),hours:e.hours(),minutes:e.minutes(),seconds:e.seconds(),milliseconds:e.milliseconds()}}function xn(){return this.isValid()?this.toISOString():null}function Tn(){return p(this)}function Sn(){return h({},f(this))}function jn(){return f(this).overflow}function Hn(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}}function On(e,t){G(0,[e,e.length],0,t)}function Pn(e){return Fn.call(this,e,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)}function An(e){return Fn.call(this,e,this.isoWeek(),this.isoWeekday(),1,4)}function Cn(){return De(this.year(),1,4)}function En(){var e=this.localeData()._week;return De(this.year(),e.dow,e.doy)}function Fn(e,t,n,a,r){var i;return null==e?Ye(this,a,r).year:(i=De(e,a,r),t>i&&(t=i),Wn.call(this,e,t,n,a,r))}function Wn(e,t,n,a,r){var i=ke(e,t,n,a,r),o=Le(i.year,0,i.dayOfYear);return this.year(o.getUTCFullYear()),this.month(o.getUTCMonth()),this.date(o.getUTCDate()),this}function In(e){return null==e?Math.ceil((this.month()+1)/3):this.month(3*(e-1)+this.month()%3)}function Nn(e){var t=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"d")}function zn(e,t){t[_r]=b(1e3*("0."+e))}function Rn(){return this._isUTC?"UTC":""}function Vn(){return this._isUTC?"Coordinated Universal Time":""}function Bn(e){return Lt(1e3*e)}function $n(){return Lt.apply(null,arguments).parseZone()}function Jn(e){return e}function Un(e,t,n,a){var r=at(),i=_().set(a,t);return r[n](i,e)}function Gn(e,t,n){if(d(e)&&(t=e,e=void 0),e=e||"",null!=t)return Un(e,t,n,"month");var a,r=[];for(a=0;a<12;a++)r[a]=Un(e,a,n,"month");return r}function qn(e,t,n,a){"boolean"==typeof e?(d(t)&&(n=t,t=void 0),t=t||""):(t=e,n=t,e=!1,d(t)&&(n=t,t=void 0),t=t||"");var r=at(),i=e?r._week.dow:0;if(null!=n)return Un(t,(n+i)%7,a,"day");var o,s=[];for(o=0;o<7;o++)s[o]=Un(t,(o+i)%7,a,"day");return s}function Kn(e,t){return Gn(e,t,"months")}function Zn(e,t){return Gn(e,t,"monthsShort")}function Qn(e,t,n){return qn(e,t,n,"weekdays")}function Xn(e,t,n){return qn(e,t,n,"weekdaysShort")}function ea(e,t,n){return qn(e,t,n,"weekdaysMin")}function ta(){var e=this._data;return this._milliseconds=oi(this._milliseconds),this._days=oi(this._days),this._months=oi(this._months),e.milliseconds=oi(e.milliseconds),e.seconds=oi(e.seconds),e.minutes=oi(e.minutes),e.hours=oi(e.hours),e.months=oi(e.months),e.years=oi(e.years),this}function na(e,t,n,a){var r=Jt(t,n);return e._milliseconds+=a*r._milliseconds,e._days+=a*r._days,e._months+=a*r._months,e._bubble()}function aa(e,t){return na(this,e,t,1)}function ra(e,t){return na(this,e,t,-1)}function ia(e){return e<0?Math.floor(e):Math.ceil(e)}function oa(){var e,t,n,a,r,i=this._milliseconds,o=this._days,s=this._months,d=this._data;return i>=0&&o>=0&&s>=0||i<=0&&o<=0&&s<=0||(i+=864e5*ia(da(s)+o),o=0,s=0),d.milliseconds=i%1e3,e=L(i/1e3),d.seconds=e%60,t=L(e/60),d.minutes=t%60,n=L(t/60),d.hours=n%24,o+=L(n/24),r=L(sa(o)),s+=r,o-=ia(da(r)),a=L(s/12),s%=12,d.days=o,d.months=s,d.years=a,this}function sa(e){return 4800*e/146097}function da(e){return 146097*e/4800}function ua(e){if(!this.isValid())return NaN;var t,n,a=this._milliseconds;if(e=W(e),"month"===e||"year"===e)return t=this._days+a/864e5,n=this._months+sa(t),"month"===e?n:n/12;switch(t=this._days+Math.round(da(this._months)),e){case"week":return t/7+a/6048e5;case"day":return t+a/864e5;case"hour":return 24*t+a/36e5;case"minute":return 1440*t+a/6e4;case"second":return 86400*t+a/1e3;case"millisecond":return Math.floor(864e5*t)+a;default:throw new Error("Unknown unit "+e)}}function la(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*b(this._months/12):NaN}function ca(e){return function(){return this.as(e)}}function ha(e){return e=W(e),this.isValid()?this[e+"s"]():NaN}function _a(e){return function(){return this.isValid()?this._data[e]:NaN}}function ma(){return L(this.days()/7)}function fa(e,t,n,a,r){return r.relativeTime(t||1,!!n,e,a)}function pa(e,t,n){var a=Jt(e).abs(),r=bi(a.as("s")),i=bi(a.as("m")),o=bi(a.as("h")),s=bi(a.as("d")),d=bi(a.as("M")),u=bi(a.as("y")),l=r<=ki.ss&&["s",r]||r<ki.s&&["ss",r]||i<=1&&["m"]||i<ki.m&&["mm",i]||o<=1&&["h"]||o<ki.h&&["hh",o]||s<=1&&["d"]||s<ki.d&&["dd",s]||d<=1&&["M"]||d<ki.M&&["MM",d]||u<=1&&["y"]||["yy",u];return l[2]=t,l[3]=+e>0,l[4]=n,fa.apply(null,l)}function ya(e){return void 0===e?bi:"function"==typeof e&&(bi=e,!0)}function ga(e,t){return void 0!==ki[e]&&(void 0===t?ki[e]:(ki[e]=t,"s"===e&&(ki.ss=t-1),!0))}function va(e){if(!this.isValid())return this.localeData().invalidDate();var t=this.localeData(),n=pa(this,!e,t);return e&&(n=t.pastFuture(+this,n)),t.postformat(n)}function Ma(){if(!this.isValid())return this.localeData().invalidDate();var e,t,n,a=Yi(this._milliseconds)/1e3,r=Yi(this._days),i=Yi(this._months);e=L(a/60),t=L(e/60),a%=60,e%=60,n=L(i/12),i%=12;var o=n,s=i,d=r,u=t,l=e,c=a,h=this.asSeconds();return h?(h<0?"-":"")+"P"+(o?o+"Y":"")+(s?s+"M":"")+(d?d+"D":"")+(u||l||c?"T":"")+(u?u+"H":"")+(l?l+"M":"")+(c?c+"S":""):"P0D"}var La,ba;ba=Array.prototype.some?Array.prototype.some:function(e){for(var t=Object(this),n=t.length>>>0,a=0;a<n;a++)if(a in t&&e.call(this,t[a],a,t))return!0;return!1};var ka=ba,Ya=t.momentProperties=[],Da=!1,wa={};t.suppressDeprecationWarnings=!1,t.deprecationHandler=null;var xa;xa=Object.keys?Object.keys:function(e){var t,n=[];for(t in e)c(e,t)&&n.push(t);return n};var Ta,Sa=xa,ja={sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},Ha={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},Oa="Invalid date",Pa="%d",Aa=/\d{1,2}/,Ca={future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},Ea={},Fa={},Wa=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,Ia=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,Na={},za={},Ra=/\d/,Va=/\d\d/,Ba=/\d{3}/,$a=/\d{4}/,Ja=/[+-]?\d{6}/,Ua=/\d\d?/,Ga=/\d\d\d\d?/,qa=/\d\d\d\d\d\d?/,Ka=/\d{1,3}/,Za=/\d{1,4}/,Qa=/[+-]?\d{1,6}/,Xa=/\d+/,er=/[+-]?\d+/,tr=/Z|[+-]\d\d:?\d\d/gi,nr=/Z|[+-]\d\d(?::?\d\d)?/gi,ar=/[+-]?\d+(\.\d{1,3})?/,rr=/[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i,ir={},or={},sr=0,dr=1,ur=2,lr=3,cr=4,hr=5,_r=6,mr=7,fr=8;Ta=Array.prototype.indexOf?Array.prototype.indexOf:function(e){var t;for(t=0;t<this.length;++t)if(this[t]===e)return t;return-1};var pr=Ta;G("M",["MM",2],"Mo",function(){return this.month()+1}),G("MMM",0,0,function(e){return this.localeData().monthsShort(this,e)}),G("MMMM",0,0,function(e){return this.localeData().months(this,e)}),F("month","M"),N("month",8),X("M",Ua),X("MM",Ua,Va),X("MMM",function(e,t){return t.monthsShortRegex(e)}),X("MMMM",function(e,t){return t.monthsRegex(e)}),ae(["M","MM"],function(e,t){t[dr]=b(e)-1}),ae(["MMM","MMMM"],function(e,t,n,a){var r=n._locale.monthsParse(e,a,n._strict);null!=r?t[dr]=r:f(n).invalidMonth=e});var yr=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,gr="January_February_March_April_May_June_July_August_September_October_November_December".split("_"),vr="Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),Mr=rr,Lr=rr;G("Y",0,0,function(){var e=this.year();return e<=9999?""+e:"+"+e}),G(0,["YY",2],0,function(){return this.year()%100}),G(0,["YYYY",4],0,"year"),G(0,["YYYYY",5],0,"year"),G(0,["YYYYYY",6,!0],0,"year"),F("year","y"),N("year",1),X("Y",er),X("YY",Ua,Va),X("YYYY",Za,$a),X("YYYYY",Qa,Ja),X("YYYYYY",Qa,Ja),ae(["YYYYY","YYYYYY"],sr),ae("YYYY",function(e,n){n[sr]=2===e.length?t.parseTwoDigitYear(e):b(e)}),ae("YY",function(e,n){n[sr]=t.parseTwoDigitYear(e)}),ae("Y",function(e,t){t[sr]=parseInt(e,10)}),t.parseTwoDigitYear=function(e){return b(e)+(b(e)>68?1900:2e3)};var br=R("FullYear",!0);G("w",["ww",2],"wo","week"),G("W",["WW",2],"Wo","isoWeek"),F("week","w"),F("isoWeek","W"),N("week",5),N("isoWeek",5),X("w",Ua),X("ww",Ua,Va),X("W",Ua),X("WW",Ua,Va),re(["w","ww","W","WW"],function(e,t,n,a){t[a.substr(0,1)]=b(e)});var kr={dow:0,doy:6};G("d",0,"do","day"),G("dd",0,0,function(e){return this.localeData().weekdaysMin(this,e)}),G("ddd",0,0,function(e){return this.localeData().weekdaysShort(this,e)}),G("dddd",0,0,function(e){return this.localeData().weekdays(this,e)}),G("e",0,0,"weekday"),G("E",0,0,"isoWeekday"),F("day","d"),F("weekday","e"),F("isoWeekday","E"),N("day",11),N("weekday",11),N("isoWeekday",11),X("d",Ua),X("e",Ua),X("E",Ua),X("dd",function(e,t){return t.weekdaysMinRegex(e)}),X("ddd",function(e,t){return t.weekdaysShortRegex(e)}),X("dddd",function(e,t){return t.weekdaysRegex(e)}),re(["dd","ddd","dddd"],function(e,t,n,a){var r=n._locale.weekdaysParse(e,a,n._strict);null!=r?t.d=r:f(n).invalidWeekday=e}),re(["d","e","E"],function(e,t,n,a){t[a]=b(e)});var Yr="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),Dr="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),wr="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),xr=rr,Tr=rr,Sr=rr;G("H",["HH",2],0,"hour"),G("h",["hh",2],0,$e),G("k",["kk",2],0,Je),G("hmm",0,0,function(){return""+$e.apply(this)+U(this.minutes(),2)}),G("hmmss",0,0,function(){return""+$e.apply(this)+U(this.minutes(),2)+U(this.seconds(),2)}),G("Hmm",0,0,function(){return""+this.hours()+U(this.minutes(),2)}),G("Hmmss",0,0,function(){return""+this.hours()+U(this.minutes(),2)+U(this.seconds(),2)}),Ue("a",!0),Ue("A",!1),F("hour","h"),N("hour",13),X("a",Ge),X("A",Ge),X("H",Ua),X("h",Ua),X("k",Ua),X("HH",Ua,Va),X("hh",Ua,Va),X("kk",Ua,Va),X("hmm",Ga),X("hmmss",qa),X("Hmm",Ga),X("Hmmss",qa),ae(["H","HH"],lr),ae(["k","kk"],function(e,t,n){var a=b(e);t[lr]=24===a?0:a}),ae(["a","A"],function(e,t,n){n._isPm=n._locale.isPM(e),n._meridiem=e}),ae(["h","hh"],function(e,t,n){t[lr]=b(e),f(n).bigHour=!0}),ae("hmm",function(e,t,n){var a=e.length-2;t[lr]=b(e.substr(0,a)),t[cr]=b(e.substr(a)),f(n).bigHour=!0}),ae("hmmss",function(e,t,n){var a=e.length-4,r=e.length-2;t[lr]=b(e.substr(0,a)),t[cr]=b(e.substr(a,2)),t[hr]=b(e.substr(r)),f(n).bigHour=!0}),ae("Hmm",function(e,t,n){var a=e.length-2;t[lr]=b(e.substr(0,a)),t[cr]=b(e.substr(a))}),ae("Hmmss",function(e,t,n){var a=e.length-4,r=e.length-2;t[lr]=b(e.substr(0,a)),t[cr]=b(e.substr(a,2)),t[hr]=b(e.substr(r))});var jr,Hr=/[ap]\.?m?\.?/i,Or=R("Hours",!0),Pr={calendar:ja,longDateFormat:Ha,invalidDate:Oa,ordinal:Pa,dayOfMonthOrdinalParse:Aa,relativeTime:Ca,months:gr,monthsShort:vr,week:kr,weekdays:Yr,weekdaysMin:wr,weekdaysShort:Dr,meridiemParse:Hr},Ar={},Cr={},Er=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Fr=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Wr=/Z|[+-]\d\d(?::?\d\d)?/,Ir=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/]],Nr=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],zr=/^\/?Date\((\-?\d+)/i,Rr=/^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d?\d\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?:\d\d)?\d\d\s)(\d\d:\d\d)(\:\d\d)?(\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\d{4}))$/;t.createFromInputFallback=D("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged and will be removed in an upcoming major release. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",function(e){e._d=new Date(e._i+(e._useUTC?" UTC":""))}),t.ISO_8601=function(){},t.RFC_2822=function(){};var Vr=D("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",function(){var e=Lt.apply(null,arguments);return this.isValid()&&e.isValid()?e<this?this:e:y()}),Br=D("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",function(){var e=Lt.apply(null,arguments);return this.isValid()&&e.isValid()?e>this?this:e:y()}),$r=function(){return Date.now?Date.now():+new Date},Jr=["year","quarter","month","week","day","hour","minute","second","millisecond"];Ht("Z",":"),Ht("ZZ",""),X("Z",nr),X("ZZ",nr),ae(["Z","ZZ"],function(e,t,n){n._useUTC=!0,n._tzm=Ot(nr,e)});var Ur=/([\+\-]|\d\d)/gi;t.updateOffset=function(){};var Gr=/^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/,qr=/^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;Jt.fn=Tt.prototype,Jt.invalid=xt;var Kr=Kt(1,"add"),Zr=Kt(-1,"subtract");t.defaultFormat="YYYY-MM-DDTHH:mm:ssZ",t.defaultFormatUtc="YYYY-MM-DDTHH:mm:ss[Z]";var Qr=D("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",function(e){return void 0===e?this.localeData():this.locale(e)});G(0,["gg",2],0,function(){return this.weekYear()%100}),G(0,["GG",2],0,function(){return this.isoWeekYear()%100}),On("gggg","weekYear"),On("ggggg","weekYear"),On("GGGG","isoWeekYear"),On("GGGGG","isoWeekYear"),F("weekYear","gg"),F("isoWeekYear","GG"),N("weekYear",1),N("isoWeekYear",1),X("G",er),X("g",er),X("GG",Ua,Va),X("gg",Ua,Va),X("GGGG",Za,$a),X("gggg",Za,$a),X("GGGGG",Qa,Ja),X("ggggg",Qa,Ja),re(["gggg","ggggg","GGGG","GGGGG"],function(e,t,n,a){t[a.substr(0,2)]=b(e)}),re(["gg","GG"],function(e,n,a,r){n[r]=t.parseTwoDigitYear(e)}),G("Q",0,"Qo","quarter"),F("quarter","Q"),N("quarter",7),X("Q",Ra),ae("Q",function(e,t){t[dr]=3*(b(e)-1)}),G("D",["DD",2],"Do","date"),F("date","D"),N("date",9),X("D",Ua),X("DD",Ua,Va),X("Do",function(e,t){return e?t._dayOfMonthOrdinalParse||t._ordinalParse:t._dayOfMonthOrdinalParseLenient}),ae(["D","DD"],ur),ae("Do",function(e,t){t[ur]=b(e.match(Ua)[0],10)});var Xr=R("Date",!0);G("DDD",["DDDD",3],"DDDo","dayOfYear"),F("dayOfYear","DDD"),N("dayOfYear",4),X("DDD",Ka),X("DDDD",Ba),ae(["DDD","DDDD"],function(e,t,n){n._dayOfYear=b(e)}),G("m",["mm",2],0,"minute"),F("minute","m"),N("minute",14),X("m",Ua),X("mm",Ua,Va),ae(["m","mm"],cr);var ei=R("Minutes",!1);G("s",["ss",2],0,"second"),F("second","s"),N("second",15),X("s",Ua),X("ss",Ua,Va),ae(["s","ss"],hr);var ti=R("Seconds",!1);G("S",0,0,function(){return~~(this.millisecond()/100)}),G(0,["SS",2],0,function(){return~~(this.millisecond()/10)}),G(0,["SSS",3],0,"millisecond"),G(0,["SSSS",4],0,function(){return 10*this.millisecond()}),G(0,["SSSSS",5],0,function(){return 100*this.millisecond()}),G(0,["SSSSSS",6],0,function(){return 1e3*this.millisecond()}),G(0,["SSSSSSS",7],0,function(){return 1e4*this.millisecond()}),G(0,["SSSSSSSS",8],0,function(){return 1e5*this.millisecond()}),G(0,["SSSSSSSSS",9],0,function(){return 1e6*this.millisecond()}),F("millisecond","ms"),N("millisecond",16),X("S",Ka,Ra),X("SS",Ka,Va),X("SSS",Ka,Ba);var ni;for(ni="SSSS";ni.length<=9;ni+="S")X(ni,Xa);for(ni="S";ni.length<=9;ni+="S")ae(ni,zn);var ai=R("Milliseconds",!1);G("z",0,0,"zoneAbbr"),G("zz",0,0,"zoneName");var ri=v.prototype;ri.add=Kr,ri.calendar=Xt,ri.clone=en,ri.diff=dn,ri.endOf=Ln,ri.format=_n,ri.from=mn,ri.fromNow=fn,ri.to=pn,ri.toNow=yn,ri.get=$,ri.invalidAt=jn,ri.isAfter=tn,ri.isBefore=nn,ri.isBetween=an,ri.isSame=rn,ri.isSameOrAfter=on,ri.isSameOrBefore=sn,ri.isValid=Tn,ri.lang=Qr,ri.locale=gn,ri.localeData=vn,ri.max=Br,ri.min=Vr,ri.parsingFlags=Sn,ri.set=J,ri.startOf=Mn,ri.subtract=Zr,ri.toArray=Dn,ri.toObject=wn,ri.toDate=Yn,ri.toISOString=cn,ri.inspect=hn,ri.toJSON=xn,ri.toString=ln,ri.unix=kn,ri.valueOf=bn,ri.creationData=Hn,ri.year=br,ri.isLeapYear=ve,ri.weekYear=Pn,ri.isoWeekYear=An,ri.quarter=ri.quarters=In,ri.month=he,ri.daysInMonth=_e,ri.week=ri.weeks=Se,ri.isoWeek=ri.isoWeeks=je,ri.weeksInYear=En,ri.isoWeeksInYear=Cn,ri.date=Xr,ri.day=ri.days=We,ri.weekday=Ie,ri.isoWeekday=Ne,ri.dayOfYear=Nn,ri.hour=ri.hours=Or,ri.minute=ri.minutes=ei,ri.second=ri.seconds=ti,ri.millisecond=ri.milliseconds=ai,ri.utcOffset=Ct,ri.utc=Ft,ri.local=Wt,ri.parseZone=It,ri.hasAlignedHourOffset=Nt,ri.isDST=zt,ri.isLocal=Vt,ri.isUtcOffset=Bt,ri.isUtc=$t,ri.isUTC=$t,ri.zoneAbbr=Rn,ri.zoneName=Vn,ri.dates=D("dates accessor is deprecated. Use date instead.",Xr),ri.months=D("months accessor is deprecated. Use month instead",he),ri.years=D("years accessor is deprecated. Use year instead",br),ri.zone=D("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",Et),ri.isDSTShifted=D("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",Rt);var ii=j.prototype;ii.calendar=H,ii.longDateFormat=O,ii.invalidDate=P,ii.ordinal=A,ii.preparse=Jn,ii.postformat=Jn,ii.relativeTime=C,ii.pastFuture=E,ii.set=T,ii.months=se,ii.monthsShort=de,ii.monthsParse=le,ii.monthsRegex=fe,ii.monthsShortRegex=me,ii.week=we,ii.firstDayOfYear=Te,ii.firstDayOfWeek=xe,ii.weekdays=Pe,ii.weekdaysMin=Ce,ii.weekdaysShort=Ae,ii.weekdaysParse=Fe,ii.weekdaysRegex=ze,ii.weekdaysShortRegex=Re,ii.weekdaysMinRegex=Ve,ii.isPM=qe,ii.meridiem=Ke,et("en",{dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10,n=1===b(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n}}),t.lang=D("moment.lang is deprecated. Use moment.locale instead.",et),t.langData=D("moment.langData is deprecated. Use moment.localeData instead.",at);var oi=Math.abs,si=ca("ms"),di=ca("s"),ui=ca("m"),li=ca("h"),ci=ca("d"),hi=ca("w"),_i=ca("M"),mi=ca("y"),fi=_a("milliseconds"),pi=_a("seconds"),yi=_a("minutes"),gi=_a("hours"),vi=_a("days"),Mi=_a("months"),Li=_a("years"),bi=Math.round,ki={ss:44,s:45,m:45,h:22,d:26,M:11},Yi=Math.abs,Di=Tt.prototype;return Di.isValid=wt,Di.abs=ta,Di.add=aa,Di.subtract=ra,Di.as=ua,Di.asMilliseconds=si,Di.asSeconds=di,Di.asMinutes=ui,Di.asHours=li,Di.asDays=ci,Di.asWeeks=hi,Di.asMonths=_i,Di.asYears=mi,Di.valueOf=la,Di._bubble=oa,Di.get=ha,Di.milliseconds=fi,Di.seconds=pi,Di.minutes=yi,Di.hours=gi,Di.days=vi,Di.weeks=ma,Di.months=Mi,Di.years=Li,Di.humanize=va,Di.toISOString=Ma,Di.toString=Ma,Di.toJSON=Ma,Di.locale=gn,Di.localeData=vn,Di.toIsoString=D("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",Ma),Di.lang=Qr,G("X",0,0,"unix"),G("x",0,0,"valueOf"),X("x",er),X("X",ar),ae("X",function(e,t,n){n._d=new Date(1e3*parseFloat(e,10))}),ae("x",function(e,t,n){n._d=new Date(b(e))}),t.version="2.18.1",a(Lt),t.fn=ri,t.min=kt,t.max=Yt,t.now=$r,t.utc=_,t.unix=Bn,t.months=Kn,t.isDate=u,t.locale=et,t.invalid=y,t.duration=Jt,t.isMoment=M,t.weekdays=Qn,t.parseZone=$n,t.localeData=at,t.isDuration=St,t.monthsShort=Zn,t.weekdaysMin=ea,t.defineLocale=tt,t.updateLocale=nt,t.locales=rt,t.weekdaysShort=Xn,t.normalizeUnits=W,t.relativeTimeRounding=ya,t.relativeTimeThreshold=ga,t.calendarFormat=Qt,t.prototype=ri,t})}).call(t,n(139)(e))},function(e,t,n){"use strict";e.exports=n(10),e.exports.easing=n(181),e.exports.canvas=n(180),e.exports.options=n(182)},function(e,t,n){"use strict";var a=n(2);e.exports={_set:function(e,t){return a.merge(this[e]||(this[e]={}),t)}}},function(e,t,n){"use strict";function a(e,t,n,a){var i,o,s,d,u,l,c,h,_,m=Object.keys(n);for(i=0,o=m.length;i<o;++i)if(s=m[i],l=n[s],t.hasOwnProperty(s)||(t[s]=l),d=t[s],d!==l&&"_"!==s[0]){if(e.hasOwnProperty(s)||(e[s]=d),u=e[s],c=typeof l,c===typeof u)if("string"===c){if(h=r(u),h.valid&&(_=r(l),_.valid)){t[s]=_.mix(h,a).rgbString();continue}}else if("number"===c&&isFinite(u)&&isFinite(l)){t[s]=u+(l-u)*a;continue}t[s]=l}}var r=n(20),i=n(2),o=function(e){i.extend(this,e),this.initialize.apply(this,arguments)};i.extend(o.prototype,{initialize:function(){this.hidden=!1},pivot:function(){var e=this;return e._view||(e._view=i.clone(e._model)),e._start={},e},transition:function(e){var t=this,n=t._model,r=t._start,i=t._view;return n&&1!==e?(i||(i=t._view={}),r||(r=t._start={}),a(r,i,n,e),t):(t._view=n,t._start=null,t)},tooltipPosition:function(){return{x:this._model.x,y:this._model.y}},hasValue:function(){return i.isNumber(this._model.x)&&i.isNumber(this._model.y)}}),o.extend=i.inherits,e.exports=o},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}function r(e,t){return(0,o.default)(e,t)}Object.defineProperty(t,"__esModule",{value:!0}),t.mergeOptions=r;var i=n(226),o=a(i)},function(e,t,n){var a=n(170)();a.helpers=n(2),n(169)(a),a.defaults=n(3),a.Element=n(4),a.elements=n(8),a.Interaction=n(18),a.platform=n(19),n(172)(a),n(166)(a),n(167)(a),n(168)(a),n(171)(a),n(174)(a),n(173)(a),n(175)(a),n(190)(a),n(188)(a),n(189)(a),n(191)(a),n(192)(a),n(193)(a),n(159)(a),n(160)(a),n(161)(a),n(162)(a),n(163)(a),n(164)(a),n(165)(a),n(152)(a),n(153)(a),n(154)(a),n(155)(a),n(156)(a),n(157)(a),n(158)(a);var r=[];r.push(n(185)(a),n(186)(a),n(187)(a)),a.plugins.register(r),a.platform.initialize(),e.exports=a,"undefined"!=typeof window&&(window.Chart=a),a.canvasHelpers=a.helpers.canvas},function(e,t,n){(function(t,n){/*!
+	 * Vue.js v2.4.4
+	 * (c) 2014-2017 Evan You
+	 * Released under the MIT License.
+	 */
+"use strict";function a(e){return void 0===e||null===e}function r(e){return void 0!==e&&null!==e}function i(e){return e===!0}function o(e){return e===!1}function s(e){return"string"==typeof e||"number"==typeof e||"boolean"==typeof e}function d(e){return null!==e&&"object"==typeof e}function u(e){return"[object Object]"===ya.call(e)}function l(e){return"[object RegExp]"===ya.call(e)}function c(e){var t=parseFloat(e);return t>=0&&Math.floor(t)===t&&isFinite(e)}function h(e){return null==e?"":"object"==typeof e?JSON.stringify(e,null,2):String(e)}function _(e){var t=parseFloat(e);return isNaN(t)?e:t}function m(e,t){for(var n=Object.create(null),a=e.split(","),r=0;r<a.length;r++)n[a[r]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}function f(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}function p(e,t){return Ma.call(e,t)}function y(e){var t=Object.create(null);return function(n){var a=t[n];return a||(t[n]=e(n))}}function g(e,t){function n(n){var a=arguments.length;return a?a>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n}function v(e,t){t=t||0;for(var n=e.length-t,a=new Array(n);n--;)a[n]=e[n+t];return a}function M(e,t){for(var n in t)e[n]=t[n];return e}function L(e){for(var t={},n=0;n<e.length;n++)e[n]&&M(t,e[n]);return t}function b(e,t,n){}function k(e,t){if(e===t)return!0;var n=d(e),a=d(t);if(!n||!a)return!n&&!a&&String(e)===String(t);try{var r=Array.isArray(e),i=Array.isArray(t);if(r&&i)return e.length===t.length&&e.every(function(e,n){return k(e,t[n])});if(r||i)return!1;var o=Object.keys(e),s=Object.keys(t);return o.length===s.length&&o.every(function(n){return k(e[n],t[n])})}catch(e){return!1}}function Y(e,t){for(var n=0;n<e.length;n++)if(k(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}function w(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function x(e,t,n,a){Object.defineProperty(e,t,{value:n,enumerable:!!a,writable:!0,configurable:!0})}function T(e){if(!Pa.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}function S(e,n,a){if(Ha.errorHandler)Ha.errorHandler.call(null,e,n,a);else{if("production"!==t.env.NODE_ENV&&Aa("Error in "+a+': "'+e.toString()+'"',n),!Va||"undefined"==typeof console)throw e;console.error(e)}}function j(e){return"function"==typeof e&&/native code/.test(e.toString())}function H(e){sr.target&&dr.push(sr.target),sr.target=e}function O(){sr.target=dr.pop()}function P(e,t,n){e.__proto__=t}function A(e,t,n){for(var a=0,r=n.length;a<r;a++){var i=n[a];x(e,i,t[i])}}function C(e,t){if(d(e)){var n;return p(e,"__ob__")&&e.__ob__ instanceof _r?n=e.__ob__:hr.shouldConvert&&!nr()&&(Array.isArray(e)||u(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new _r(e)),t&&n&&n.vmCount++,n}}function E(e,n,a,r,i){var o=new sr,s=Object.getOwnPropertyDescriptor(e,n);if(!s||s.configurable!==!1){var d=s&&s.get,u=s&&s.set,l=!i&&C(a);Object.defineProperty(e,n,{enumerable:!0,configurable:!0,get:function(){var t=d?d.call(e):a;return sr.target&&(o.depend(),l&&(l.dep.depend(),Array.isArray(t)&&I(t))),t},set:function(n){var s=d?d.call(e):a;n===s||n!==n&&s!==s||("production"!==t.env.NODE_ENV&&r&&r(),u?u.call(e,n):a=n,l=!i&&C(n),o.notify())}})}}function F(e,n,a){if(Array.isArray(e)&&c(n))return e.length=Math.max(e.length,n),e.splice(n,1,a),a;if(p(e,n))return e[n]=a,a;var r=e.__ob__;return e._isVue||r&&r.vmCount?("production"!==t.env.NODE_ENV&&Aa("Avoid adding reactive properties to a Vue instance or its root $data at runtime - declare it upfront in the data option."),a):r?(E(r.value,n,a),r.dep.notify(),a):(e[n]=a,a)}function W(e,n){if(Array.isArray(e)&&c(n))return void e.splice(n,1);var a=e.__ob__;return e._isVue||a&&a.vmCount?void("production"!==t.env.NODE_ENV&&Aa("Avoid deleting properties on a Vue instance or its root $data - just set it to null.")):void(p(e,n)&&(delete e[n],a&&a.dep.notify()))}function I(e){for(var t=void 0,n=0,a=e.length;n<a;n++)t=e[n],t&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&I(t)}function N(e,t){if(!t)return e;for(var n,a,r,i=Object.keys(t),o=0;o<i.length;o++)n=i[o],a=e[n],r=t[n],p(e,n)?u(a)&&u(r)&&N(a,r):F(e,n,r);return e}function z(e,t,n){return n?e||t?function(){var a="function"==typeof t?t.call(n):t,r="function"==typeof e?e.call(n):e;return a?N(a,r):r}:void 0:t?e?function(){return N("function"==typeof t?t.call(this):t,"function"==typeof e?e.call(this):e)}:t:e}function R(e,t){return t?e?e.concat(t):Array.isArray(t)?t:[t]:e}function V(e,t){var n=Object.create(e||null);return t?M(n,t):n}function B(e){for(var t in e.components){var n=t.toLowerCase();(ga(n)||Ha.isReservedTag(n))&&Aa("Do not use built-in or reserved HTML elements as component id: "+t)}}function $(e){var n=e.props;if(n){var a,r,i,o={};if(Array.isArray(n))for(a=n.length;a--;)r=n[a],"string"==typeof r?(i=ba(r),o[i]={type:null}):"production"!==t.env.NODE_ENV&&Aa("props must be strings when using array syntax.");else if(u(n))for(var s in n)r=n[s],i=ba(s),o[i]=u(r)?r:{type:r};e.props=o}}function J(e){var t=e.inject;if(Array.isArray(t))for(var n=e.inject={},a=0;a<t.length;a++)n[t[a]]=t[a]}function U(e){var t=e.directives;if(t)for(var n in t){var a=t[n];"function"==typeof a&&(t[n]={bind:a,update:a})}}function G(e,n,a){function r(t){var r=mr[t]||pr;u[t]=r(e[t],n[t],a,t)}"production"!==t.env.NODE_ENV&&B(n),"function"==typeof n&&(n=n.options),$(n),J(n),U(n);var i=n.extends;if(i&&(e=G(e,i,a)),n.mixins)for(var o=0,s=n.mixins.length;o<s;o++)e=G(e,n.mixins[o],a);var d,u={};for(d in e)r(d);for(d in n)p(e,d)||r(d);return u}function q(e,n,a,r){if("string"==typeof a){var i=e[n];if(p(i,a))return i[a];var o=ba(a);if(p(i,o))return i[o];var s=ka(o);if(p(i,s))return i[s];var d=i[a]||i[o]||i[s];return"production"!==t.env.NODE_ENV&&r&&!d&&Aa("Failed to resolve "+n.slice(0,-1)+": "+a,e),d}}function K(e,n,a,r){var i=n[e],o=!p(a,e),s=a[e];if(te(Boolean,i.type)&&(o&&!p(i,"default")?s=!1:te(String,i.type)||""!==s&&s!==Da(e)||(s=!0)),void 0===s){s=Z(r,i,e);var d=hr.shouldConvert;hr.shouldConvert=!0,C(s),hr.shouldConvert=d}return"production"!==t.env.NODE_ENV&&Q(i,e,s,r,o),s}function Z(e,n,a){if(p(n,"default")){var r=n.default;return"production"!==t.env.NODE_ENV&&d(r)&&Aa('Invalid default value for prop "'+a+'": Props with type Object/Array must use a factory function to return the default value.',e),e&&e.$options.propsData&&void 0===e.$options.propsData[a]&&void 0!==e._props[a]?e._props[a]:"function"==typeof r&&"Function"!==ee(n.type)?r.call(e):r}}function Q(e,t,n,a,r){if(e.required&&r)return void Aa('Missing required prop: "'+t+'"',a);if(null!=n||e.required){var i=e.type,o=!i||i===!0,s=[];if(i){Array.isArray(i)||(i=[i]);for(var d=0;d<i.length&&!o;d++){var u=X(n,i[d]);s.push(u.expectedType||""),o=u.valid}}if(!o)return void Aa('Invalid prop: type check failed for prop "'+t+'". Expected '+s.map(ka).join(", ")+", got "+Object.prototype.toString.call(n).slice(8,-1)+".",a);var l=e.validator;l&&(l(n)||Aa('Invalid prop: custom validator check failed for prop "'+t+'".',a))}}function X(e,t){var n,a=ee(t);if(yr.test(a)){var r=typeof e;n=r===a.toLowerCase(),n||"object"!==r||(n=e instanceof t)}else n="Object"===a?u(e):"Array"===a?Array.isArray(e):e instanceof t;return{valid:n,expectedType:a}}function ee(e){var t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function te(e,t){if(!Array.isArray(t))return ee(t)===ee(e);for(var n=0,a=t.length;n<a;n++)if(ee(t[n])===ee(e))return!0;return!1}function ne(e){return new xr(void 0,void 0,void 0,String(e))}function ae(e,t){var n=new xr(e.tag,e.data,e.children,e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return n.ns=e.ns,n.isStatic=e.isStatic,n.key=e.key,n.isComment=e.isComment,n.isCloned=!0,t&&e.children&&(n.children=re(e.children)),n}function re(e,t){for(var n=e.length,a=new Array(n),r=0;r<n;r++)a[r]=ae(e[r],t);return a}function ie(e){function t(){var e=arguments,n=t.fns;if(!Array.isArray(n))return n.apply(null,arguments);for(var a=n.slice(),r=0;r<a.length;r++)a[r].apply(null,e)}return t.fns=e,t}function oe(e,t){return e.plain?-1:t.plain?1:0}function se(e,n,r,i,o){var s,d,u,l,c=[],h=!1;for(s in e)d=e[s],u=n[s],l=Hr(s),l.plain||(h=!0),a(d)?"production"!==t.env.NODE_ENV&&Aa('Invalid handler for event "'+l.name+'": got '+String(d),o):a(u)?(a(d.fns)&&(d=e[s]=ie(d)),l.handler=d,c.push(l)):d!==u&&(u.fns=d,e[s]=u);if(c.length){h&&c.sort(oe);for(var _=0;_<c.length;_++){var m=c[_];r(m.name,m.handler,m.once,m.capture,m.passive)}}for(s in n)a(e[s])&&(l=Hr(s),i(l.name,n[s],l.capture))}function de(e,t,n){function o(){n.apply(this,arguments),f(s.fns,o)}var s,d=e[t];a(d)?s=ie([o]):r(d.fns)&&i(d.merged)?(s=d,s.fns.push(o)):s=ie([d,o]),s.merged=!0,e[t]=s}function ue(e,n,i){var o=n.options.props;if(!a(o)){var s={},d=e.attrs,u=e.props;if(r(d)||r(u))for(var l in o){var c=Da(l);if("production"!==t.env.NODE_ENV){var h=l.toLowerCase();l!==h&&d&&p(d,h)&&Ca('Prop "'+h+'" is passed to component '+Ea(i||n)+', but the declared prop name is "'+l+'". Note that HTML attributes are case-insensitive and camelCased props need to use their kebab-case equivalents when using in-DOM templates. You should probably use "'+c+'" instead of "'+l+'".')}le(s,u,l,c,!0)||le(s,d,l,c,!1)}return s}}function le(e,t,n,a,i){if(r(t)){if(p(t,n))return e[n]=t[n],i||delete t[n],!0;if(p(t,a))return e[n]=t[a],i||delete t[a],!0}return!1}function ce(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function he(e){return s(e)?[ne(e)]:Array.isArray(e)?me(e):void 0}function _e(e){return r(e)&&r(e.text)&&o(e.isComment)}function me(e,t){var n,o,d,u=[];for(n=0;n<e.length;n++)o=e[n],a(o)||"boolean"==typeof o||(d=u[u.length-1],Array.isArray(o)?u.push.apply(u,me(o,(t||"")+"_"+n)):s(o)?_e(d)?d.text+=String(o):""!==o&&u.push(ne(o)):_e(o)&&_e(d)?u[u.length-1]=ne(d.text+o.text):(i(e._isVList)&&r(o.tag)&&a(o.key)&&r(t)&&(o.key="__vlist"+t+"_"+n+"__"),u.push(o)));return u}function fe(e,t){return e.__esModule&&e.default&&(e=e.default),d(e)?t.extend(e):e}function pe(e,t,n,a,r){var i=jr();return i.asyncFactory=e,i.asyncMeta={data:t,context:n,children:a,tag:r},i}function ye(e,n,o){if(i(e.error)&&r(e.errorComp))return e.errorComp;if(r(e.resolved))return e.resolved;if(i(e.loading)&&r(e.loadingComp))return e.loadingComp;if(!r(e.contexts)){var s=e.contexts=[o],u=!0,l=function(){for(var e=0,t=s.length;e<t;e++)s[e].$forceUpdate()},c=D(function(t){e.resolved=fe(t,n),u||l()}),h=D(function(n){"production"!==t.env.NODE_ENV&&Aa("Failed to resolve async component: "+String(e)+(n?"\nReason: "+n:"")),r(e.errorComp)&&(e.error=!0,l())}),_=e(c,h);return d(_)&&("function"==typeof _.then?a(e.resolved)&&_.then(c,h):r(_.component)&&"function"==typeof _.component.then&&(_.component.then(c,h),r(_.error)&&(e.errorComp=fe(_.error,n)),r(_.loading)&&(e.loadingComp=fe(_.loading,n),0===_.delay?e.loading=!0:setTimeout(function(){a(e.resolved)&&a(e.error)&&(e.loading=!0,l())},_.delay||200)),r(_.timeout)&&setTimeout(function(){a(e.resolved)&&h("production"!==t.env.NODE_ENV?"timeout ("+_.timeout+"ms)":null)},_.timeout))),u=!1,e.loading?e.loadingComp:e.resolved}e.contexts.push(o)}function ge(e){return e.isComment&&e.asyncFactory}function ve(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var n=e[t];if(r(n)&&(r(n.componentOptions)||ge(n)))return n}}function Me(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&ke(e,t)}function Le(e,t,n){n?Sr.$once(e,t):Sr.$on(e,t)}function be(e,t){Sr.$off(e,t)}function ke(e,t,n){Sr=e,se(t,n||{},Le,be,e)}function Ye(e){var n=/^hook:/;e.prototype.$on=function(e,t){var a=this,r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)a.$on(e[i],t);else(r._events[e]||(r._events[e]=[])).push(t),n.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){function n(){a.$off(e,n),t.apply(a,arguments)}var a=this;return n.fn=t,a.$on(e,n),a},e.prototype.$off=function(e,t){var n=this,a=this;if(!arguments.length)return a._events=Object.create(null),a;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return a}var o=a._events[e];if(!o)return a;if(1===arguments.length)return a._events[e]=null,a;if(t)for(var s,d=o.length;d--;)if(s=o[d],s===t||s.fn===t){o.splice(d,1);break}return a},e.prototype.$emit=function(e){var n=this;if("production"!==t.env.NODE_ENV){var a=e.toLowerCase();a!==e&&n._events[a]&&Ca('Event "'+a+'" is emitted in component '+Ea(n)+' but the handler is registered for "'+e+'". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "'+Da(e)+'" instead of "'+e+'".')}var r=n._events[e];if(r){r=r.length>1?v(r):r;for(var i=v(arguments,1),o=0,s=r.length;o<s;o++)try{r[o].apply(n,i)}catch(t){S(t,n,'event handler for "'+e+'"')}}return n}}function De(e,t){var n={};if(!e)return n;for(var a=[],r=0,i=e.length;r<i;r++){var o=e[r],s=o.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,o.context!==t&&o.functionalContext!==t||!s||null==s.slot)a.push(o);else{var d=o.data.slot,u=n[d]||(n[d]=[]);"template"===o.tag?u.push.apply(u,o.children):u.push(o)}}return a.every(we)||(n.default=a),n}function we(e){return e.isComment||" "===e.text}function xe(e,t){t=t||{};for(var n=0;n<e.length;n++)Array.isArray(e[n])?xe(e[n],t):t[e[n].key]=e[n].fn;return t}function Te(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}function Se(e){e.prototype._update=function(e,t){var n=this;n._isMounted&&Ce(n,"beforeUpdate");var a=n.$el,r=n._vnode,i=Or;Or=n,n._vnode=e,r?n.$el=n.__patch__(r,e):(n.$el=n.__patch__(n.$el,e,t,!1,n.$options._parentElm,n.$options._refElm),n.$options._parentElm=n.$options._refElm=null),Or=i,a&&(a.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){var e=this;e._watcher&&e._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Ce(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||f(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Ce(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null)}}}function je(e,n,a){e.$el=n,e.$options.render||(e.$options.render=jr,"production"!==t.env.NODE_ENV&&(e.$options.template&&"#"!==e.$options.template.charAt(0)||e.$options.el||n?Aa("You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.",e):Aa("Failed to mount component: template or render function not defined.",e))),Ce(e,"beforeMount");var r;return r="production"!==t.env.NODE_ENV&&Ha.performance&&Yr?function(){var t=e._name,n=e._uid,r="vue-perf-start:"+n,i="vue-perf-end:"+n;Yr(r);var o=e._render();Yr(i),Dr(t+" render",r,i),Yr(r),e._update(o,a),Yr(i),Dr(t+" patch",r,i)}:function(){e._update(e._render(),a)},e._watcher=new Vr(e,r,b),a=!1,null==e.$vnode&&(e._isMounted=!0,Ce(e,"mounted")),e}function He(e,n,a,r,i){"production"!==t.env.NODE_ENV&&(Pr=!0);var o=!!(i||e.$options._renderChildren||r.data.scopedSlots||e.$scopedSlots!==Oa);if(e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r),e.$options._renderChildren=i,e.$attrs=r.data&&r.data.attrs||Oa,e.$listeners=a||Oa,n&&e.$options.props){hr.shouldConvert=!1;for(var s=e._props,d=e.$options._propKeys||[],u=0;u<d.length;u++){var l=d[u];s[l]=K(l,e.$options.props,n,e)}hr.shouldConvert=!0,e.$options.propsData=n}if(a){var c=e.$options._parentListeners;e.$options._parentListeners=a,ke(e,a,c)}o&&(e.$slots=De(i,r.context),e.$forceUpdate()),"production"!==t.env.NODE_ENV&&(Pr=!1)}function Oe(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Pe(e,t){if(t){if(e._directInactive=!1,Oe(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Pe(e.$children[n]);Ce(e,"activated")}}function Ae(e,t){if(!(t&&(e._directInactive=!0,Oe(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)Ae(e.$children[n]);Ce(e,"deactivated")}}function Ce(e,t){var n=e.$options[t];if(n)for(var a=0,r=n.length;a<r;a++)try{n[a].call(e)}catch(n){S(n,e,t+" hook")}e._hasHookEvent&&e.$emit("hook:"+t)}function Ee(){zr=Cr.length=Er.length=0,Fr={},"production"!==t.env.NODE_ENV&&(Wr={}),Ir=Nr=!1}function Fe(){Nr=!0;var e,n;for(Cr.sort(function(e,t){return e.id-t.id}),zr=0;zr<Cr.length;zr++)if(e=Cr[zr],n=e.id,Fr[n]=null,e.run(),"production"!==t.env.NODE_ENV&&null!=Fr[n]&&(Wr[n]=(Wr[n]||0)+1,Wr[n]>Ar)){Aa("You may have an infinite update loop "+(e.user?'in watcher with expression "'+e.expression+'"':"in a component render function."),e.vm);break}var a=Er.slice(),r=Cr.slice();Ee(),Ne(a),We(r),ar&&Ha.devtools&&ar.emit("flush")}function We(e){for(var t=e.length;t--;){var n=e[t],a=n.vm;a._watcher===n&&a._isMounted&&Ce(a,"updated")}}function Ie(e){e._inactive=!1,Er.push(e)}function Ne(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Pe(e[t],!0)}function ze(e){var t=e.id;if(null==Fr[t]){if(Fr[t]=!0,Nr){for(var n=Cr.length-1;n>zr&&Cr[n].id>e.id;)n--;Cr.splice(n+1,0,e)}else Cr.push(e);Ir||(Ir=!0,ir(Fe))}}function Re(e){Br.clear(),Ve(e,Br)}function Ve(e,t){var n,a,r=Array.isArray(e);if((r||d(e))&&Object.isExtensible(e)){if(e.__ob__){var i=e.__ob__.dep.id;if(t.has(i))return;t.add(i)}if(r)for(n=e.length;n--;)Ve(e[n],t);else for(a=Object.keys(e),n=a.length;n--;)Ve(e[a[n]],t)}}function Be(e,t,n){$r.get=function(){return this[t][n]},$r.set=function(e){this[t][n]=e},Object.defineProperty(e,n,$r)}function $e(e){e._watchers=[];var t=e.$options;t.props&&Ue(e,t.props),t.methods&&Xe(e,t.methods),t.data?Ge(e):C(e._data={},!0),t.computed&&Ke(e,t.computed),t.watch&&t.watch!==Za&&et(e,t.watch)}function Je(e,t){var n=e.$options[t];u(n)||Aa('component option "'+t+'" should be an object.',e)}function Ue(e,n){var a=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[],o=!e.$parent;hr.shouldConvert=o;var s=function(o){i.push(o);var s=K(o,n,a,e);"production"!==t.env.NODE_ENV?((va(o)||Ha.isReservedAttr(o))&&Aa('"'+o+'" is a reserved attribute and cannot be used as component prop.',e),E(r,o,s,function(){e.$parent&&!Pr&&Aa("Avoid mutating a prop directly since the value will be overwritten whenever the parent component re-renders. Instead, use a data or computed property based on the prop's value. Prop being mutated: \""+o+'"',e)})):E(r,o,s),o in e||Be(e,"_props",o)};for(var d in n)s(d);hr.shouldConvert=!0}function Ge(e){var n=e.$options.data;n=e._data="function"==typeof n?qe(n,e):n||{},u(n)||(n={},"production"!==t.env.NODE_ENV&&Aa("data functions should return an object:\nhttps://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function",e));for(var a=Object.keys(n),r=e.$options.props,i=e.$options.methods,o=a.length;o--;){var s=a[o];"production"!==t.env.NODE_ENV&&i&&p(i,s)&&Aa('Method "'+s+'" has already been defined as a data property.',e),r&&p(r,s)?"production"!==t.env.NODE_ENV&&Aa('The data property "'+s+'" is already declared as a prop. Use prop default value instead.',e):w(s)||Be(e,"_data",s)}C(n,!0)}function qe(e,t){try{return e.call(t)}catch(e){return S(e,t,"data()"),{}}}function Ke(e,n){"production"!==t.env.NODE_ENV&&Je(e,"computed");var a=e._computedWatchers=Object.create(null),r=nr();for(var i in n){var o=n[i],s="function"==typeof o?o:o.get;"production"!==t.env.NODE_ENV&&null==s&&Aa('Getter is missing for computed property "'+i+'".',e),r||(a[i]=new Vr(e,s||b,b,Jr)),i in e?"production"!==t.env.NODE_ENV&&(i in e.$data?Aa('The computed property "'+i+'" is already defined in data.',e):e.$options.props&&i in e.$options.props&&Aa('The computed property "'+i+'" is already defined as a prop.',e)):Ze(e,i,o)}}function Ze(e,n,a){var r=!nr();"function"==typeof a?($r.get=r?Qe(n):a,$r.set=b):($r.get=a.get?r&&a.cache!==!1?Qe(n):a.get:b,$r.set=a.set?a.set:b),"production"!==t.env.NODE_ENV&&$r.set===b&&($r.set=function(){Aa('Computed property "'+n+'" was assigned to but it has no setter.',this)}),Object.defineProperty(e,n,$r)}function Qe(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),sr.target&&t.depend(),t.value}}function Xe(e,n){"production"!==t.env.NODE_ENV&&Je(e,"methods");var a=e.$options.props;for(var r in n)"production"!==t.env.NODE_ENV&&(null==n[r]&&Aa('Method "'+r+'" has an undefined value in the component definition. Did you reference the function correctly?',e),a&&p(a,r)&&Aa('Method "'+r+'" has already been defined as a prop.',e),r in e&&w(r)&&Aa('Method "'+r+'" conflicts with an existing Vue instance method. Avoid defining component methods that start with _ or $.')),e[r]=null==n[r]?b:g(n[r],e)}function et(e,n){"production"!==t.env.NODE_ENV&&Je(e,"watch");for(var a in n){var r=n[a];if(Array.isArray(r))for(var i=0;i<r.length;i++)tt(e,a,r[i]);else tt(e,a,r)}}function tt(e,t,n,a){return u(n)&&(a=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,a)}function nt(e){var n={};n.get=function(){return this._data};var a={};a.get=function(){return this._props},"production"!==t.env.NODE_ENV&&(n.set=function(e){Aa("Avoid replacing instance root $data. Use nested data properties instead.",this)},a.set=function(){Aa("$props is readonly.",this)}),Object.defineProperty(e.prototype,"$data",n),Object.defineProperty(e.prototype,"$props",a),e.prototype.$set=F,e.prototype.$delete=W,e.prototype.$watch=function(e,t,n){var a=this;if(u(t))return tt(a,e,t,n);n=n||{},n.user=!0;var r=new Vr(a,e,t,n);return n.immediate&&t.call(a,r.value),function(){r.teardown()}}}function at(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}function rt(e){var n=it(e.$options.inject,e);n&&(hr.shouldConvert=!1,Object.keys(n).forEach(function(a){"production"!==t.env.NODE_ENV?E(e,a,n[a],function(){Aa('Avoid mutating an injected value directly since the changes will be overwritten whenever the provided component re-renders. injection being mutated: "'+a+'"',e)}):E(e,a,n[a])}),hr.shouldConvert=!0)}function it(e,n){if(e){for(var a=Object.create(null),r=rr?Reflect.ownKeys(e).filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}):Object.keys(e),i=0;i<r.length;i++){for(var o=r[i],s=e[o],d=n;d;){if(d._provided&&s in d._provided){a[o]=d._provided[s];break}d=d.$parent}"production"===t.env.NODE_ENV||d||Aa('Injection "'+o+'" not found',n)}return a}}function ot(e,t,n,a,i){var o={},s=e.options.props;if(r(s))for(var d in s)o[d]=K(d,s,t||Oa);else r(n.attrs)&&st(o,n.attrs),r(n.props)&&st(o,n.props);var u=Object.create(a),l=function(e,t,n,a){return _t(u,e,t,n,a,!0)},c=e.options.render.call(null,l,{data:n,props:o,children:i,parent:a,listeners:n.on||Oa,injections:it(e.options.inject,a),slots:function(){return De(i,a)}});return c instanceof xr&&(c.functionalContext=a,c.functionalOptions=e.options,n.slot&&((c.data||(c.data={})).slot=n.slot)),c}function st(e,t){for(var n in t)e[ba(n)]=t[n]}function dt(e,n,o,s,u){if(!a(e)){var l=o.$options._base;if(d(e)&&(e=l.extend(e)),"function"!=typeof e)return void("production"!==t.env.NODE_ENV&&Aa("Invalid Component definition: "+String(e),o));var c;if(a(e.cid)&&(c=e,e=ye(c,l,o),void 0===e))return pe(c,n,o,s,u);n=n||{},jt(e),r(n.model)&&ht(e.options,n);var h=ue(n,e,u);if(i(e.options.functional))return ot(e,h,n,o,s);var _=n.on;if(n.on=n.nativeOn,i(e.options.abstract)){var m=n.slot;n={},m&&(n.slot=m)}lt(n);var f=e.options.name||u,p=new xr("vue-component-"+e.cid+(f?"-"+f:""),n,void 0,void 0,void 0,o,{Ctor:e,propsData:h,listeners:_,tag:u,children:s},c);return p}}function ut(e,t,n,a){var i=e.componentOptions,o={_isComponent:!0,parent:t,propsData:i.propsData,_componentTag:i.tag,_parentVnode:e,_parentListeners:i.listeners,_renderChildren:i.children,_parentElm:n||null,_refElm:a||null},s=e.data.inlineTemplate;return r(s)&&(o.render=s.render,o.staticRenderFns=s.staticRenderFns),new i.Ctor(o)}function lt(e){e.hook||(e.hook={});for(var t=0;t<Gr.length;t++){var n=Gr[t],a=e.hook[n],r=Ur[n];e.hook[n]=a?ct(r,a):r}}function ct(e,t){return function(n,a,r,i){e(n,a,r,i),t(n,a,r,i)}}function ht(e,t){var n=e.model&&e.model.prop||"value",a=e.model&&e.model.event||"input";(t.props||(t.props={}))[n]=t.model.value;var i=t.on||(t.on={});r(i[a])?i[a]=[t.model.callback].concat(i[a]):i[a]=t.model.callback}function _t(e,t,n,a,r,o){return(Array.isArray(n)||s(n))&&(r=a,a=n,n=void 0),i(o)&&(r=Kr),mt(e,t,n,a,r)}function mt(e,n,a,i,o){if(r(a)&&r(a.__ob__))return"production"!==t.env.NODE_ENV&&Aa("Avoid using observed data object as vnode data: "+JSON.stringify(a)+"\nAlways create fresh vnode data objects in each render!",e),jr();if(r(a)&&r(a.is)&&(n=a.is),!n)return jr();"production"!==t.env.NODE_ENV&&r(a)&&r(a.key)&&!s(a.key)&&Aa("Avoid using non-primitive value as key, use string/number value instead.",e),Array.isArray(i)&&"function"==typeof i[0]&&(a=a||{},a.scopedSlots={default:i[0]},i.length=0),o===Kr?i=he(i):o===qr&&(i=ce(i));var d,u;if("string"==typeof n){var l;u=e.$vnode&&e.$vnode.ns||Ha.getTagNamespace(n),d=Ha.isReservedTag(n)?new xr(Ha.parsePlatformTagName(n),a,i,void 0,void 0,e):r(l=q(e.$options,"components",n))?dt(l,a,e,i,n):new xr(n,a,i,void 0,void 0,e)}else d=dt(n,a,e,i);return r(d)?(u&&ft(d,u),d):jr()}function ft(e,t){if(e.ns=t,"foreignObject"!==e.tag&&r(e.children))for(var n=0,i=e.children.length;n<i;n++){var o=e.children[n];r(o.tag)&&a(o.ns)&&ft(o,t)}}function pt(e,t){var n,a,i,o,s;if(Array.isArray(e)||"string"==typeof e)for(n=new Array(e.length),a=0,i=e.length;a<i;a++)n[a]=t(e[a],a);else if("number"==typeof e)for(n=new Array(e),a=0;a<e;a++)n[a]=t(a+1,a);else if(d(e))for(o=Object.keys(e),n=new Array(o.length),a=0,i=o.length;a<i;a++)s=o[a],n[a]=t(e[s],s,a);return r(n)&&(n._isVList=!0),n}function yt(e,n,a,r){var i=this.$scopedSlots[e];if(i)return a=a||{},r&&(a=M(M({},r),a)),i(a)||n;var o=this.$slots[e];return o&&"production"!==t.env.NODE_ENV&&(o._rendered&&Aa('Duplicate presence of slot "'+e+'" found in the same render tree - this will likely cause render errors.',this),o._rendered=!0),o||n}function gt(e){return q(this.$options,"filters",e,!0)||xa}function vt(e,t,n){var a=Ha.keyCodes[t]||n;return Array.isArray(a)?a.indexOf(e)===-1:a!==e}function Mt(e,n,a,r,i){if(a)if(d(a)){Array.isArray(a)&&(a=L(a));var o,s=function(t){if("class"===t||"style"===t||va(t))o=e;else{var s=e.attrs&&e.attrs.type;o=r||Ha.mustUseProp(n,s,t)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}if(!(t in o)&&(o[t]=a[t],i)){var d=e.on||(e.on={});d["update:"+t]=function(e){a[t]=e}}};for(var u in a)s(u)}else"production"!==t.env.NODE_ENV&&Aa("v-bind without argument expects an Object or Array value",this);return e}function Lt(e,t){var n=this._staticTrees[e];return n&&!t?Array.isArray(n)?re(n):ae(n):(n=this._staticTrees[e]=this.$options.staticRenderFns[e].call(this._renderProxy),kt(n,"__static__"+e,!1),n)}function bt(e,t,n){return kt(e,"__once__"+t+(n?"_"+n:""),!0),e}function kt(e,t,n){if(Array.isArray(e))for(var a=0;a<e.length;a++)e[a]&&"string"!=typeof e[a]&&Yt(e[a],t+"_"+a,n);else Yt(e,t,n)}function Yt(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function Dt(e,n){if(n)if(u(n)){var a=e.on=e.on?M({},e.on):{};for(var r in n){var i=a[r],o=n[r];a[r]=i?[].concat(o,i):o}}else"production"!==t.env.NODE_ENV&&Aa("v-on without argument expects an Object value",this);return e}function wt(e){e._vnode=null,e._staticTrees=null;var n=e.$vnode=e.$options._parentVnode,a=n&&n.context;e.$slots=De(e.$options._renderChildren,a),e.$scopedSlots=Oa,e._c=function(t,n,a,r){return _t(e,t,n,a,r,!1)},e.$createElement=function(t,n,a,r){return _t(e,t,n,a,r,!0)};var r=n&&n.data;"production"!==t.env.NODE_ENV?(E(e,"$attrs",r&&r.attrs||Oa,function(){!Pr&&Aa("$attrs is readonly.",e)},!0),E(e,"$listeners",e.$options._parentListeners||Oa,function(){!Pr&&Aa("$listeners is readonly.",e)},!0)):(E(e,"$attrs",r&&r.attrs||Oa,null,!0),E(e,"$listeners",e.$options._parentListeners||Oa,null,!0))}function xt(e){e.prototype.$nextTick=function(e){return ir(e,this)},e.prototype._render=function(){var e=this,n=e.$options,a=n.render,r=n.staticRenderFns,i=n._parentVnode;if(e._isMounted)for(var o in e.$slots){var s=e.$slots[o];s._rendered&&(e.$slots[o]=re(s,!0))}e.$scopedSlots=i&&i.data.scopedSlots||Oa,r&&!e._staticTrees&&(e._staticTrees=[]),e.$vnode=i;var d;try{d=a.call(e._renderProxy,e.$createElement)}catch(n){S(n,e,"render function"),d="production"!==t.env.NODE_ENV&&e.$options.renderError?e.$options.renderError.call(e._renderProxy,e.$createElement,n):e._vnode}return d instanceof xr||("production"!==t.env.NODE_ENV&&Array.isArray(d)&&Aa("Multiple root nodes returned from render function. Render function should return a single root node.",e),d=jr()),d.parent=i,d},e.prototype._o=bt,e.prototype._n=_,e.prototype._s=h,e.prototype._l=pt,e.prototype._t=yt,e.prototype._q=k,e.prototype._i=Y,e.prototype._m=Lt,e.prototype._f=gt,e.prototype._k=vt,e.prototype._b=Mt,e.prototype._v=ne,e.prototype._e=jr,e.prototype._u=xe,e.prototype._g=Dt}function Tt(e){e.prototype._init=function(e){var n=this;n._uid=Zr++;var a,r;"production"!==t.env.NODE_ENV&&Ha.performance&&Yr&&(a="vue-perf-init:"+n._uid,r="vue-perf-end:"+n._uid,Yr(a)),n._isVue=!0,e&&e._isComponent?St(n,e):n.$options=G(jt(n.constructor),e||{},n),"production"!==t.env.NODE_ENV?fr(n):n._renderProxy=n,n._self=n,Te(n),Me(n),wt(n),Ce(n,"beforeCreate"),rt(n),$e(n),at(n),Ce(n,"created"),"production"!==t.env.NODE_ENV&&Ha.performance&&Yr&&(n._name=Ea(n,!1),Yr(r),Dr(n._name+" init",a,r)),n.$options.el&&n.$mount(n.$options.el)}}function St(e,t){var n=e.$options=Object.create(e.constructor.options);n.parent=t.parent,n.propsData=t.propsData,n._parentVnode=t._parentVnode,n._parentListeners=t._parentListeners,n._renderChildren=t._renderChildren,n._componentTag=t._componentTag,n._parentElm=t._parentElm,n._refElm=t._refElm,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}function jt(e){var t=e.options;if(e.super){var n=jt(e.super),a=e.superOptions;if(n!==a){e.superOptions=n;var r=Ht(e);r&&M(e.extendOptions,r),t=e.options=G(n,e.extendOptions),t.name&&(t.components[t.name]=e)}}return t}function Ht(e){var t,n=e.options,a=e.extendOptions,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=Ot(n[i],a[i],r[i]));return t}function Ot(e,t,n){if(Array.isArray(e)){var a=[];n=Array.isArray(n)?n:[n],t=Array.isArray(t)?t:[t];for(var r=0;r<e.length;r++)(t.indexOf(e[r])>=0||n.indexOf(e[r])<0)&&a.push(e[r]);return a}return e}function Pt(e){"production"===t.env.NODE_ENV||this instanceof Pt||Aa("Vue is a constructor and should be called with the `new` keyword"),this._init(e)}function At(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=v(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}function Ct(e){e.mixin=function(e){return this.options=G(this.options,e),this}}function Et(e){e.cid=0;var n=1;e.extend=function(e){e=e||{};var a=this,r=a.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||a.options.name;"production"!==t.env.NODE_ENV&&(/^[a-zA-Z][\w-]*$/.test(o)||Aa('Invalid component name: "'+o+'". Component names can only contain alphanumeric characters and the hyphen, and must start with a letter.'));var s=function(e){this._init(e)};return s.prototype=Object.create(a.prototype),s.prototype.constructor=s,s.cid=n++,s.options=G(a.options,e),s.super=a,s.options.props&&Ft(s),s.options.computed&&Wt(s),s.extend=a.extend,s.mixin=a.mixin,s.use=a.use,Sa.forEach(function(e){s[e]=a[e]}),o&&(s.options.components[o]=s),s.superOptions=a.options,s.extendOptions=e,s.sealedOptions=M({},s.options),i[r]=s,s}}function Ft(e){var t=e.options.props;for(var n in t)Be(e.prototype,"_props",n);
+}function Wt(e){var t=e.options.computed;for(var n in t)Ze(e.prototype,n,t[n])}function It(e){Sa.forEach(function(n){e[n]=function(e,a){return a?("production"!==t.env.NODE_ENV&&"component"===n&&Ha.isReservedTag(e)&&Aa("Do not use built-in or reserved HTML elements as component id: "+e),"component"===n&&u(a)&&(a.name=a.name||e,a=this.options._base.extend(a)),"directive"===n&&"function"==typeof a&&(a={bind:a,update:a}),this.options[n+"s"][e]=a,a):this.options[n+"s"][e]}})}function Nt(e){return e&&(e.Ctor.options.name||e.tag)}function zt(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:!!l(e)&&e.test(t)}function Rt(e,t,n){for(var a in e){var r=e[a];if(r){var i=Nt(r.componentOptions);i&&!n(i)&&(r!==t&&Vt(r),e[a]=null)}}}function Vt(e){e&&e.componentInstance.$destroy()}function Bt(e){var n={};n.get=function(){return Ha},"production"!==t.env.NODE_ENV&&(n.set=function(){Aa("Do not replace the Vue.config object, set individual fields instead.")}),Object.defineProperty(e,"config",n),e.util={warn:Aa,extend:M,mergeOptions:G,defineReactive:E},e.set=F,e.delete=W,e.nextTick=ir,e.options=Object.create(null),Sa.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,M(e.options.components,ei),At(e),Ct(e),Et(e),It(e)}function $t(e){for(var t=e.data,n=e,a=e;r(a.componentInstance);)a=a.componentInstance._vnode,a.data&&(t=Jt(a.data,t));for(;r(n=n.parent);)n.data&&(t=Jt(t,n.data));return Ut(t.staticClass,t.class)}function Jt(e,t){return{staticClass:Gt(e.staticClass,t.staticClass),class:r(e.class)?[e.class,t.class]:t.class}}function Ut(e,t){return r(e)||r(t)?Gt(e,qt(t)):""}function Gt(e,t){return e?t?e+" "+t:e:t||""}function qt(e){return Array.isArray(e)?Kt(e):d(e)?Zt(e):"string"==typeof e?e:""}function Kt(e){for(var t,n="",a=0,i=e.length;a<i;a++)r(t=qt(e[a]))&&""!==t&&(n&&(n+=" "),n+=t);return n}function Zt(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}function Qt(e){return mi(e)?"svg":"math"===e?"math":void 0}function Xt(e){if(!Va)return!0;if(fi(e))return!1;if(e=e.toLowerCase(),null!=pi[e])return pi[e];var t=document.createElement(e);return e.indexOf("-")>-1?pi[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:pi[e]=/HTMLUnknownElement/.test(t.toString())}function en(e){if("string"==typeof e){var n=document.querySelector(e);return n?n:("production"!==t.env.NODE_ENV&&Aa("Cannot find element: "+e),document.createElement("div"))}return e}function tn(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)}function nn(e,t){return document.createElementNS(hi[e],t)}function an(e){return document.createTextNode(e)}function rn(e){return document.createComment(e)}function on(e,t,n){e.insertBefore(t,n)}function sn(e,t){e.removeChild(t)}function dn(e,t){e.appendChild(t)}function un(e){return e.parentNode}function ln(e){return e.nextSibling}function cn(e){return e.tagName}function hn(e,t){e.textContent=t}function _n(e,t,n){e.setAttribute(t,n)}function mn(e,t){var n=e.data.ref;if(n){var a=e.context,r=e.componentInstance||e.elm,i=a.$refs;t?Array.isArray(i[n])?f(i[n],r):i[n]===r&&(i[n]=void 0):e.data.refInFor?Array.isArray(i[n])?i[n].indexOf(r)<0&&i[n].push(r):i[n]=[r]:i[n]=r}}function fn(e,t){return e.key===t.key&&(e.tag===t.tag&&e.isComment===t.isComment&&r(e.data)===r(t.data)&&pn(e,t)||i(e.isAsyncPlaceholder)&&e.asyncFactory===t.asyncFactory&&a(t.asyncFactory.error))}function pn(e,t){if("input"!==e.tag)return!0;var n,a=r(n=e.data)&&r(n=n.attrs)&&n.type,i=r(n=t.data)&&r(n=n.attrs)&&n.type;return a===i||yi(a)&&yi(i)}function yn(e,t,n){var a,i,o={};for(a=t;a<=n;++a)i=e[a].key,r(i)&&(o[i]=a);return o}function gn(e){function n(e){return new xr(P.tagName(e).toLowerCase(),{},[],void 0,e)}function o(e,t){function n(){0===--n.listeners&&d(e)}return n.listeners=t,n}function d(e){var t=P.parentNode(e);r(t)&&P.removeChild(t,e)}function u(e,n,a,o,s){if(e.isRootInsert=!s,!l(e,n,a,o)){var d=e.data,u=e.children,c=e.tag;r(c)?("production"!==t.env.NODE_ENV&&(d&&d.pre&&A++,A||e.ns||Ha.ignoredElements.length&&Ha.ignoredElements.indexOf(c)>-1||!Ha.isUnknownElement(c)||Aa("Unknown custom element: <"+c+'> - did you register the component correctly? For recursive components, make sure to provide the "name" option.',e.context)),e.elm=e.ns?P.createElementNS(e.ns,c):P.createElement(c,e),g(e),f(e,u,n),r(d)&&y(e,n),_(a,e.elm,o),"production"!==t.env.NODE_ENV&&d&&d.pre&&A--):i(e.isComment)?(e.elm=P.createComment(e.text),_(a,e.elm,o)):(e.elm=P.createTextNode(e.text),_(a,e.elm,o))}}function l(e,t,n,a){var o=e.data;if(r(o)){var s=r(e.componentInstance)&&o.keepAlive;if(r(o=o.hook)&&r(o=o.init)&&o(e,!1,n,a),r(e.componentInstance))return c(e,t),i(s)&&h(e,t,n,a),!0}}function c(e,t){r(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,p(e)?(y(e,t),g(e)):(mn(e),t.push(e))}function h(e,t,n,a){for(var i,o=e;o.componentInstance;)if(o=o.componentInstance._vnode,r(i=o.data)&&r(i=i.transition)){for(i=0;i<H.activate.length;++i)H.activate[i](Mi,o);t.push(o);break}_(n,e.elm,a)}function _(e,t,n){r(e)&&(r(n)?n.parentNode===e&&P.insertBefore(e,t,n):P.appendChild(e,t))}function f(e,t,n){if(Array.isArray(t))for(var a=0;a<t.length;++a)u(t[a],n,e.elm,null,!0);else s(e.text)&&P.appendChild(e.elm,P.createTextNode(e.text))}function p(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return r(e.tag)}function y(e,t){for(var n=0;n<H.create.length;++n)H.create[n](Mi,e);S=e.data.hook,r(S)&&(r(S.create)&&S.create(Mi,e),r(S.insert)&&t.push(e))}function g(e){for(var t,n=e;n;)r(t=n.context)&&r(t=t.$options._scopeId)&&P.setAttribute(e.elm,t,""),n=n.parent;r(t=Or)&&t!==e.context&&r(t=t.$options._scopeId)&&P.setAttribute(e.elm,t,"")}function v(e,t,n,a,r,i){for(;a<=r;++a)u(n[a],i,e,t)}function M(e){var t,n,a=e.data;if(r(a))for(r(t=a.hook)&&r(t=t.destroy)&&t(e),t=0;t<H.destroy.length;++t)H.destroy[t](e);if(r(t=e.children))for(n=0;n<e.children.length;++n)M(e.children[n])}function L(e,t,n,a){for(;n<=a;++n){var i=t[n];r(i)&&(r(i.tag)?(b(i),M(i)):d(i.elm))}}function b(e,t){if(r(t)||r(e.data)){var n,a=H.remove.length+1;for(r(t)?t.listeners+=a:t=o(e.elm,a),r(n=e.componentInstance)&&r(n=n._vnode)&&r(n.data)&&b(n,t),n=0;n<H.remove.length;++n)H.remove[n](e,t);r(n=e.data.hook)&&r(n=n.remove)?n(e,t):t()}else d(e.elm)}function k(e,n,i,o,s){for(var d,l,c,h,_=0,m=0,f=n.length-1,p=n[0],y=n[f],g=i.length-1,M=i[0],b=i[g],k=!s;_<=f&&m<=g;)a(p)?p=n[++_]:a(y)?y=n[--f]:fn(p,M)?(D(p,M,o),p=n[++_],M=i[++m]):fn(y,b)?(D(y,b,o),y=n[--f],b=i[--g]):fn(p,b)?(D(p,b,o),k&&P.insertBefore(e,p.elm,P.nextSibling(y.elm)),p=n[++_],b=i[--g]):fn(y,M)?(D(y,M,o),k&&P.insertBefore(e,y.elm,p.elm),y=n[--f],M=i[++m]):(a(d)&&(d=yn(n,_,f)),l=r(M.key)?d[M.key]:Y(M,n,_,f),a(l)?u(M,o,e,p.elm):(c=n[l],"production"===t.env.NODE_ENV||c||Aa("It seems there are duplicate keys that is causing an update error. Make sure each v-for item has a unique key."),fn(c,M)?(D(c,M,o),n[l]=void 0,k&&P.insertBefore(e,c.elm,p.elm)):u(M,o,e,p.elm)),M=i[++m]);_>f?(h=a(i[g+1])?null:i[g+1].elm,v(e,h,i,m,g,o)):m>g&&L(e,n,_,f)}function Y(e,t,n,a){for(var i=n;i<a;i++){var o=t[i];if(r(o)&&fn(e,o))return i}}function D(e,t,n,o){if(e!==t){var s=t.elm=e.elm;if(i(e.isAsyncPlaceholder))return void(r(t.asyncFactory.resolved)?x(e.elm,t,n):t.isAsyncPlaceholder=!0);if(i(t.isStatic)&&i(e.isStatic)&&t.key===e.key&&(i(t.isCloned)||i(t.isOnce)))return void(t.componentInstance=e.componentInstance);var d,u=t.data;r(u)&&r(d=u.hook)&&r(d=d.prepatch)&&d(e,t);var l=e.children,c=t.children;if(r(u)&&p(t)){for(d=0;d<H.update.length;++d)H.update[d](e,t);r(d=u.hook)&&r(d=d.update)&&d(e,t)}a(t.text)?r(l)&&r(c)?l!==c&&k(s,l,c,n,o):r(c)?(r(e.text)&&P.setTextContent(s,""),v(s,null,c,0,c.length-1,n)):r(l)?L(s,l,0,l.length-1):r(e.text)&&P.setTextContent(s,""):e.text!==t.text&&P.setTextContent(s,t.text),r(u)&&r(d=u.hook)&&r(d=d.postpatch)&&d(e,t)}}function w(e,t,n){if(i(n)&&r(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}function x(e,n,a){if(i(n.isComment)&&r(n.asyncFactory))return n.elm=e,n.isAsyncPlaceholder=!0,!0;if("production"!==t.env.NODE_ENV&&!T(e,n))return!1;n.elm=e;var o=n.tag,s=n.data,d=n.children;if(r(s)&&(r(S=s.hook)&&r(S=S.init)&&S(n,!0),r(S=n.componentInstance)))return c(n,a),!0;if(r(o)){if(r(d))if(e.hasChildNodes())if(r(S=s)&&r(S=S.domProps)&&r(S=S.innerHTML)){if(S!==e.innerHTML)return"production"===t.env.NODE_ENV||"undefined"==typeof console||C||(C=!0,console.warn("Parent: ",e),console.warn("server innerHTML: ",S),console.warn("client innerHTML: ",e.innerHTML)),!1}else{for(var u=!0,l=e.firstChild,h=0;h<d.length;h++){if(!l||!x(l,d[h],a)){u=!1;break}l=l.nextSibling}if(!u||l)return"production"===t.env.NODE_ENV||"undefined"==typeof console||C||(C=!0,console.warn("Parent: ",e),console.warn("Mismatching childNodes vs. VNodes: ",e.childNodes,d)),!1}else f(n,d,a);if(r(s))for(var _ in s)if(!E(_)){y(n,a);break}}else e.data!==n.text&&(e.data=n.text);return!0}function T(e,t){return r(t.tag)?0===t.tag.indexOf("vue-component")||t.tag.toLowerCase()===(e.tagName&&e.tagName.toLowerCase()):e.nodeType===(t.isComment?8:3)}var S,j,H={},O=e.modules,P=e.nodeOps;for(S=0;S<Li.length;++S)for(H[Li[S]]=[],j=0;j<O.length;++j)r(O[j][Li[S]])&&H[Li[S]].push(O[j][Li[S]]);var A=0,C=!1,E=m("attrs,style,class,staticClass,staticStyle,key");return function(e,o,s,d,l,c){if(a(o))return void(r(e)&&M(e));var h=!1,_=[];if(a(e))h=!0,u(o,_,l,c);else{var m=r(e.nodeType);if(!m&&fn(e,o))D(e,o,_,d);else{if(m){if(1===e.nodeType&&e.hasAttribute(Ta)&&(e.removeAttribute(Ta),s=!0),i(s)){if(x(e,o,_))return w(o,_,!0),e;"production"!==t.env.NODE_ENV&&Aa("The client-side rendered virtual DOM tree is not matching server-rendered content. This is likely caused by incorrect HTML markup, for example nesting block-level elements inside <p>, or missing <tbody>. Bailing hydration and performing full client-side render.")}e=n(e)}var f=e.elm,y=P.parentNode(f);if(u(o,_,f._leaveCb?null:y,P.nextSibling(f)),r(o.parent))for(var g=o.parent,v=p(o);g;){for(var b=0;b<H.destroy.length;++b)H.destroy[b](g);if(g.elm=o.elm,v){for(var k=0;k<H.create.length;++k)H.create[k](Mi,g);var Y=g.data.hook.insert;if(Y.merged)for(var T=1;T<Y.fns.length;T++)Y.fns[T]()}g=g.parent}r(y)?L(y,[e],0,0):r(e.tag)&&M(e)}}return w(o,_,h),o.elm}}function vn(e,t){(e.data.directives||t.data.directives)&&Mn(e,t)}function Mn(e,t){var n,a,r,i=e===Mi,o=t===Mi,s=Ln(e.data.directives,e.context),d=Ln(t.data.directives,t.context),u=[],l=[];for(n in d)a=s[n],r=d[n],a?(r.oldValue=a.value,kn(r,"update",t,e),r.def&&r.def.componentUpdated&&l.push(r)):(kn(r,"bind",t,e),r.def&&r.def.inserted&&u.push(r));if(u.length){var c=function(){for(var n=0;n<u.length;n++)kn(u[n],"inserted",t,e)};i?de(t.data.hook||(t.data.hook={}),"insert",c):c()}if(l.length&&de(t.data.hook||(t.data.hook={}),"postpatch",function(){for(var n=0;n<l.length;n++)kn(l[n],"componentUpdated",t,e)}),!i)for(n in s)d[n]||kn(s[n],"unbind",e,e,o)}function Ln(e,t){var n=Object.create(null);if(!e)return n;var a,r;for(a=0;a<e.length;a++)r=e[a],r.modifiers||(r.modifiers=ki),n[bn(r)]=r,r.def=q(t.$options,"directives",r.name,!0);return n}function bn(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function kn(e,t,n,a,r){var i=e.def&&e.def[t];if(i)try{i(n.elm,e,n,a,r)}catch(a){S(a,n.context,"directive "+e.name+" "+t+" hook")}}function Yn(e,t){var n=t.componentOptions;if(!(r(n)&&n.Ctor.options.inheritAttrs===!1||a(e.data.attrs)&&a(t.data.attrs))){var i,o,s,d=t.elm,u=e.data.attrs||{},l=t.data.attrs||{};r(l.__ob__)&&(l=t.data.attrs=M({},l));for(i in l)o=l[i],s=u[i],s!==o&&Dn(d,i,o);Ja&&l.value!==u.value&&Dn(d,"value",l.value);for(i in u)a(l[i])&&(ui(i)?d.removeAttributeNS(di,li(i)):oi(i)||d.removeAttribute(i))}}function Dn(e,t,n){si(t)?ci(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):oi(t)?e.setAttribute(t,ci(n)||"false"===n?"false":"true"):ui(t)?ci(n)?e.removeAttributeNS(di,li(t)):e.setAttributeNS(di,t,n):ci(n)?e.removeAttribute(t):e.setAttribute(t,n)}function wn(e,t){var n=t.elm,i=t.data,o=e.data;if(!(a(i.staticClass)&&a(i.class)&&(a(o)||a(o.staticClass)&&a(o.class)))){var s=$t(t),d=n._transitionClasses;r(d)&&(s=Gt(s,qt(d))),s!==n._prevClass&&(n.setAttribute("class",s),n._prevClass=s)}}function xn(e){var t;r(e[xi])&&(t=$a?"change":"input",e[t]=[].concat(e[xi],e[t]||[]),delete e[xi]),r(e[Ti])&&(t=Ka?"click":"change",e[t]=[].concat(e[Ti],e[t]||[]),delete e[Ti])}function Tn(e,t,n,a,r){if(n){var i=t,o=ti;t=function(n){var r=1===arguments.length?i(n):i.apply(null,arguments);null!==r&&Sn(e,t,a,o)}}ti.addEventListener(e,t,Qa?{capture:a,passive:r}:a)}function Sn(e,t,n,a){(a||ti).removeEventListener(e,t,n)}function jn(e,t){if(!a(e.data.on)||!a(t.data.on)){var n=t.data.on||{},r=e.data.on||{};ti=t.elm,xn(n),se(n,r,Tn,Sn,t.context)}}function Hn(e,t){if(!a(e.data.domProps)||!a(t.data.domProps)){var n,i,o=t.elm,s=e.data.domProps||{},d=t.data.domProps||{};r(d.__ob__)&&(d=t.data.domProps=M({},d));for(n in s)a(d[n])&&(o[n]="");for(n in d)if(i=d[n],"textContent"!==n&&"innerHTML"!==n||(t.children&&(t.children.length=0),i!==s[n]))if("value"===n){o._value=i;var u=a(i)?"":String(i);On(o,t,u)&&(o.value=u)}else o[n]=i}}function On(e,t,n){return!e.composing&&("option"===t.tag||Pn(e,n)||An(e,n))}function Pn(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}function An(e,t){var n=e.value,a=e._vModifiers;return r(a)&&a.number?_(n)!==_(t):r(a)&&a.trim?n.trim()!==t.trim():n!==t}function Cn(e){var t=En(e.style);return e.staticStyle?M(e.staticStyle,t):t}function En(e){return Array.isArray(e)?L(e):"string"==typeof e?Hi(e):e}function Fn(e,t){var n,a={};if(t)for(var r=e;r.componentInstance;)r=r.componentInstance._vnode,r.data&&(n=Cn(r.data))&&M(a,n);(n=Cn(e.data))&&M(a,n);for(var i=e;i=i.parent;)i.data&&(n=Cn(i.data))&&M(a,n);return a}function Wn(e,t){var n=t.data,i=e.data;if(!(a(n.staticStyle)&&a(n.style)&&a(i.staticStyle)&&a(i.style))){var o,s,d=t.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},c=u||l,h=En(t.data.style)||{};t.data.normalizedStyle=r(h.__ob__)?M({},h):h;var _=Fn(t,!0);for(s in c)a(_[s])&&Ai(d,s,"");for(s in _)o=_[s],o!==c[s]&&Ai(d,s,null==o?"":o)}}function In(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(/\s+/).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Nn(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(/\s+/).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",a=" "+t+" ";n.indexOf(a)>=0;)n=n.replace(a," ");n=n.trim(),n?e.setAttribute("class",n):e.removeAttribute("class")}}function zn(e){if(e){if("object"==typeof e){var t={};return e.css!==!1&&M(t,Wi(e.name||"v")),M(t,e),t}return"string"==typeof e?Wi(e):void 0}}function Rn(e){Ji(function(){Ji(e)})}function Vn(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),In(e,t))}function Bn(e,t){e._transitionClasses&&f(e._transitionClasses,t),Nn(e,t)}function $n(e,t,n){var a=Jn(e,t),r=a.type,i=a.timeout,o=a.propCount;if(!r)return n();var s=r===Ni?Vi:$i,d=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++d>=o&&u()};setTimeout(function(){d<o&&u()},i+1),e.addEventListener(s,l)}function Jn(e,t){var n,a=window.getComputedStyle(e),r=a[Ri+"Delay"].split(", "),i=a[Ri+"Duration"].split(", "),o=Un(r,i),s=a[Bi+"Delay"].split(", "),d=a[Bi+"Duration"].split(", "),u=Un(s,d),l=0,c=0;t===Ni?o>0&&(n=Ni,l=o,c=i.length):t===zi?u>0&&(n=zi,l=u,c=d.length):(l=Math.max(o,u),n=l>0?o>u?Ni:zi:null,c=n?n===Ni?i.length:d.length:0);var h=n===Ni&&Ui.test(a[Ri+"Property"]);return{type:n,timeout:l,propCount:c,hasTransform:h}}function Un(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Gn(t)+Gn(e[n])}))}function Gn(e){return 1e3*Number(e.slice(0,-1))}function qn(e,n){var i=e.elm;r(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=zn(e.data.transition);if(!a(o)&&!r(i._enterCb)&&1===i.nodeType){for(var s=o.css,u=o.type,l=o.enterClass,c=o.enterToClass,h=o.enterActiveClass,m=o.appearClass,f=o.appearToClass,p=o.appearActiveClass,y=o.beforeEnter,g=o.enter,v=o.afterEnter,M=o.enterCancelled,L=o.beforeAppear,b=o.appear,k=o.afterAppear,Y=o.appearCancelled,w=o.duration,x=Or,T=Or.$vnode;T&&T.parent;)T=T.parent,x=T.context;var S=!x._isMounted||!e.isRootInsert;if(!S||b||""===b){var j=S&&m?m:l,H=S&&p?p:h,O=S&&f?f:c,P=S?L||y:y,A=S&&"function"==typeof b?b:g,C=S?k||v:v,E=S?Y||M:M,F=_(d(w)?w.enter:w);"production"!==t.env.NODE_ENV&&null!=F&&Zn(F,"enter",e);var W=s!==!1&&!Ja,I=Xn(A),N=i._enterCb=D(function(){W&&(Bn(i,O),Bn(i,H)),N.cancelled?(W&&Bn(i,j),E&&E(i)):C&&C(i),i._enterCb=null});e.data.show||de(e.data.hook||(e.data.hook={}),"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),A&&A(i,N)}),P&&P(i),W&&(Vn(i,j),Vn(i,H),Rn(function(){Vn(i,O),Bn(i,j),N.cancelled||I||(Qn(F)?setTimeout(N,F):$n(i,u,N))})),e.data.show&&(n&&n(),A&&A(i,N)),W||I||N()}}}function Kn(e,n){function i(){Y.cancelled||(e.data.show||((o.parentNode._pending||(o.parentNode._pending={}))[e.key]=e),f&&f(o),L&&(Vn(o,c),Vn(o,m),Rn(function(){Vn(o,h),Bn(o,c),Y.cancelled||b||(Qn(k)?setTimeout(Y,k):$n(o,l,Y))})),p&&p(o,Y),L||b||Y())}var o=e.elm;r(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var s=zn(e.data.transition);if(a(s))return n();if(!r(o._leaveCb)&&1===o.nodeType){var u=s.css,l=s.type,c=s.leaveClass,h=s.leaveToClass,m=s.leaveActiveClass,f=s.beforeLeave,p=s.leave,y=s.afterLeave,g=s.leaveCancelled,v=s.delayLeave,M=s.duration,L=u!==!1&&!Ja,b=Xn(p),k=_(d(M)?M.leave:M);"production"!==t.env.NODE_ENV&&r(k)&&Zn(k,"leave",e);var Y=o._leaveCb=D(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[e.key]=null),L&&(Bn(o,h),Bn(o,m)),Y.cancelled?(L&&Bn(o,c),g&&g(o)):(n(),y&&y(o)),o._leaveCb=null});v?v(i):i()}}function Zn(e,t,n){"number"!=typeof e?Aa("<transition> explicit "+t+" duration is not a valid number - got "+JSON.stringify(e)+".",n.context):isNaN(e)&&Aa("<transition> explicit "+t+" duration is NaN - the duration expression might be incorrect.",n.context)}function Qn(e){return"number"==typeof e&&!isNaN(e)}function Xn(e){if(a(e))return!1;var t=e.fns;return r(t)?Xn(Array.isArray(t)?t[0]:t):(e._length||e.length)>1}function ea(e,t){t.data.show!==!0&&qn(t)}function ta(e,t,n){na(e,t,n),($a||Ua)&&setTimeout(function(){na(e,t,n)},0)}function na(e,n,a){var r=n.value,i=e.multiple;if(i&&!Array.isArray(r))return void("production"!==t.env.NODE_ENV&&Aa('<select multiple v-model="'+n.expression+'"> expects an Array value for its binding, but got '+Object.prototype.toString.call(r).slice(8,-1),a));for(var o,s,d=0,u=e.options.length;d<u;d++)if(s=e.options[d],i)o=Y(r,ra(s))>-1,s.selected!==o&&(s.selected=o);else if(k(ra(s),r))return void(e.selectedIndex!==d&&(e.selectedIndex=d));i||(e.selectedIndex=-1)}function aa(e,t){return t.every(function(t){return!k(t,e)})}function ra(e){return"_value"in e?e._value:e.value}function ia(e){e.target.composing=!0}function oa(e){e.target.composing&&(e.target.composing=!1,sa(e.target,"input"))}function sa(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function da(e){return!e.componentInstance||e.data&&e.data.transition?e:da(e.componentInstance._vnode)}function ua(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ua(ve(t.children)):e}function la(e){var t={},n=e.$options;for(var a in n.propsData)t[a]=e[a];var r=n._parentListeners;for(var i in r)t[ba(i)]=r[i];return t}function ca(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}function ha(e){for(;e=e.parent;)if(e.data.transition)return!0}function _a(e,t){return t.key===e.key&&t.tag===e.tag}function ma(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function fa(e){e.data.newPos=e.elm.getBoundingClientRect()}function pa(e){var t=e.data.pos,n=e.data.newPos,a=t.left-n.left,r=t.top-n.top;if(a||r){e.data.moved=!0;var i=e.elm.style;i.transform=i.WebkitTransform="translate("+a+"px,"+r+"px)",i.transitionDuration="0s"}}var ya=Object.prototype.toString,ga=m("slot,component",!0),va=m("key,ref,slot,is"),Ma=Object.prototype.hasOwnProperty,La=/-(\w)/g,ba=y(function(e){return e.replace(La,function(e,t){return t?t.toUpperCase():""})}),ka=y(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),Ya=/\B([A-Z])/g,Da=y(function(e){return e.replace(Ya,"-$1").toLowerCase()}),wa=function(e,t,n){return!1},xa=function(e){return e},Ta="data-server-rendered",Sa=["component","directive","filter"],ja=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated"],Ha={optionMergeStrategies:Object.create(null),silent:!1,productionTip:"production"!==t.env.NODE_ENV,devtools:"production"!==t.env.NODE_ENV,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:wa,isReservedAttr:wa,isUnknownElement:wa,getTagNamespace:b,parsePlatformTagName:xa,mustUseProp:wa,_lifecycleHooks:ja},Oa=Object.freeze({}),Pa=/[^\w.$]/,Aa=b,Ca=b,Ea=null;if("production"!==t.env.NODE_ENV){var Fa="undefined"!=typeof console,Wa=/(?:^|[-_])(\w)/g,Ia=function(e){return e.replace(Wa,function(e){return e.toUpperCase()}).replace(/[-_]/g,"")};Aa=function(e,t){var n=t?za(t):"";Ha.warnHandler?Ha.warnHandler.call(null,e,t,n):Fa&&!Ha.silent&&console.error("[Vue warn]: "+e+n)},Ca=function(e,t){Fa&&!Ha.silent&&console.warn("[Vue tip]: "+e+(t?za(t):""))},Ea=function(e,t){if(e.$root===e)return"<Root>";var n="string"==typeof e?e:"function"==typeof e&&e.options?e.options.name:e._isVue?e.$options.name||e.$options._componentTag:e.name,a=e._isVue&&e.$options.__file;if(!n&&a){var r=a.match(/([^\/\\]+)\.vue$/);n=r&&r[1]}return(n?"<"+Ia(n)+">":"<Anonymous>")+(a&&t!==!1?" at "+a:"")};var Na=function(e,t){for(var n="";t;)t%2===1&&(n+=e),t>1&&(e+=e),t>>=1;return n},za=function(e){if(e._isVue&&e.$parent){for(var t=[],n=0;e;){if(t.length>0){var a=t[t.length-1];if(a.constructor===e.constructor){n++,e=e.$parent;continue}n>0&&(t[t.length-1]=[a,n],n=0)}t.push(e),e=e.$parent}return"\n\nfound in\n\n"+t.map(function(e,t){return""+(0===t?"---> ":Na(" ",5+2*t))+(Array.isArray(e)?Ea(e[0])+"... ("+e[1]+" recursive calls)":Ea(e))}).join("\n")}return"\n\n(found in "+Ea(e)+")"}}var Ra="__proto__"in{},Va="undefined"!=typeof window,Ba=Va&&window.navigator.userAgent.toLowerCase(),$a=Ba&&/msie|trident/.test(Ba),Ja=Ba&&Ba.indexOf("msie 9.0")>0,Ua=Ba&&Ba.indexOf("edge/")>0,Ga=Ba&&Ba.indexOf("android")>0,qa=Ba&&/iphone|ipad|ipod|ios/.test(Ba),Ka=Ba&&/chrome\/\d+/.test(Ba)&&!Ua,Za={}.watch,Qa=!1;if(Va)try{var Xa={};Object.defineProperty(Xa,"passive",{get:function(){Qa=!0}}),window.addEventListener("test-passive",null,Xa)}catch(e){}var er,tr,nr=function(){return void 0===er&&(er=!Va&&"undefined"!=typeof n&&"server"===n.process.env.VUE_ENV),er},ar=Va&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__,rr="undefined"!=typeof Symbol&&j(Symbol)&&"undefined"!=typeof Reflect&&j(Reflect.ownKeys),ir=function(){function e(){a=!1;var e=n.slice(0);n.length=0;for(var t=0;t<e.length;t++)e[t]()}var t,n=[],a=!1;if("undefined"!=typeof Promise&&j(Promise)){var r=Promise.resolve(),i=function(e){console.error(e)};t=function(){r.then(e).catch(i),qa&&setTimeout(b)}}else if($a||"undefined"==typeof MutationObserver||!j(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())t=function(){setTimeout(e,0)};else{var o=1,s=new MutationObserver(e),d=document.createTextNode(String(o));s.observe(d,{characterData:!0}),t=function(){o=(o+1)%2,d.data=String(o)}}return function(e,r){var i;if(n.push(function(){if(e)try{e.call(r)}catch(e){S(e,r,"nextTick")}else i&&i(r)}),a||(a=!0,t()),!e&&"undefined"!=typeof Promise)return new Promise(function(e,t){i=e})}}();tr="undefined"!=typeof Set&&j(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return this.set[e]===!0},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var or=0,sr=function(){this.id=or++,this.subs=[]};sr.prototype.addSub=function(e){this.subs.push(e)},sr.prototype.removeSub=function(e){f(this.subs,e)},sr.prototype.depend=function(){sr.target&&sr.target.addDep(this)},sr.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},sr.target=null;var dr=[],ur=Array.prototype,lr=Object.create(ur);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=ur[e];x(lr,e,function(){for(var n=[],a=arguments.length;a--;)n[a]=arguments[a];var r,i=t.apply(this,n),o=this.__ob__;switch(e){case"push":case"unshift":r=n;break;case"splice":r=n.slice(2)}return r&&o.observeArray(r),o.dep.notify(),i})});var cr=Object.getOwnPropertyNames(lr),hr={shouldConvert:!0},_r=function(e){if(this.value=e,this.dep=new sr,this.vmCount=0,x(e,"__ob__",this),Array.isArray(e)){var t=Ra?P:A;t(e,lr,cr),this.observeArray(e)}else this.walk(e)};_r.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)E(e,t[n],e[t[n]])},_r.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)C(e[t])};var mr=Ha.optionMergeStrategies;"production"!==t.env.NODE_ENV&&(mr.el=mr.propsData=function(e,t,n,a){return n||Aa('option "'+a+'" can only be used during instance creation with the `new` keyword.'),pr(e,t)}),mr.data=function(e,n,a){return a?z(e,n,a):n&&"function"!=typeof n?("production"!==t.env.NODE_ENV&&Aa('The "data" option should be a function that returns a per-instance value in component definitions.',a),e):z.call(this,e,n)},ja.forEach(function(e){mr[e]=R}),Sa.forEach(function(e){mr[e+"s"]=V}),mr.watch=function(e,t){if(e===Za&&(e=void 0),t===Za&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var n={};M(n,e);for(var a in t){var r=n[a],i=t[a];r&&!Array.isArray(r)&&(r=[r]),n[a]=r?r.concat(i):Array.isArray(i)?i:[i]}return n},mr.props=mr.methods=mr.inject=mr.computed=function(e,t){if(!e)return t;var n=Object.create(null);return M(n,e),t&&M(n,t),n},mr.provide=z;var fr,pr=function(e,t){return void 0===t?e:t},yr=/^(String|Number|Boolean|Function|Symbol)$/;if("production"!==t.env.NODE_ENV){var gr=m("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,require"),vr=function(e,t){Aa('Property or method "'+t+'" is not defined on the instance but referenced during render. Make sure to declare reactive data properties in the data option.',e)},Mr="undefined"!=typeof Proxy&&Proxy.toString().match(/native code/);if(Mr){var Lr=m("stop,prevent,self,ctrl,shift,alt,meta");Ha.keyCodes=new Proxy(Ha.keyCodes,{set:function(e,t,n){return Lr(t)?(Aa("Avoid overwriting built-in modifier in config.keyCodes: ."+t),!1):(e[t]=n,!0)}})}var br={has:function e(t,n){var e=n in t,a=gr(n)||"_"===n.charAt(0);return e||a||vr(t,n),e||!a}},kr={get:function(e,t){return"string"!=typeof t||t in e||vr(e,t),e[t]}};fr=function(e){if(Mr){var t=e.$options,n=t.render&&t.render._withStripped?kr:br;e._renderProxy=new Proxy(e,n)}else e._renderProxy=e}}var Yr,Dr;if("production"!==t.env.NODE_ENV){var wr=Va&&window.performance;wr&&wr.mark&&wr.measure&&wr.clearMarks&&wr.clearMeasures&&(Yr=function(e){return wr.mark(e)},Dr=function(e,t,n){wr.measure(e,t,n),wr.clearMarks(t),wr.clearMarks(n),wr.clearMeasures(e)})}var xr=function(e,t,n,a,r,i,o,s){this.tag=e,this.data=t,this.children=n,this.text=a,this.elm=r,this.ns=void 0,this.context=i,this.functionalContext=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},Tr={child:{}};Tr.child.get=function(){return this.componentInstance},Object.defineProperties(xr.prototype,Tr);var Sr,jr=function(e){void 0===e&&(e="");var t=new xr;return t.text=e,t.isComment=!0,t},Hr=y(function(e){var t="&"===e.charAt(0);e=t?e.slice(1):e;var n="~"===e.charAt(0);e=n?e.slice(1):e;var a="!"===e.charAt(0);e=a?e.slice(1):e;var r=!(t||n||a);return{name:e,plain:r,once:n,capture:a,passive:t}}),Or=null,Pr=!1,Ar=100,Cr=[],Er=[],Fr={},Wr={},Ir=!1,Nr=!1,zr=0,Rr=0,Vr=function(e,n,a,r){this.vm=e,e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync):this.deep=this.user=this.lazy=this.sync=!1,this.cb=a,this.id=++Rr,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new tr,this.newDepIds=new tr,this.expression="production"!==t.env.NODE_ENV?n.toString():"","function"==typeof n?this.getter=n:(this.getter=T(n),this.getter||(this.getter=function(){},"production"!==t.env.NODE_ENV&&Aa('Failed watching path: "'+n+'" Watcher only accepts simple dot-delimited paths. For full control, use a function instead.',e))),this.value=this.lazy?void 0:this.get()};Vr.prototype.get=function(){H(this);var e,t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;S(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Re(e),O(),this.cleanupDeps()}return e},Vr.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},Vr.prototype.cleanupDeps=function(){for(var e=this,t=this.deps.length;t--;){var n=e.deps[t];e.newDepIds.has(n.id)||n.removeSub(e)}var a=this.depIds;this.depIds=this.newDepIds,this.newDepIds=a,this.newDepIds.clear(),a=this.deps,this.deps=this.newDeps,this.newDeps=a,this.newDeps.length=0},Vr.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():ze(this)},Vr.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||d(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){S(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},Vr.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},Vr.prototype.depend=function(){for(var e=this,t=this.deps.length;t--;)e.deps[t].depend()},Vr.prototype.teardown=function(){var e=this;if(this.active){this.vm._isBeingDestroyed||f(this.vm._watchers,this);for(var t=this.deps.length;t--;)e.deps[t].removeSub(e);this.active=!1}};var Br=new tr,$r={enumerable:!0,configurable:!0,get:b,set:b},Jr={lazy:!0},Ur={init:function(e,t,n,a){if(!e.componentInstance||e.componentInstance._isDestroyed){var r=e.componentInstance=ut(e,Or,n,a);r.$mount(t?e.elm:void 0,t)}else if(e.data.keepAlive){var i=e;Ur.prepatch(i,i)}},prepatch:function(e,t){var n=t.componentOptions,a=t.componentInstance=e.componentInstance;He(a,n.propsData,n.listeners,t,n.children)},insert:function(e){var t=e.context,n=e.componentInstance;n._isMounted||(n._isMounted=!0,Ce(n,"mounted")),e.data.keepAlive&&(t._isMounted?Ie(n):Pe(n,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?Ae(t,!0):t.$destroy())}},Gr=Object.keys(Ur),qr=1,Kr=2,Zr=0;Tt(Pt),nt(Pt),Ye(Pt),Se(Pt),xt(Pt);var Qr=[String,RegExp,Array],Xr={name:"keep-alive",abstract:!0,props:{include:Qr,exclude:Qr},created:function(){this.cache=Object.create(null)},destroyed:function(){var e=this;for(var t in e.cache)Vt(e.cache[t])},watch:{include:function(e){Rt(this.cache,this._vnode,function(t){return zt(e,t)})},exclude:function(e){Rt(this.cache,this._vnode,function(t){return!zt(e,t)})}},render:function(){var e=ve(this.$slots.default),t=e&&e.componentOptions;if(t){var n=Nt(t);if(n&&(this.include&&!zt(this.include,n)||this.exclude&&zt(this.exclude,n)))return e;var a=null==e.key?t.Ctor.cid+(t.tag?"::"+t.tag:""):e.key;this.cache[a]?e.componentInstance=this.cache[a].componentInstance:this.cache[a]=e,
+e.data.keepAlive=!0}return e}},ei={KeepAlive:Xr};Bt(Pt),Object.defineProperty(Pt.prototype,"$isServer",{get:nr}),Object.defineProperty(Pt.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Pt.version="2.4.4";var ti,ni,ai=m("style,class"),ri=m("input,textarea,option,select,progress"),ii=function(e,t,n){return"value"===n&&ri(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},oi=m("contenteditable,draggable,spellcheck"),si=m("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),di="http://www.w3.org/1999/xlink",ui=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},li=function(e){return ui(e)?e.slice(6,e.length):""},ci=function(e){return null==e||e===!1},hi={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},_i=m("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),mi=m("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),fi=function(e){return _i(e)||mi(e)},pi=Object.create(null),yi=m("text,number,password,search,email,tel,url"),gi=Object.freeze({createElement:tn,createElementNS:nn,createTextNode:an,createComment:rn,insertBefore:on,removeChild:sn,appendChild:dn,parentNode:un,nextSibling:ln,tagName:cn,setTextContent:hn,setAttribute:_n}),vi={create:function(e,t){mn(t)},update:function(e,t){e.data.ref!==t.data.ref&&(mn(e,!0),mn(t))},destroy:function(e){mn(e,!0)}},Mi=new xr("",{},[]),Li=["create","activate","update","remove","destroy"],bi={create:vn,update:vn,destroy:function(e){vn(e,Mi)}},ki=Object.create(null),Yi=[vi,bi],Di={create:Yn,update:Yn},wi={create:wn,update:wn},xi="__r",Ti="__c",Si={create:jn,update:jn},ji={create:Hn,update:Hn},Hi=y(function(e){var t={},n=/;(?![^(]*\))/g,a=/:(.+)/;return e.split(n).forEach(function(e){if(e){var n=e.split(a);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}),Oi=/^--/,Pi=/\s*!important$/,Ai=function(e,t,n){if(Oi.test(t))e.style.setProperty(t,n);else if(Pi.test(n))e.style.setProperty(t,n.replace(Pi,""),"important");else{var a=Ei(t);if(Array.isArray(n))for(var r=0,i=n.length;r<i;r++)e.style[a]=n[r];else e.style[a]=n}},Ci=["Webkit","Moz","ms"],Ei=y(function(e){if(ni=ni||document.createElement("div").style,e=ba(e),"filter"!==e&&e in ni)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<Ci.length;n++){var a=Ci[n]+t;if(a in ni)return a}}),Fi={create:Wn,update:Wn},Wi=y(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),Ii=Va&&!Ja,Ni="transition",zi="animation",Ri="transition",Vi="transitionend",Bi="animation",$i="animationend";Ii&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ri="WebkitTransition",Vi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Bi="WebkitAnimation",$i="webkitAnimationEnd"));var Ji=Va&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout,Ui=/\b(transform|all)(,|$)/,Gi=Va?{create:ea,activate:ea,remove:function(e,t){e.data.show!==!0?Kn(e,t):t()}}:{},qi=[Di,wi,Si,ji,Fi,Gi],Ki=qi.concat(Yi),Zi=gn({nodeOps:gi,modules:Ki});Ja&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&sa(e,"input")});var Qi={inserted:function(e,t,n){"select"===n.tag?(ta(e,t,n.context),e._vOptions=[].map.call(e.options,ra)):("textarea"===n.tag||yi(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("change",oa),Ga||(e.addEventListener("compositionstart",ia),e.addEventListener("compositionend",oa)),Ja&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){ta(e,t,n.context);var a=e._vOptions,r=e._vOptions=[].map.call(e.options,ra);if(r.some(function(e,t){return!k(e,a[t])})){var i=e.multiple?t.value.some(function(e){return aa(e,r)}):t.value!==t.oldValue&&aa(t.value,r);i&&sa(e,"change")}}}},Xi={bind:function(e,t,n){var a=t.value;n=da(n);var r=n.data&&n.data.transition,i=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;a&&r?(n.data.show=!0,qn(n,function(){e.style.display=i})):e.style.display=a?i:"none"},update:function(e,t,n){var a=t.value,r=t.oldValue;if(a!==r){n=da(n);var i=n.data&&n.data.transition;i?(n.data.show=!0,a?qn(n,function(){e.style.display=e.__vOriginalDisplay}):Kn(n,function(){e.style.display="none"})):e.style.display=a?e.__vOriginalDisplay:"none"}},unbind:function(e,t,n,a,r){r||(e.style.display=e.__vOriginalDisplay)}},eo={model:Qi,show:Xi},to={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]},no={name:"transition",props:to,abstract:!0,render:function(e){var n=this,a=this.$options._renderChildren;if(a&&(a=a.filter(function(e){return e.tag||ge(e)}),a.length)){"production"!==t.env.NODE_ENV&&a.length>1&&Aa("<transition> can only be used on a single element. Use <transition-group> for lists.",this.$parent);var r=this.mode;"production"!==t.env.NODE_ENV&&r&&"in-out"!==r&&"out-in"!==r&&Aa("invalid <transition> mode: "+r,this.$parent);var i=a[0];if(ha(this.$vnode))return i;var o=ua(i);if(!o)return i;if(this._leaving)return ca(e,i);var d="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?d+"comment":d+o.tag:s(o.key)?0===String(o.key).indexOf(d)?o.key:d+o.key:o.key;var u=(o.data||(o.data={})).transition=la(this),l=this._vnode,c=ua(l);if(o.data.directives&&o.data.directives.some(function(e){return"show"===e.name})&&(o.data.show=!0),c&&c.data&&!_a(o,c)&&!ge(c)){var h=c&&(c.data.transition=M({},u));if("out-in"===r)return this._leaving=!0,de(h,"afterLeave",function(){n._leaving=!1,n.$forceUpdate()}),ca(e,i);if("in-out"===r){if(ge(o))return l;var _,m=function(){_()};de(u,"afterEnter",m),de(u,"enterCancelled",m),de(h,"delayLeave",function(e){_=e})}}return i}}},ao=M({tag:String,moveClass:String},to);delete ao.mode;var ro={props:ao,render:function(e){for(var n=this.tag||this.$vnode.data.tag||"span",a=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],s=la(this),d=0;d<i.length;d++){var u=i[d];if(u.tag)if(null!=u.key&&0!==String(u.key).indexOf("__vlist"))o.push(u),a[u.key]=u,(u.data||(u.data={})).transition=s;else if("production"!==t.env.NODE_ENV){var l=u.componentOptions,c=l?l.Ctor.options.name||l.tag||"":u.tag;Aa("<transition-group> children must be keyed: <"+c+">")}}if(r){for(var h=[],_=[],m=0;m<r.length;m++){var f=r[m];f.data.transition=s,f.data.pos=f.elm.getBoundingClientRect(),a[f.key]?h.push(f):_.push(f)}this.kept=e(n,null,h),this.removed=_}return e(n,null,o)},beforeUpdate:function(){this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";if(e.length&&this.hasMove(e[0].elm,t)){e.forEach(ma),e.forEach(fa),e.forEach(pa);var n=document.body;n.offsetHeight;e.forEach(function(e){if(e.data.moved){var n=e.elm,a=n.style;Vn(n,t),a.transform=a.WebkitTransform=a.transitionDuration="",n.addEventListener(Vi,n._moveCb=function e(a){a&&!/transform$/.test(a.propertyName)||(n.removeEventListener(Vi,e),n._moveCb=null,Bn(n,t))})}})}},methods:{hasMove:function(e,t){if(!Ii)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){Nn(n,e)}),In(n,t),n.style.display="none",this.$el.appendChild(n);var a=Jn(n);return this.$el.removeChild(n),this._hasMove=a.hasTransform}}},io={Transition:no,TransitionGroup:ro};Pt.config.mustUseProp=ii,Pt.config.isReservedTag=fi,Pt.config.isReservedAttr=ai,Pt.config.getTagNamespace=Qt,Pt.config.isUnknownElement=Xt,M(Pt.options.directives,eo),M(Pt.options.components,io),Pt.prototype.__patch__=Va?Zi:b,Pt.prototype.$mount=function(e,t){return e=e&&Va?en(e):void 0,je(this,e,t)},setTimeout(function(){Ha.devtools&&(ar?ar.emit("init",Pt):"production"!==t.env.NODE_ENV&&Ka&&console[console.info?"info":"log"]("Download the Vue Devtools extension for a better development experience:\nhttps://github.com/vuejs/vue-devtools")),"production"!==t.env.NODE_ENV&&Ha.productionTip!==!1&&Va&&"undefined"!=typeof console&&console[console.info?"info":"log"]("You are running Vue in development mode.\nMake sure to turn on production mode when deploying for production.\nSee more tips at https://vuejs.org/guide/deployment.html")},0),e.exports=Pt}).call(t,n(228),function(){return this}())},function(e,t,n){"use strict";e.exports={},e.exports.Arc=n(176),e.exports.Line=n(177),e.exports.Point=n(178),e.exports.Rectangle=n(179)},function(e,t,n){"use strict";var a=n(2);e.exports={generators:{linear:function(e,t){var n,r=[];if(e.stepSize&&e.stepSize>0)n=e.stepSize;else{var i=a.niceNum(t.max-t.min,!1);n=a.niceNum(i/(e.maxTicks-1),!0)}var o=Math.floor(t.min/n)*n,s=Math.ceil(t.max/n)*n;e.min&&e.max&&e.stepSize&&a.almostWhole((e.max-e.min)/e.stepSize,n/1e3)&&(o=e.min,s=e.max);var d=(s-o)/n;d=a.almostEquals(d,Math.round(d),n/1e3)?Math.round(d):Math.ceil(d),r.push(void 0!==e.min?e.min:o);for(var u=1;u<d;++u)r.push(o+u*n);return r.push(void 0!==e.max?e.max:s),r},logarithmic:function(e,t){var n,r,i=[],o=a.valueOrDefault,s=o(e.min,Math.pow(10,Math.floor(a.log10(t.min)))),d=Math.floor(a.log10(t.max)),u=Math.ceil(t.max/Math.pow(10,d));0===s?(n=Math.floor(a.log10(t.minNotZero)),r=Math.floor(t.minNotZero/Math.pow(10,n)),i.push(s),s=r*Math.pow(10,n)):(n=Math.floor(a.log10(s)),r=Math.floor(s/Math.pow(10,n)));do i.push(s),++r,10===r&&(r=1,++n),s=r*Math.pow(10,n);while(n<d||n===d&&r<u);var l=o(e.max,s);return i.push(l),i}},formatters:{values:function(e){return a.isArray(e)?e:""+e},linear:function(e,t,n){var r=n.length>3?n[2]-n[1]:n[1]-n[0];Math.abs(r)>1&&e!==Math.floor(e)&&(r=e-Math.floor(e));var i=a.log10(Math.abs(r)),o="";if(0!==e){var s=-1*Math.floor(i);s=Math.max(Math.min(s,20),0),o=e.toFixed(s)}else o="0";return o},logarithmic:function(e,t,n){var r=e/Math.pow(10,Math.floor(a.log10(e)));return 0===e?"0":1===r||2===r||5===r||0===t||t===n.length-1?e.toExponential():""}}}},function(e,t){"use strict";var n={noop:function(){},uid:function(){var e=0;return function(){return e++}}(),isNullOrUndef:function(e){return null===e||"undefined"==typeof e},isArray:Array.isArray?Array.isArray:function(e){return"[object Array]"===Object.prototype.toString.call(e)},isObject:function(e){return null!==e&&"[object Object]"===Object.prototype.toString.call(e)},valueOrDefault:function(e,t){return"undefined"==typeof e?t:e},valueAtIndexOrDefault:function(e,t,a){return n.valueOrDefault(n.isArray(e)?e[t]:e,a)},callback:function(e,t,n){if(e&&"function"==typeof e.call)return e.apply(n,t)},each:function(e,t,a,r){var i,o,s;if(n.isArray(e))if(o=e.length,r)for(i=o-1;i>=0;i--)t.call(a,e[i],i);else for(i=0;i<o;i++)t.call(a,e[i],i);else if(n.isObject(e))for(s=Object.keys(e),o=s.length,i=0;i<o;i++)t.call(a,e[s[i]],s[i])},arrayEquals:function(e,t){var a,r,i,o;if(!e||!t||e.length!==t.length)return!1;for(a=0,r=e.length;a<r;++a)if(i=e[a],o=t[a],i instanceof Array&&o instanceof Array){if(!n.arrayEquals(i,o))return!1}else if(i!==o)return!1;return!0},clone:function(e){if(n.isArray(e))return e.map(n.clone);if(n.isObject(e)){for(var t={},a=Object.keys(e),r=a.length,i=0;i<r;++i)t[a[i]]=n.clone(e[a[i]]);return t}return e},_merger:function(e,t,a,r){var i=t[e],o=a[e];n.isObject(i)&&n.isObject(o)?n.merge(i,o,r):t[e]=n.clone(o)},_mergerIf:function(e,t,a){var r=t[e],i=a[e];n.isObject(r)&&n.isObject(i)?n.mergeIf(r,i):t.hasOwnProperty(e)||(t[e]=n.clone(i))},merge:function(e,t,a){var r,i,o,s,d,u=n.isArray(t)?t:[t],l=u.length;if(!n.isObject(e))return e;for(a=a||{},r=a.merger||n._merger,i=0;i<l;++i)if(t=u[i],n.isObject(t))for(o=Object.keys(t),d=0,s=o.length;d<s;++d)r(o[d],e,t,a);return e},mergeIf:function(e,t){return n.merge(e,t,{merger:n._mergerIf})}};e.exports=n,n.callCallback=n.callback,n.indexOf=function(e,t,n){return Array.prototype.indexOf.call(e,t,n)},n.getValueOrDefault=n.valueOrDefault,n.getValueAtIndexOrDefault=n.valueAtIndexOrDefault},function(e,t){var n=e.exports={version:"2.4.0"};"number"==typeof __e&&(__e=n)},function(e,t,n){e.exports=!n(13)(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a})},function(e,t){e.exports=function(e){try{return!!e()}catch(e){return!0}}},function(e,t){var n=e.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=n)},function(e,t){e.exports=function(e){return"object"==typeof e?null!==e:"function"==typeof e}},function(e,t,n){e.exports={default:n(198),__esModule:!0}},function(e,t,n){e.exports={default:n(199),__esModule:!0}},function(e,t,n){"use strict";function a(e,t){return e.native?{x:e.x,y:e.y}:u.getRelativePosition(e,t)}function r(e,t){var n,a,r,i,o,s=e.data.datasets;for(a=0,i=s.length;a<i;++a)if(e.isDatasetVisible(a))for(n=e.getDatasetMeta(a),r=0,o=n.data.length;r<o;++r){var d=n.data[r];d._view.skip||t(d)}}function i(e,t){var n=[];return r(e,function(e){e.inRange(t.x,t.y)&&n.push(e)}),n}function o(e,t,n,a){var i=Number.POSITIVE_INFINITY,o=[];return r(e,function(e){if(!n||e.inRange(t.x,t.y)){var r=e.getCenterPoint(),s=a(t,r);s<i?(o=[e],i=s):s===i&&o.push(e)}}),o}function s(e){var t=e.indexOf("x")!==-1,n=e.indexOf("y")!==-1;return function(e,a){var r=t?Math.abs(e.x-a.x):0,i=n?Math.abs(e.y-a.y):0;return Math.sqrt(Math.pow(r,2)+Math.pow(i,2))}}function d(e,t,n){var r=a(t,e);n.axis=n.axis||"x";var d=s(n.axis),u=n.intersect?i(e,r):o(e,r,!1,d),l=[];return u.length?(e.data.datasets.forEach(function(t,n){if(e.isDatasetVisible(n)){var a=e.getDatasetMeta(n),r=a.data[u[0]._index];r&&!r._view.skip&&l.push(r)}}),l):[]}var u=n(2);e.exports={modes:{single:function(e,t){var n=a(t,e),i=[];return r(e,function(e){if(e.inRange(n.x,n.y))return i.push(e),i}),i.slice(0,1)},label:d,index:d,dataset:function(e,t,n){var r=a(t,e);n.axis=n.axis||"xy";var d=s(n.axis),u=n.intersect?i(e,r):o(e,r,!1,d);return u.length>0&&(u=e.getDatasetMeta(u[0]._datasetIndex).data),u},"x-axis":function(e,t){return d(e,t,{intersect:!0})},point:function(e,t){var n=a(t,e);return i(e,n)},nearest:function(e,t,n){var r=a(t,e);n.axis=n.axis||"xy";var i=s(n.axis),d=o(e,r,n.intersect,i);return d.length>1&&d.sort(function(e,t){var n=e.getArea(),a=t.getArea(),r=n-a;return 0===r&&(r=e._datasetIndex-t._datasetIndex),r}),d.slice(0,1)},x:function(e,t,n){var i=a(t,e),o=[],s=!1;return r(e,function(e){e.inXRange(i.x)&&o.push(e),e.inRange(i.x,i.y)&&(s=!0)}),n.intersect&&!s&&(o=[]),o},y:function(e,t,n){var i=a(t,e),o=[],s=!1;return r(e,function(e){e.inYRange(i.y)&&o.push(e),e.inRange(i.x,i.y)&&(s=!0)}),n.intersect&&!s&&(o=[]),o}}}},function(e,t,n){"use strict";var a=n(2),r=n(183),i=n(184),o=i._enabled?i:r;e.exports=a.extend({initialize:function(){},acquireContext:function(){},releaseContext:function(){},addEventListener:function(){},removeEventListener:function(){}},o)},function(e,t,n){var a=n(196),r=n(194),i=function(e){if(e instanceof i)return e;if(!(this instanceof i))return new i(e);this.valid=!1,this.values={rgb:[0,0,0],hsl:[0,0,0],hsv:[0,0,0],hwb:[0,0,0],cmyk:[0,0,0,0],alpha:1};var t;"string"==typeof e?(t=r.getRgba(e),t?this.setValues("rgb",t):(t=r.getHsla(e))?this.setValues("hsl",t):(t=r.getHwb(e))&&this.setValues("hwb",t)):"object"==typeof e&&(t=e,void 0!==t.r||void 0!==t.red?this.setValues("rgb",t):void 0!==t.l||void 0!==t.lightness?this.setValues("hsl",t):void 0!==t.v||void 0!==t.value?this.setValues("hsv",t):void 0!==t.w||void 0!==t.whiteness?this.setValues("hwb",t):void 0===t.c&&void 0===t.cyan||this.setValues("cmyk",t))};i.prototype={isValid:function(){return this.valid},rgb:function(){return this.setSpace("rgb",arguments)},hsl:function(){return this.setSpace("hsl",arguments)},hsv:function(){return this.setSpace("hsv",arguments)},hwb:function(){return this.setSpace("hwb",arguments)},cmyk:function(){return this.setSpace("cmyk",arguments)},rgbArray:function(){return this.values.rgb},hslArray:function(){return this.values.hsl},hsvArray:function(){return this.values.hsv},hwbArray:function(){var e=this.values;return 1!==e.alpha?e.hwb.concat([e.alpha]):e.hwb},cmykArray:function(){return this.values.cmyk},rgbaArray:function(){var e=this.values;return e.rgb.concat([e.alpha])},hslaArray:function(){var e=this.values;return e.hsl.concat([e.alpha])},alpha:function(e){return void 0===e?this.values.alpha:(this.setValues("alpha",e),this)},red:function(e){return this.setChannel("rgb",0,e)},green:function(e){return this.setChannel("rgb",1,e)},blue:function(e){return this.setChannel("rgb",2,e)},hue:function(e){return e&&(e%=360,e=e<0?360+e:e),this.setChannel("hsl",0,e)},saturation:function(e){return this.setChannel("hsl",1,e)},lightness:function(e){return this.setChannel("hsl",2,e)},saturationv:function(e){return this.setChannel("hsv",1,e)},whiteness:function(e){return this.setChannel("hwb",1,e)},blackness:function(e){return this.setChannel("hwb",2,e)},value:function(e){return this.setChannel("hsv",2,e)},cyan:function(e){return this.setChannel("cmyk",0,e)},magenta:function(e){return this.setChannel("cmyk",1,e)},yellow:function(e){return this.setChannel("cmyk",2,e)},black:function(e){return this.setChannel("cmyk",3,e)},hexString:function(){return r.hexString(this.values.rgb)},rgbString:function(){return r.rgbString(this.values.rgb,this.values.alpha)},rgbaString:function(){return r.rgbaString(this.values.rgb,this.values.alpha)},percentString:function(){return r.percentString(this.values.rgb,this.values.alpha)},hslString:function(){return r.hslString(this.values.hsl,this.values.alpha)},hslaString:function(){return r.hslaString(this.values.hsl,this.values.alpha)},hwbString:function(){return r.hwbString(this.values.hwb,this.values.alpha)},keyword:function(){return r.keyword(this.values.rgb,this.values.alpha)},rgbNumber:function(){var e=this.values.rgb;return e[0]<<16|e[1]<<8|e[2]},luminosity:function(){for(var e=this.values.rgb,t=[],n=0;n<e.length;n++){var a=e[n]/255;t[n]=a<=.03928?a/12.92:Math.pow((a+.055)/1.055,2.4)}return.2126*t[0]+.7152*t[1]+.0722*t[2]},contrast:function(e){var t=this.luminosity(),n=e.luminosity();return t>n?(t+.05)/(n+.05):(n+.05)/(t+.05)},level:function(e){var t=this.contrast(e);return t>=7.1?"AAA":t>=4.5?"AA":""},dark:function(){var e=this.values.rgb,t=(299*e[0]+587*e[1]+114*e[2])/1e3;return t<128},light:function(){return!this.dark()},negate:function(){for(var e=[],t=0;t<3;t++)e[t]=255-this.values.rgb[t];return this.setValues("rgb",e),this},lighten:function(e){var t=this.values.hsl;return t[2]+=t[2]*e,this.setValues("hsl",t),this},darken:function(e){var t=this.values.hsl;return t[2]-=t[2]*e,this.setValues("hsl",t),this},saturate:function(e){var t=this.values.hsl;return t[1]+=t[1]*e,this.setValues("hsl",t),this},desaturate:function(e){var t=this.values.hsl;return t[1]-=t[1]*e,this.setValues("hsl",t),this},whiten:function(e){var t=this.values.hwb;return t[1]+=t[1]*e,this.setValues("hwb",t),this},blacken:function(e){var t=this.values.hwb;return t[2]+=t[2]*e,this.setValues("hwb",t),this},greyscale:function(){var e=this.values.rgb,t=.3*e[0]+.59*e[1]+.11*e[2];return this.setValues("rgb",[t,t,t]),this},clearer:function(e){var t=this.values.alpha;return this.setValues("alpha",t-t*e),this},opaquer:function(e){var t=this.values.alpha;return this.setValues("alpha",t+t*e),this},rotate:function(e){var t=this.values.hsl,n=(t[0]+e)%360;return t[0]=n<0?360+n:n,this.setValues("hsl",t),this},mix:function(e,t){var n=this,a=e,r=void 0===t?.5:t,i=2*r-1,o=n.alpha()-a.alpha(),s=((i*o===-1?i:(i+o)/(1+i*o))+1)/2,d=1-s;return this.rgb(s*n.red()+d*a.red(),s*n.green()+d*a.green(),s*n.blue()+d*a.blue()).alpha(n.alpha()*r+a.alpha()*(1-r))},toJSON:function(){return this.rgb()},clone:function(){var e,t,n=new i,a=this.values,r=n.values;for(var o in a)a.hasOwnProperty(o)&&(e=a[o],t={}.toString.call(e),"[object Array]"===t?r[o]=e.slice(0):"[object Number]"===t?r[o]=e:console.error("unexpected color value:",e));return n}},i.prototype.spaces={rgb:["red","green","blue"],hsl:["hue","saturation","lightness"],hsv:["hue","saturation","value"],hwb:["hue","whiteness","blackness"],cmyk:["cyan","magenta","yellow","black"]},i.prototype.maxes={rgb:[255,255,255],hsl:[360,100,100],hsv:[360,100,100],hwb:[360,100,100],cmyk:[100,100,100,100]},i.prototype.getValues=function(e){for(var t=this.values,n={},a=0;a<e.length;a++)n[e.charAt(a)]=t[e][a];return 1!==t.alpha&&(n.a=t.alpha),n},i.prototype.setValues=function(e,t){var n,r=this.values,i=this.spaces,o=this.maxes,s=1;if(this.valid=!0,"alpha"===e)s=t;else if(t.length)r[e]=t.slice(0,e.length),s=t[e.length];else if(void 0!==t[e.charAt(0)]){for(n=0;n<e.length;n++)r[e][n]=t[e.charAt(n)];s=t.a}else if(void 0!==t[i[e][0]]){var d=i[e];for(n=0;n<e.length;n++)r[e][n]=t[d[n]];s=t.alpha}if(r.alpha=Math.max(0,Math.min(1,void 0===s?r.alpha:s)),"alpha"===e)return!1;var u;for(n=0;n<e.length;n++)u=Math.max(0,Math.min(o[e][n],r[e][n])),r[e][n]=Math.round(u);for(var l in i)l!==e&&(r[l]=a[e][l](r[e]));return!0},i.prototype.setSpace=function(e,t){var n=t[0];return void 0===n?this.getValues(e):("number"==typeof n&&(n=Array.prototype.slice.call(t)),this.setValues(e,n),this)},i.prototype.setChannel=function(e,t,n){var a=this.values[e];return void 0===n?a[t]:n===a[t]?this:(a[t]=n,this.setValues(e,a),this)},"undefined"!=typeof window&&(window.Color=i),e.exports=i},function(e,t){e.exports=function(e){if(void 0==e)throw TypeError("Can't call method on  "+e);return e}},function(e,t){var n=Math.ceil,a=Math.floor;e.exports=function(e){return isNaN(e=+e)?0:(e>0?a:n)(e)}},function(e,t,n){var a=n(211),r=n(21);e.exports=function(e){return a(r(e))}},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("af",{months:"Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des".split("_"),weekdays:"Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag".split("_"),weekdaysShort:"Son_Maa_Din_Woe_Don_Vry_Sat".split("_"),weekdaysMin:"So_Ma_Di_Wo_Do_Vr_Sa".split("_"),meridiemParse:/vm|nm/i,isPM:function(e){return/^nm$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"vm":"VM":n?"nm":"NM"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Vandag om] LT",nextDay:"[Môre om] LT",nextWeek:"dddd [om] LT",lastDay:"[Gister om] LT",lastWeek:"[Laas] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oor %s",past:"%s gelede",s:"'n paar sekondes",m:"'n minuut",mm:"%d minute",h:"'n uur",hh:"%d ure",d:"'n dag",dd:"%d dae",M:"'n maand",MM:"%d maande",y:"'n jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ar-dz",{months:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"أح_إث_ثلا_أر_خم_جم_سب".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:0,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ar-kw",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:0,doy:12}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"1",2:"2",3:"3",4:"4",5:"5",6:"6",7:"7",8:"8",9:"9",0:"0"},n=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},a={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},r=function(e){return function(t,r,i,o){var s=n(t),d=a[e][n(t)];return 2===s&&(d=d[r?0:1]),d.replace(/%d/i,t)}},i=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"],o=e.defineLocale("ar-ly",{months:i,monthsShort:i,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:r("s"),m:r("m"),mm:r("m"),h:r("h"),hh:r("h"),d:r("d"),dd:r("d"),M:r("M"),MM:r("M"),y:r("y"),yy:r("y")},preparse:function(e){return e.replace(/\u200f/g,"").replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]}).replace(/,/g,"،")},week:{dow:6,doy:12}});return o})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ar-ma",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:6,doy:12}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},a=e.defineLocale("ar-sa",{months:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,function(e){return n[e]}).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]}).replace(/,/g,"،")},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ar-tn",{months:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},a=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},r={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],
+y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},i=function(e){return function(t,n,i,o){var s=a(t),d=r[e][a(t)];return 2===s&&(d=d[n?0:1]),d.replace(/%d/i,t)}},o=["كانون الثاني يناير","شباط فبراير","آذار مارس","نيسان أبريل","أيار مايو","حزيران يونيو","تموز يوليو","آب أغسطس","أيلول سبتمبر","تشرين الأول أكتوبر","تشرين الثاني نوفمبر","كانون الأول ديسمبر"],s=e.defineLocale("ar",{months:o,monthsShort:o,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:i("s"),m:i("m"),mm:i("m"),h:i("h"),hh:i("h"),d:i("d"),dd:i("d"),M:i("M"),MM:i("M"),y:i("y"),yy:i("y")},preparse:function(e){return e.replace(/\u200f/g,"").replace(/[١٢٣٤٥٦٧٨٩٠]/g,function(e){return n[e]}).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]}).replace(/,/g,"،")},week:{dow:6,doy:12}});return s})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"-inci",5:"-inci",8:"-inci",70:"-inci",80:"-inci",2:"-nci",7:"-nci",20:"-nci",50:"-nci",3:"-üncü",4:"-üncü",100:"-üncü",6:"-ncı",9:"-uncu",10:"-uncu",30:"-uncu",60:"-ıncı",90:"-ıncı"},n=e.defineLocale("az",{months:"yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr".split("_"),monthsShort:"yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek".split("_"),weekdays:"Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə".split("_"),weekdaysShort:"Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən".split("_"),weekdaysMin:"Bz_BE_ÇA_Çə_CA_Cü_Şə".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[sabah saat] LT",nextWeek:"[gələn həftə] dddd [saat] LT",lastDay:"[dünən] LT",lastWeek:"[keçən həftə] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s əvvəl",s:"birneçə saniyyə",m:"bir dəqiqə",mm:"%d dəqiqə",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir il",yy:"%d il"},meridiemParse:/gecə|səhər|gündüz|axşam/,isPM:function(e){return/^(gündüz|axşam)$/.test(e)},meridiem:function(e,t,n){return e<4?"gecə":e<12?"səhər":e<17?"gündüz":"axşam"},dayOfMonthOrdinalParse:/\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,ordinal:function(e){if(0===e)return e+"-ıncı";var n=e%10,a=e%100-n,r=e>=100?100:null;return e+(t[n]||t[a]||t[r])},week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t){var n=e.split("_");return t%10===1&&t%100!==11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,a){var r={mm:n?"хвіліна_хвіліны_хвілін":"хвіліну_хвіліны_хвілін",hh:n?"гадзіна_гадзіны_гадзін":"гадзіну_гадзіны_гадзін",dd:"дзень_дні_дзён",MM:"месяц_месяцы_месяцаў",yy:"год_гады_гадоў"};return"m"===a?n?"хвіліна":"хвіліну":"h"===a?n?"гадзіна":"гадзіну":e+" "+t(r[a],+e)}var a=e.defineLocale("be",{months:{format:"студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня".split("_"),standalone:"студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань".split("_")},monthsShort:"студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж".split("_"),weekdays:{format:"нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу".split("_"),standalone:"нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота".split("_"),isFormat:/\[ ?[Вв] ?(?:мінулую|наступную)? ?\] ?dddd/},weekdaysShort:"нд_пн_ат_ср_чц_пт_сб".split("_"),weekdaysMin:"нд_пн_ат_ср_чц_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., HH:mm",LLLL:"dddd, D MMMM YYYY г., HH:mm"},calendar:{sameDay:"[Сёння ў] LT",nextDay:"[Заўтра ў] LT",lastDay:"[Учора ў] LT",nextWeek:function(){return"[У] dddd [ў] LT"},lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return"[У мінулую] dddd [ў] LT";case 1:case 2:case 4:return"[У мінулы] dddd [ў] LT"}},sameElse:"L"},relativeTime:{future:"праз %s",past:"%s таму",s:"некалькі секунд",m:n,mm:n,h:n,hh:n,d:"дзень",dd:n,M:"месяц",MM:n,y:"год",yy:n},meridiemParse:/ночы|раніцы|дня|вечара/,isPM:function(e){return/^(дня|вечара)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночы":e<12?"раніцы":e<17?"дня":"вечара"},dayOfMonthOrdinalParse:/\d{1,2}-(і|ы|га)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e%10!==2&&e%10!==3||e%100===12||e%100===13?e+"-ы":e+"-і";case"D":return e+"-га";default:return e}},week:{dow:1,doy:7}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("bg",{months:"януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември".split("_"),monthsShort:"янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек".split("_"),weekdays:"неделя_понеделник_вторник_сряда_четвъртък_петък_събота".split("_"),weekdaysShort:"нед_пон_вто_сря_чет_пет_съб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Днес в] LT",nextDay:"[Утре в] LT",nextWeek:"dddd [в] LT",lastDay:"[Вчера в] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[В изминалата] dddd [в] LT";case 1:case 2:case 4:case 5:return"[В изминалия] dddd [в] LT"}},sameElse:"L"},relativeTime:{future:"след %s",past:"преди %s",s:"няколко секунди",m:"минута",mm:"%d минути",h:"час",hh:"%d часа",d:"ден",dd:"%d дни",M:"месец",MM:"%d месеца",y:"година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,n=e%100;return 0===e?e+"-ев":0===n?e+"-ен":n>10&&n<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"১",2:"২",3:"৩",4:"৪",5:"৫",6:"৬",7:"৭",8:"৮",9:"৯",0:"০"},n={"১":"1","২":"2","৩":"3","৪":"4","৫":"5","৬":"6","৭":"7","৮":"8","৯":"9","০":"0"},a=e.defineLocale("bn",{months:"জানুয়ারী_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর".split("_"),monthsShort:"জানু_ফেব_মার্চ_এপ্র_মে_জুন_জুল_আগ_সেপ্ট_অক্টো_নভে_ডিসে".split("_"),weekdays:"রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার".split("_"),weekdaysShort:"রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি".split("_"),weekdaysMin:"রবি_সোম_মঙ্গ_বুধ_বৃহঃ_শুক্র_শনি".split("_"),longDateFormat:{LT:"A h:mm সময়",LTS:"A h:mm:ss সময়",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm সময়",LLLL:"dddd, D MMMM YYYY, A h:mm সময়"},calendar:{sameDay:"[আজ] LT",nextDay:"[আগামীকাল] LT",nextWeek:"dddd, LT",lastDay:"[গতকাল] LT",lastWeek:"[গত] dddd, LT",sameElse:"L"},relativeTime:{future:"%s পরে",past:"%s আগে",s:"কয়েক সেকেন্ড",m:"এক মিনিট",mm:"%d মিনিট",h:"এক ঘন্টা",hh:"%d ঘন্টা",d:"এক দিন",dd:"%d দিন",M:"এক মাস",MM:"%d মাস",y:"এক বছর",yy:"%d বছর"},preparse:function(e){return e.replace(/[১২৩৪৫৬৭৮৯০]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},meridiemParse:/রাত|সকাল|দুপুর|বিকাল|রাত/,meridiemHour:function(e,t){return 12===e&&(e=0),"রাত"===t&&e>=4||"দুপুর"===t&&e<5||"বিকাল"===t?e+12:e},meridiem:function(e,t,n){return e<4?"রাত":e<10?"সকাল":e<17?"দুপুর":e<20?"বিকাল":"রাত"},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"༡",2:"༢",3:"༣",4:"༤",5:"༥",6:"༦",7:"༧",8:"༨",9:"༩",0:"༠"},n={"༡":"1","༢":"2","༣":"3","༤":"4","༥":"5","༦":"6","༧":"7","༨":"8","༩":"9","༠":"0"},a=e.defineLocale("bo",{months:"ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ".split("_"),monthsShort:"ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ".split("_"),weekdays:"གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་".split("_"),weekdaysShort:"ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་".split("_"),weekdaysMin:"ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[དི་རིང] LT",nextDay:"[སང་ཉིན] LT",nextWeek:"[བདུན་ཕྲག་རྗེས་མ], LT",lastDay:"[ཁ་སང] LT",lastWeek:"[བདུན་ཕྲག་མཐའ་མ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ལ་",past:"%s སྔན་ལ",s:"ལམ་སང",m:"སྐར་མ་གཅིག",mm:"%d སྐར་མ",h:"ཆུ་ཚོད་གཅིག",hh:"%d ཆུ་ཚོད",d:"ཉིན་གཅིག",dd:"%d ཉིན་",M:"ཟླ་བ་གཅིག",MM:"%d ཟླ་བ",y:"ལོ་གཅིག",yy:"%d ལོ"},preparse:function(e){return e.replace(/[༡༢༣༤༥༦༧༨༩༠]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},meridiemParse:/མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,meridiemHour:function(e,t){return 12===e&&(e=0),"མཚན་མོ"===t&&e>=4||"ཉིན་གུང"===t&&e<5||"དགོང་དག"===t?e+12:e},meridiem:function(e,t,n){return e<4?"མཚན་མོ":e<10?"ཞོགས་ཀས":e<17?"ཉིན་གུང":e<20?"དགོང་དག":"མཚན་མོ"},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n){var a={mm:"munutenn",MM:"miz",dd:"devezh"};return e+" "+r(a[n],e)}function n(e){switch(a(e)){case 1:case 3:case 4:case 5:case 9:return e+" bloaz";default:return e+" vloaz"}}function a(e){return e>9?a(e%10):e}function r(e,t){return 2===t?i(e):e}function i(e){var t={m:"v",b:"v",d:"z"};return void 0===t[e.charAt(0)]?e:t[e.charAt(0)]+e.substring(1)}var o=e.defineLocale("br",{months:"Genver_C'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu".split("_"),monthsShort:"Gen_C'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker".split("_"),weekdays:"Sul_Lun_Meurzh_Merc'her_Yaou_Gwener_Sadorn".split("_"),weekdaysShort:"Sul_Lun_Meu_Mer_Yao_Gwe_Sad".split("_"),weekdaysMin:"Su_Lu_Me_Mer_Ya_Gw_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h[e]mm A",LTS:"h[e]mm:ss A",L:"DD/MM/YYYY",LL:"D [a viz] MMMM YYYY",LLL:"D [a viz] MMMM YYYY h[e]mm A",LLLL:"dddd, D [a viz] MMMM YYYY h[e]mm A"},calendar:{sameDay:"[Hiziv da] LT",nextDay:"[Warc'hoazh da] LT",nextWeek:"dddd [da] LT",lastDay:"[Dec'h da] LT",lastWeek:"dddd [paset da] LT",sameElse:"L"},relativeTime:{future:"a-benn %s",past:"%s 'zo",s:"un nebeud segondennoù",m:"ur vunutenn",mm:t,h:"un eur",hh:"%d eur",d:"un devezh",dd:t,M:"ur miz",MM:t,y:"ur bloaz",yy:n},dayOfMonthOrdinalParse:/\d{1,2}(añ|vet)/,ordinal:function(e){var t=1===e?"añ":"vet";return e+t},week:{dow:1,doy:4}});return o})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n){var a=e+" ";switch(n){case"m":return t?"jedna minuta":"jedne minute";case"mm":return a+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return a+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return a+=1===e?"dan":"dana";case"MM":return a+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return a+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}var n=e.defineLocale("bs",{months:"januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:case 3:return"[prošlu] dddd [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ca",{months:{standalone:"gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre".split("_"),format:"de gener_de febrer_de març_d'abril_de maig_de juny_de juliol_d'agost_de setembre_d'octubre_de novembre_de desembre".split("_"),isFormat:/D[oD]?(\s)+MMMM/},monthsShort:"gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.".split("_"),monthsParseExact:!0,weekdays:"diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte".split("_"),weekdaysShort:"dg._dl._dt._dc._dj._dv._ds.".split("_"),weekdaysMin:"Dg_Dl_Dt_Dc_Dj_Dv_Ds".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"[el] D MMMM [de] YYYY",ll:"D MMM YYYY",LLL:"[el] D MMMM [de] YYYY [a les] H:mm",lll:"D MMM YYYY, H:mm",LLLL:"[el] dddd D MMMM [de] YYYY [a les] H:mm",llll:"ddd D MMM YYYY, H:mm"},calendar:{sameDay:function(){return"[avui a "+(1!==this.hours()?"les":"la")+"] LT"},nextDay:function(){return"[demà a "+(1!==this.hours()?"les":"la")+"] LT"},nextWeek:function(){return"dddd [a "+(1!==this.hours()?"les":"la")+"] LT"},lastDay:function(){return"[ahir a "+(1!==this.hours()?"les":"la")+"] LT"},lastWeek:function(){return"[el] dddd [passat a "+(1!==this.hours()?"les":"la")+"] LT"},sameElse:"L"},relativeTime:{future:"d'aquí %s",past:"fa %s",s:"uns segons",m:"un minut",mm:"%d minuts",h:"una hora",hh:"%d hores",d:"un dia",dd:"%d dies",M:"un mes",MM:"%d mesos",y:"un any",yy:"%d anys"},dayOfMonthOrdinalParse:/\d{1,2}(r|n|t|è|a)/,ordinal:function(e,t){var n=1===e?"r":2===e?"n":3===e?"r":4===e?"t":"è";return"w"!==t&&"W"!==t||(n="a"),e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e){return e>1&&e<5&&1!==~~(e/10)}function n(e,n,a,r){var i=e+" ";switch(a){case"s":return n||r?"pár sekund":"pár sekundami";case"m":return n?"minuta":r?"minutu":"minutou";case"mm":return n||r?i+(t(e)?"minuty":"minut"):i+"minutami";case"h":return n?"hodina":r?"hodinu":"hodinou";case"hh":return n||r?i+(t(e)?"hodiny":"hodin"):i+"hodinami";case"d":return n||r?"den":"dnem";case"dd":return n||r?i+(t(e)?"dny":"dní"):i+"dny";case"M":return n||r?"měsíc":"měsícem";case"MM":return n||r?i+(t(e)?"měsíce":"měsíců"):i+"měsíci";case"y":return n||r?"rok":"rokem";case"yy":return n||r?i+(t(e)?"roky":"let"):i+"lety"}}var a="leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec".split("_"),r="led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro".split("_"),i=e.defineLocale("cs",{months:a,monthsShort:r,monthsParse:function(e,t){var n,a=[];for(n=0;n<12;n++)a[n]=new RegExp("^"+e[n]+"$|^"+t[n]+"$","i");return a}(a,r),shortMonthsParse:function(e){var t,n=[];for(t=0;t<12;t++)n[t]=new RegExp("^"+e[t]+"$","i");return n}(r),longMonthsParse:function(e){var t,n=[];for(t=0;t<12;t++)n[t]=new RegExp("^"+e[t]+"$","i");return n}(a),weekdays:"neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota".split("_"),weekdaysShort:"ne_po_út_st_čt_pá_so".split("_"),weekdaysMin:"ne_po_út_st_čt_pá_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm",l:"D. M. YYYY"},calendar:{sameDay:"[dnes v] LT",nextDay:"[zítra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v neděli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve středu v] LT";case 4:return"[ve čtvrtek v] LT";case 5:return"[v pátek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[včera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou neděli v] LT";case 1:case 2:return"[minulé] dddd [v] LT";case 3:return"[minulou středu v] LT";case 4:case 5:return"[minulý] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"před %s",s:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("cv",{months:"кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав".split("_"),monthsShort:"кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш".split("_"),weekdays:"вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун".split("_"),weekdaysShort:"выр_тун_ытл_юн_кӗҫ_эрн_шӑм".split("_"),weekdaysMin:"вр_тн_ыт_юн_кҫ_эр_шм".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]",LLL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm",LLLL:"dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm"},calendar:{sameDay:"[Паян] LT [сехетре]",nextDay:"[Ыран] LT [сехетре]",lastDay:"[Ӗнер] LT [сехетре]",nextWeek:"[Ҫитес] dddd LT [сехетре]",lastWeek:"[Иртнӗ] dddd LT [сехетре]",sameElse:"L"},relativeTime:{future:function(e){var t=/сехет$/i.exec(e)?"рен":/ҫул$/i.exec(e)?"тан":"ран";return e+t},past:"%s каялла",s:"пӗр-ик ҫеккунт",m:"пӗр минут",mm:"%d минут",h:"пӗр сехет",hh:"%d сехет",d:"пӗр кун",dd:"%d кун",M:"пӗр уйӑх",MM:"%d уйӑх",y:"пӗр ҫул",yy:"%d ҫул"},dayOfMonthOrdinalParse:/\d{1,2}-мӗш/,ordinal:"%d-мӗш",week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("cy",{months:"Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr".split("_"),monthsShort:"Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag".split("_"),weekdays:"Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn".split("_"),weekdaysShort:"Sul_Llun_Maw_Mer_Iau_Gwe_Sad".split("_"),weekdaysMin:"Su_Ll_Ma_Me_Ia_Gw_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Heddiw am] LT",nextDay:"[Yfory am] LT",nextWeek:"dddd [am] LT",lastDay:"[Ddoe am] LT",lastWeek:"dddd [diwethaf am] LT",sameElse:"L"},relativeTime:{future:"mewn %s",past:"%s yn ôl",s:"ychydig eiliadau",m:"munud",mm:"%d munud",h:"awr",hh:"%d awr",d:"diwrnod",dd:"%d diwrnod",M:"mis",MM:"%d mis",y:"blwyddyn",yy:"%d flynedd"},dayOfMonthOrdinalParse:/\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,ordinal:function(e){var t=e,n="",a=["","af","il","ydd","ydd","ed","ed","ed","fed","fed","fed","eg","fed","eg","eg","fed","eg","eg","fed","eg","fed"];return t>20?n=40===t||50===t||60===t||80===t||100===t?"fed":"ain":t>0&&(n=a[t]),e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("da",{months:"januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"søn_man_tir_ons_tor_fre_lør".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd [d.] D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"på dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[i] dddd[s kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"få sekunder",m:"et minut",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dage",M:"en måned",MM:"%d måneder",y:"et år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?r[n][0]:r[n][1]}var n=e.defineLocale("de-at",{months:"Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jän._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?r[n][0]:r[n][1]}var n=e.defineLocale("de-ch",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Febr._März_April_Mai_Juni_Juli_Aug._Sept._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH.mm",LLLL:"dddd, D. MMMM YYYY HH.mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?r[n][0]:r[n][1]}var n=e.defineLocale("de",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=["ޖެނުއަރީ","ފެބްރުއަރީ","މާރިޗު","އޭޕްރީލު","މޭ","ޖޫން","ޖުލައި","އޯގަސްޓު","ސެޕްޓެމްބަރު","އޮކްޓޯބަރު","ނޮވެމްބަރު","ޑިސެމްބަރު"],n=["އާދިއްތަ","ހޯމަ","އަންގާރަ","ބުދަ","ބުރާސްފަތި","ހުކުރު","ހޮނިހިރު"],a=e.defineLocale("dv",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:"އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/M/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/މކ|މފ/,isPM:function(e){return"މފ"===e},meridiem:function(e,t,n){return e<12?"މކ":"މފ"},calendar:{sameDay:"[މިއަދު] LT",nextDay:"[މާދަމާ] LT",nextWeek:"dddd LT",lastDay:"[އިއްޔެ] LT",lastWeek:"[ފާއިތުވި] dddd LT",sameElse:"L"},relativeTime:{future:"ތެރޭގައި %s",past:"ކުރިން %s",s:"ސިކުންތުކޮޅެއް",m:"މިނިޓެއް",mm:"މިނިޓު %d",h:"ގަޑިއިރެއް",hh:"ގަޑިއިރު %d",d:"ދުވަހެއް",dd:"ދުވަސް %d",M:"މަހެއް",MM:"މަސް %d",y:"އަހަރެއް",yy:"އަހަރު %d"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:7,doy:12}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e){return e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}var n=e.defineLocale("el",{monthsNominativeEl:"Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος".split("_"),monthsGenitiveEl:"Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου".split("_"),months:function(e,t){return e?/D/.test(t.substring(0,t.indexOf("MMMM")))?this._monthsGenitiveEl[e.month()]:this._monthsNominativeEl[e.month()]:this._monthsNominativeEl},monthsShort:"Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ".split("_"),weekdays:"Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο".split("_"),weekdaysShort:"Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ".split("_"),weekdaysMin:"Κυ_Δε_Τρ_Τε_Πε_Πα_Σα".split("_"),meridiem:function(e,t,n){return e>11?n?"μμ":"ΜΜ":n?"πμ":"ΠΜ"},isPM:function(e){return"μ"===(e+"").toLowerCase()[0]},meridiemParse:/[ΠΜ]\.?Μ?\.?/i,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendarEl:{sameDay:"[Σήμερα {}] LT",nextDay:"[Αύριο {}] LT",nextWeek:"dddd [{}] LT",lastDay:"[Χθες {}] LT",lastWeek:function(){switch(this.day()){case 6:return"[το προηγούμενο] dddd [{}] LT";default:return"[την προηγούμενη] dddd [{}] LT"}},sameElse:"L"},calendar:function(e,n){var a=this._calendarEl[e],r=n&&n.hours();return t(a)&&(a=a.apply(n)),a.replace("{}",r%12===1?"στη":"στις")},relativeTime:{future:"σε %s",past:"%s πριν",s:"λίγα δευτερόλεπτα",m:"ένα λεπτό",mm:"%d λεπτά",h:"μία ώρα",hh:"%d ώρες",d:"μία μέρα",dd:"%d μέρες",M:"ένας μήνας",MM:"%d μήνες",y:"ένας χρόνος",yy:"%d χρόνια"},dayOfMonthOrdinalParse:/\d{1,2}η/,ordinal:"%dη",week:{dow:1,doy:4}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("en-au",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("en-ca",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"YYYY-MM-DD",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("en-gb",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("en-ie",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("en-nz",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("eo",{months:"januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec".split("_"),weekdays:"dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato".split("_"),weekdaysShort:"dim_lun_mard_merk_ĵaŭ_ven_sab".split("_"),weekdaysMin:"di_lu_ma_me_ĵa_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D[-a de] MMMM, YYYY",LLL:"D[-a de] MMMM, YYYY HH:mm",LLLL:"dddd, [la] D[-a de] MMMM, YYYY HH:mm"},meridiemParse:/[ap]\.t\.m/i,isPM:function(e){return"p"===e.charAt(0).toLowerCase()},meridiem:function(e,t,n){return e>11?n?"p.t.m.":"P.T.M.":n?"a.t.m.":"A.T.M."},calendar:{sameDay:"[Hodiaŭ je] LT",nextDay:"[Morgaŭ je] LT",nextWeek:"dddd [je] LT",lastDay:"[Hieraŭ je] LT",lastWeek:"[pasinta] dddd [je] LT",sameElse:"L"},relativeTime:{future:"post %s",past:"antaŭ %s",s:"sekundoj",m:"minuto",mm:"%d minutoj",h:"horo",hh:"%d horoj",d:"tago",dd:"%d tagoj",M:"monato",MM:"%d monatoj",y:"jaro",yy:"%d jaroj"},dayOfMonthOrdinalParse:/\d{1,2}a/,ordinal:"%da",week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),a=e.defineLocale("es-do",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,a){return e?/-MMM-/.test(a)?n[e.month()]:t[e.month()]:t},monthsParseExact:!0,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY h:mm A",LLLL:"dddd, D [de] MMMM [de] YYYY h:mm A"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),a=e.defineLocale("es",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,a){return e?/-MMM-/.test(a)?n[e.month()]:t[e.month()]:t},monthsParseExact:!0,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r={s:["mõne sekundi","mõni sekund","paar sekundit"],m:["ühe minuti","üks minut"],mm:[e+" minuti",e+" minutit"],h:["ühe tunni","tund aega","üks tund"],hh:[e+" tunni",e+" tundi"],d:["ühe päeva","üks päev"],M:["kuu aja","kuu aega","üks kuu"],MM:[e+" kuu",e+" kuud"],y:["ühe aasta","aasta","üks aasta"],yy:[e+" aasta",e+" aastat"]};return t?r[n][2]?r[n][2]:r[n][1]:a?r[n][0]:r[n][1]}var n=e.defineLocale("et",{months:"jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember".split("_"),monthsShort:"jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets".split("_"),weekdays:"pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev".split("_"),weekdaysShort:"P_E_T_K_N_R_L".split("_"),weekdaysMin:"P_E_T_K_N_R_L".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[Täna,] LT",nextDay:"[Homme,] LT",nextWeek:"[Järgmine] dddd LT",lastDay:"[Eile,] LT",lastWeek:"[Eelmine] dddd LT",sameElse:"L"},relativeTime:{future:"%s pärast",past:"%s tagasi",s:t,m:t,mm:t,h:t,hh:t,d:t,dd:"%d päeva",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("eu",{months:"urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua".split("_"),monthsShort:"urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.".split("_"),monthsParseExact:!0,weekdays:"igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata".split("_"),weekdaysShort:"ig._al._ar._az._og._ol._lr.".split("_"),weekdaysMin:"ig_al_ar_az_og_ol_lr".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY[ko] MMMM[ren] D[a]",LLL:"YYYY[ko] MMMM[ren] D[a] HH:mm",LLLL:"dddd, YYYY[ko] MMMM[ren] D[a] HH:mm",l:"YYYY-M-D",ll:"YYYY[ko] MMM D[a]",lll:"YYYY[ko] MMM D[a] HH:mm",llll:"ddd, YYYY[ko] MMM D[a] HH:mm"},calendar:{sameDay:"[gaur] LT[etan]",nextDay:"[bihar] LT[etan]",nextWeek:"dddd LT[etan]",lastDay:"[atzo] LT[etan]",lastWeek:"[aurreko] dddd LT[etan]",sameElse:"L"},relativeTime:{future:"%s barru",past:"duela %s",s:"segundo batzuk",m:"minutu bat",mm:"%d minutu",h:"ordu bat",hh:"%d ordu",d:"egun bat",dd:"%d egun",M:"hilabete bat",MM:"%d hilabete",y:"urte bat",yy:"%d urte"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"۱",2:"۲",3:"۳",4:"۴",5:"۵",6:"۶",7:"۷",8:"۸",9:"۹",0:"۰"},n={"۱":"1","۲":"2","۳":"3","۴":"4","۵":"5","۶":"6","۷":"7","۸":"8","۹":"9","۰":"0"},a=e.defineLocale("fa",{months:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),monthsShort:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),weekdays:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysShort:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysMin:"ی_د_س_چ_پ_ج_ش".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/قبل از ظهر|بعد از ظهر/,isPM:function(e){return/بعد از ظهر/.test(e)},meridiem:function(e,t,n){return e<12?"قبل از ظهر":"بعد از ظهر"},calendar:{sameDay:"[امروز ساعت] LT",nextDay:"[فردا ساعت] LT",nextWeek:"dddd [ساعت] LT",lastDay:"[دیروز ساعت] LT",lastWeek:"dddd [پیش] [ساعت] LT",sameElse:"L"},relativeTime:{future:"در %s",past:"%s پیش",s:"چند ثانیه",m:"یک دقیقه",mm:"%d دقیقه",h:"یک ساعت",hh:"%d ساعت",d:"یک روز",dd:"%d روز",M:"یک ماه",MM:"%d ماه",y:"یک سال",yy:"%d سال"},preparse:function(e){return e.replace(/[۰-۹]/g,function(e){return n[e]}).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]}).replace(/,/g,"،")},dayOfMonthOrdinalParse:/\d{1,2}م/,ordinal:"%dم",week:{dow:6,doy:12}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,a,r){var i="";switch(a){case"s":return r?"muutaman sekunnin":"muutama sekunti";case"m":return r?"minuutin":"minuutti";case"mm":i=r?"minuutin":"minuuttia";break;case"h":return r?"tunnin":"tunti";case"hh":i=r?"tunnin":"tuntia";break;case"d":return r?"päivän":"päivä";case"dd":i=r?"päivän":"päivää";break;case"M":return r?"kuukauden":"kuukausi";case"MM":i=r?"kuukauden":"kuukautta";break;case"y":return r?"vuoden":"vuosi";case"yy":i=r?"vuoden":"vuotta"}return i=n(e,r)+" "+i}function n(e,t){return e<10?t?r[e]:a[e]:e}var a="nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän".split(" "),r=["nolla","yhden","kahden","kolmen","neljän","viiden","kuuden",a[7],a[8],a[9]],i=e.defineLocale("fi",{months:"tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu".split("_"),monthsShort:"tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu".split("_"),weekdays:"sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai".split("_"),weekdaysShort:"su_ma_ti_ke_to_pe_la".split("_"),weekdaysMin:"su_ma_ti_ke_to_pe_la".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"Do MMMM[ta] YYYY",LLL:"Do MMMM[ta] YYYY, [klo] HH.mm",LLLL:"dddd, Do MMMM[ta] YYYY, [klo] HH.mm",l:"D.M.YYYY",ll:"Do MMM YYYY",lll:"Do MMM YYYY, [klo] HH.mm",llll:"ddd, Do MMM YYYY, [klo] HH.mm"},calendar:{sameDay:"[tänään] [klo] LT",nextDay:"[huomenna] [klo] LT",nextWeek:"dddd [klo] LT",lastDay:"[eilen] [klo] LT",lastWeek:"[viime] dddd[na] [klo] LT",sameElse:"L"},relativeTime:{future:"%s päästä",past:"%s sitten",s:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("fo",{months:"januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_"),weekdays:"sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur".split("_"),weekdaysShort:"sun_mán_týs_mik_hós_frí_ley".split("_"),weekdaysMin:"su_má_tý_mi_hó_fr_le".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D. MMMM, YYYY HH:mm"},calendar:{sameDay:"[Í dag kl.] LT",nextDay:"[Í morgin kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[Í gjár kl.] LT",lastWeek:"[síðstu] dddd [kl] LT",sameElse:"L"},relativeTime:{future:"um %s",past:"%s síðani",s:"fá sekund",m:"ein minutt",mm:"%d minuttir",h:"ein tími",hh:"%d tímar",d:"ein dagur",dd:"%d dagar",M:"ein mánaði",MM:"%d mánaðir",y:"eitt ár",yy:"%d ár"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("fr-ca",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"Di_Lu_Ma_Me_Je_Ve_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("fr-ch",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"Di_Lu_Ma_Me_Je_Ve_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("fr",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"Di_Lu_Ma_Me_Je_Ve_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|)/,ordinal:function(e,t){switch(t){case"D":return e+(1===e?"er":"");default:case"M":case"Q":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t="jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.".split("_"),n="jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_"),a=e.defineLocale("fy",{months:"jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber".split("_"),monthsShort:function(e,a){return e?/-MMM-/.test(a)?n[e.month()]:t[e.month()]:t},monthsParseExact:!0,weekdays:"snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon".split("_"),weekdaysShort:"si._mo._ti._wo._to._fr._so.".split("_"),weekdaysMin:"Si_Mo_Ti_Wo_To_Fr_So".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[hjoed om] LT",nextDay:"[moarn om] LT",nextWeek:"dddd [om] LT",lastDay:"[juster om] LT",lastWeek:"[ôfrûne] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oer %s",past:"%s lyn",s:"in pear sekonden",m:"ien minút",mm:"%d minuten",h:"ien oere",hh:"%d oeren",d:"ien dei",dd:"%d dagen",M:"ien moanne",MM:"%d moannen",y:"ien jier",yy:"%d jierren"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=["Am Faoilleach","An Gearran","Am Màrt","An Giblean","An Cèitean","An t-Ògmhios","An t-Iuchar","An Lùnastal","An t-Sultain","An Dàmhair","An t-Samhain","An Dùbhlachd"],n=["Faoi","Gear","Màrt","Gibl","Cèit","Ògmh","Iuch","Lùn","Sult","Dàmh","Samh","Dùbh"],a=["Didòmhnaich","Diluain","Dimàirt","Diciadain","Diardaoin","Dihaoine","Disathairne"],r=["Did","Dil","Dim","Dic","Dia","Dih","Dis"],i=["Dò","Lu","Mà","Ci","Ar","Ha","Sa"],o=e.defineLocale("gd",{months:t,monthsShort:n,monthsParseExact:!0,weekdays:a,weekdaysShort:r,weekdaysMin:i,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[An-diugh aig] LT",nextDay:"[A-màireach aig] LT",nextWeek:"dddd [aig] LT",lastDay:"[An-dè aig] LT",lastWeek:"dddd [seo chaidh] [aig] LT",sameElse:"L"},relativeTime:{future:"ann an %s",past:"bho chionn %s",s:"beagan diogan",m:"mionaid",mm:"%d mionaidean",h:"uair",hh:"%d uairean",d:"latha",dd:"%d latha",M:"mìos",MM:"%d mìosan",y:"bliadhna",yy:"%d bliadhna"},dayOfMonthOrdinalParse:/\d{1,2}(d|na|mh)/,ordinal:function(e){var t=1===e?"d":e%10===2?"na":"mh";return e+t},week:{dow:1,doy:4}});return o})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("gl",{months:"xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro".split("_"),monthsShort:"xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"domingo_luns_martes_mércores_xoves_venres_sábado".split("_"),weekdaysShort:"dom._lun._mar._mér._xov._ven._sáb.".split("_"),weekdaysMin:"do_lu_ma_mé_xo_ve_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoxe "+(1!==this.hours()?"ás":"á")+"] LT"},nextDay:function(){return"[mañá "+(1!==this.hours()?"ás":"á")+"] LT"},nextWeek:function(){return"dddd ["+(1!==this.hours()?"ás":"a")+"] LT"},lastDay:function(){return"[onte "+(1!==this.hours()?"á":"a")+"] LT"},lastWeek:function(){return"[o] dddd [pasado "+(1!==this.hours()?"ás":"a")+"] LT"},sameElse:"L"},relativeTime:{future:function(e){return 0===e.indexOf("un")?"n"+e:"en "+e},past:"hai %s",s:"uns segundos",m:"un minuto",mm:"%d minutos",h:"unha hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r={s:["thodde secondanim","thodde second"],m:["eka mintan","ek minute"],mm:[e+" mintanim",e+" mintam"],h:["eka horan","ek hor"],hh:[e+" horanim",e+" hor"],d:["eka disan","ek dis"],dd:[e+" disanim",e+" dis"],M:["eka mhoinean","ek mhoino"],MM:[e+" mhoineanim",e+" mhoine"],y:["eka vorsan","ek voros"],yy:[e+" vorsanim",e+" vorsam"]};return t?r[n][0]:r[n][1]}var n=e.defineLocale("gom-latn",{months:"Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr".split("_"),monthsShort:"Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Aitar_Somar_Mongllar_Budvar_Brestar_Sukrar_Son'var".split("_"),weekdaysShort:"Ait._Som._Mon._Bud._Bre._Suk._Son.".split("_"),weekdaysMin:"Ai_Sm_Mo_Bu_Br_Su_Sn".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"A h:mm [vazta]",LTS:"A h:mm:ss [vazta]",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY A h:mm [vazta]",LLLL:"dddd, MMMM[achea] Do, YYYY, A h:mm [vazta]",llll:"ddd, D MMM YYYY, A h:mm [vazta]"},calendar:{sameDay:"[Aiz] LT",nextDay:"[Faleam] LT",nextWeek:"[Ieta to] dddd[,] LT",lastDay:"[Kal] LT",lastWeek:"[Fatlo] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%s",past:"%s adim",s:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}(er)/,ordinal:function(e,t){switch(t){case"D":return e+"er";default:case"M":case"Q":case"DDD":case"d":case"w":case"W":return e}},week:{dow:1,doy:4},meridiemParse:/rati|sokalli|donparam|sanje/,meridiemHour:function(e,t){return 12===e&&(e=0),"rati"===t?e<4?e:e+12:"sokalli"===t?e:"donparam"===t?e>12?e:e+12:"sanje"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"rati":e<12?"sokalli":e<16?"donparam":e<20?"sanje":"rati"}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("he",{months:"ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר".split("_"),monthsShort:"ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳".split("_"),weekdays:"ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת".split("_"),weekdaysShort:"א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳".split("_"),weekdaysMin:"א_ב_ג_ד_ה_ו_ש".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [ב]MMMM YYYY",LLL:"D [ב]MMMM YYYY HH:mm",LLLL:"dddd, D [ב]MMMM YYYY HH:mm",l:"D/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[היום ב־]LT",nextDay:"[מחר ב־]LT",nextWeek:"dddd [בשעה] LT",lastDay:"[אתמול ב־]LT",lastWeek:"[ביום] dddd [האחרון בשעה] LT",sameElse:"L"},relativeTime:{future:"בעוד %s",past:"לפני %s",s:"מספר שניות",m:"דקה",mm:"%d דקות",h:"שעה",hh:function(e){return 2===e?"שעתיים":e+" שעות"},d:"יום",dd:function(e){return 2===e?"יומיים":e+" ימים"},M:"חודש",MM:function(e){return 2===e?"חודשיים":e+" חודשים"},y:"שנה",yy:function(e){return 2===e?"שנתיים":e%10===0&&10!==e?e+" שנה":e+" שנים"}},meridiemParse:/אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,isPM:function(e){return/^(אחה"צ|אחרי הצהריים|בערב)$/.test(e)},meridiem:function(e,t,n){return e<5?"לפנות בוקר":e<10?"בבוקר":e<12?n?'לפנה"צ':"לפני הצהריים":e<18?n?'אחה"צ':"אחרי הצהריים":"בערב"}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"},a=e.defineLocale("hi",{months:"जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर".split("_"),monthsShort:"जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.".split("_"),monthsParseExact:!0,weekdays:"रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm बजे",LTS:"A h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm बजे",LLLL:"dddd, D MMMM YYYY, A h:mm बजे"},calendar:{sameDay:"[आज] LT",nextDay:"[कल] LT",nextWeek:"dddd, LT",lastDay:"[कल] LT",lastWeek:"[पिछले] dddd, LT",sameElse:"L"},relativeTime:{future:"%s में",past:"%s पहले",s:"कुछ ही क्षण",m:"एक मिनट",mm:"%d मिनट",h:"एक घंटा",hh:"%d घंटे",d:"एक दिन",dd:"%d दिन",M:"एक महीने",MM:"%d महीने",y:"एक वर्ष",yy:"%d वर्ष"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},meridiemParse:/रात|सुबह|दोपहर|शाम/,meridiemHour:function(e,t){return 12===e&&(e=0),"रात"===t?e<4?e:e+12:"सुबह"===t?e:"दोपहर"===t?e>=10?e:e+12:"शाम"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"रात":e<10?"सुबह":e<17?"दोपहर":e<20?"शाम":"रात"},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n){var a=e+" ";switch(n){case"m":return t?"jedna minuta":"jedne minute";case"mm":return a+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return a+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return a+=1===e?"dan":"dana";case"MM":return a+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return a+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}var n=e.defineLocale("hr",{months:{format:"siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca".split("_"),standalone:"siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac".split("_")},monthsShort:"sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:case 3:return"[prošlu] dddd [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r=e;switch(n){case"s":return a||t?"néhány másodperc":"néhány másodperce";case"m":return"egy"+(a||t?" perc":" perce");case"mm":return r+(a||t?" perc":" perce");case"h":return"egy"+(a||t?" óra":" órája");case"hh":return r+(a||t?" óra":" órája");case"d":return"egy"+(a||t?" nap":" napja");case"dd":return r+(a||t?" nap":" napja");case"M":return"egy"+(a||t?" hónap":" hónapja");case"MM":return r+(a||t?" hónap":" hónapja");case"y":return"egy"+(a||t?" év":" éve");case"yy":return r+(a||t?" év":" éve")}return""}function n(e){return(e?"":"[múlt] ")+"["+a[this.day()]+"] LT[-kor]"}var a="vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton".split(" "),r=e.defineLocale("hu",{months:"január_február_március_április_május_június_július_augusztus_szeptember_október_november_december".split("_"),monthsShort:"jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec".split("_"),weekdays:"vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat".split("_"),weekdaysShort:"vas_hét_kedd_sze_csüt_pén_szo".split("_"),weekdaysMin:"v_h_k_sze_cs_p_szo".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY. MMMM D.",LLL:"YYYY. MMMM D. H:mm",LLLL:"YYYY. MMMM D., dddd H:mm"},meridiemParse:/de|du/i,isPM:function(e){return"u"===e.charAt(1).toLowerCase()},meridiem:function(e,t,n){return e<12?n===!0?"de":"DE":n===!0?"du":"DU"},calendar:{sameDay:"[ma] LT[-kor]",nextDay:"[holnap] LT[-kor]",nextWeek:function(){return n.call(this,!0)},lastDay:"[tegnap] LT[-kor]",lastWeek:function(){return n.call(this,!1)},sameElse:"L"},relativeTime:{future:"%s múlva",past:"%s",s:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return r})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("hy-am",{months:{format:"հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի".split("_"),standalone:"հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր".split("_")},monthsShort:"հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ".split("_"),weekdays:"կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ".split("_"),weekdaysShort:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),weekdaysMin:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY թ.",LLL:"D MMMM YYYY թ., HH:mm",LLLL:"dddd, D MMMM YYYY թ., HH:mm"},calendar:{sameDay:"[այսօր] LT",nextDay:"[վաղը] LT",lastDay:"[երեկ] LT",nextWeek:function(){return"dddd [օրը ժամը] LT"},lastWeek:function(){return"[անցած] dddd [օրը ժամը] LT"},sameElse:"L"},relativeTime:{future:"%s հետո",past:"%s առաջ",s:"մի քանի վայրկյան",m:"րոպե",mm:"%d րոպե",h:"ժամ",hh:"%d ժամ",d:"օր",dd:"%d օր",M:"ամիս",MM:"%d ամիս",y:"տարի",yy:"%d տարի"},meridiemParse:/գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,isPM:function(e){return/^(ցերեկվա|երեկոյան)$/.test(e)},meridiem:function(e){return e<4?"գիշերվա":e<12?"առավոտվա":e<17?"ցերեկվա":"երեկոյան"},dayOfMonthOrdinalParse:/\d{1,2}|\d{1,2}-(ին|րդ)/,ordinal:function(e,t){switch(t){case"DDD":case"w":case"W":case"DDDo":return 1===e?e+"-ին":e+"-րդ";default:return e}},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("id",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des".split("_"),weekdays:"Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu".split("_"),weekdaysShort:"Min_Sen_Sel_Rab_Kam_Jum_Sab".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|siang|sore|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"siang"===t?e>=11?e:e+12:"sore"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"siang":e<19?"sore":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Besok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kemarin pukul] LT",lastWeek:"dddd [lalu pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lalu",s:"beberapa detik",m:"semenit",mm:"%d menit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e){return e%100===11||e%10!==1}function n(e,n,a,r){var i=e+" ";switch(a){case"s":return n||r?"nokkrar sekúndur":"nokkrum sekúndum";case"m":return n?"mínúta":"mínútu";case"mm":return t(e)?i+(n||r?"mínútur":"mínútum"):n?i+"mínúta":i+"mínútu";case"hh":return t(e)?i+(n||r?"klukkustundir":"klukkustundum"):i+"klukkustund";case"d":return n?"dagur":r?"dag":"degi";case"dd":return t(e)?n?i+"dagar":i+(r?"daga":"dögum"):n?i+"dagur":i+(r?"dag":"degi");case"M":return n?"mánuður":r?"mánuð":"mánuði";case"MM":return t(e)?n?i+"mánuðir":i+(r?"mánuði":"mánuðum"):n?i+"mánuður":i+(r?"mánuð":"mánuði");case"y":return n||r?"ár":"ári";case"yy":return t(e)?i+(n||r?"ár":"árum"):i+(n||r?"ár":"ári")}}var a=e.defineLocale("is",{months:"janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember".split("_"),monthsShort:"jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des".split("_"),weekdays:"sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur".split("_"),weekdaysShort:"sun_mán_þri_mið_fim_fös_lau".split("_"),weekdaysMin:"Su_Má_Þr_Mi_Fi_Fö_La".split("_"),longDateFormat:{
+LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd, D. MMMM YYYY [kl.] H:mm"},calendar:{sameDay:"[í dag kl.] LT",nextDay:"[á morgun kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[í gær kl.] LT",lastWeek:"[síðasta] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"eftir %s",past:"fyrir %s síðan",s:n,m:n,mm:n,h:"klukkustund",hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("it",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Oggi alle] LT",nextDay:"[Domani alle] LT",nextWeek:"dddd [alle] LT",lastDay:"[Ieri alle] LT",lastWeek:function(){switch(this.day()){case 0:return"[la scorsa] dddd [alle] LT";default:return"[lo scorso] dddd [alle] LT"}},sameElse:"L"},relativeTime:{future:function(e){return(/^[0-9].+$/.test(e)?"tra":"in")+" "+e},past:"%s fa",s:"alcuni secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ja",{months:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日".split("_"),weekdaysShort:"日_月_火_水_木_金_土".split("_"),weekdaysMin:"日_月_火_水_木_金_土".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日 HH:mm dddd",l:"YYYY/MM/DD",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日 HH:mm dddd"},meridiemParse:/午前|午後/i,isPM:function(e){return"午後"===e},meridiem:function(e,t,n){return e<12?"午前":"午後"},calendar:{sameDay:"[今日] LT",nextDay:"[明日] LT",nextWeek:"[来週]dddd LT",lastDay:"[昨日] LT",lastWeek:"[前週]dddd LT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}日/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"数秒",m:"1分",mm:"%d分",h:"1時間",hh:"%d時間",d:"1日",dd:"%d日",M:"1ヶ月",MM:"%dヶ月",y:"1年",yy:"%d年"}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("jv",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des".split("_"),weekdays:"Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu".split("_"),weekdaysShort:"Min_Sen_Sel_Reb_Kem_Jem_Sep".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sp".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/enjing|siyang|sonten|ndalu/,meridiemHour:function(e,t){return 12===e&&(e=0),"enjing"===t?e:"siyang"===t?e>=11?e:e+12:"sonten"===t||"ndalu"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"enjing":e<15?"siyang":e<19?"sonten":"ndalu"},calendar:{sameDay:"[Dinten puniko pukul] LT",nextDay:"[Mbenjang pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kala wingi pukul] LT",lastWeek:"dddd [kepengker pukul] LT",sameElse:"L"},relativeTime:{future:"wonten ing %s",past:"%s ingkang kepengker",s:"sawetawis detik",m:"setunggal menit",mm:"%d menit",h:"setunggal jam",hh:"%d jam",d:"sedinten",dd:"%d dinten",M:"sewulan",MM:"%d wulan",y:"setaun",yy:"%d taun"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ka",{months:{standalone:"იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი".split("_"),format:"იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს".split("_")},monthsShort:"იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ".split("_"),weekdays:{standalone:"კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი".split("_"),format:"კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს".split("_"),isFormat:/(წინა|შემდეგ)/},weekdaysShort:"კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ".split("_"),weekdaysMin:"კვ_ორ_სა_ოთ_ხუ_პა_შა".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[დღეს] LT[-ზე]",nextDay:"[ხვალ] LT[-ზე]",lastDay:"[გუშინ] LT[-ზე]",nextWeek:"[შემდეგ] dddd LT[-ზე]",lastWeek:"[წინა] dddd LT-ზე",sameElse:"L"},relativeTime:{future:function(e){return/(წამი|წუთი|საათი|წელი)/.test(e)?e.replace(/ი$/,"ში"):e+"ში"},past:function(e){return/(წამი|წუთი|საათი|დღე|თვე)/.test(e)?e.replace(/(ი|ე)$/,"ის უკან"):/წელი/.test(e)?e.replace(/წელი$/,"წლის უკან"):void 0},s:"რამდენიმე წამი",m:"წუთი",mm:"%d წუთი",h:"საათი",hh:"%d საათი",d:"დღე",dd:"%d დღე",M:"თვე",MM:"%d თვე",y:"წელი",yy:"%d წელი"},dayOfMonthOrdinalParse:/0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,ordinal:function(e){return 0===e?e:1===e?e+"-ლი":e<20||e<=100&&e%20===0||e%100===0?"მე-"+e:e+"-ე"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={0:"-ші",1:"-ші",2:"-ші",3:"-ші",4:"-ші",5:"-ші",6:"-шы",7:"-ші",8:"-ші",9:"-шы",10:"-шы",20:"-шы",30:"-шы",40:"-шы",50:"-ші",60:"-шы",70:"-ші",80:"-ші",90:"-шы",100:"-ші"},n=e.defineLocale("kk",{months:"қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан".split("_"),monthsShort:"қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел".split("_"),weekdays:"жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі".split("_"),weekdaysShort:"жек_дүй_сей_сәр_бей_жұм_сен".split("_"),weekdaysMin:"жк_дй_сй_ср_бй_жм_сн".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгін сағат] LT",nextDay:"[Ертең сағат] LT",nextWeek:"dddd [сағат] LT",lastDay:"[Кеше сағат] LT",lastWeek:"[Өткен аптаның] dddd [сағат] LT",sameElse:"L"},relativeTime:{future:"%s ішінде",past:"%s бұрын",s:"бірнеше секунд",m:"бір минут",mm:"%d минут",h:"бір сағат",hh:"%d сағат",d:"бір күн",dd:"%d күн",M:"бір ай",MM:"%d ай",y:"бір жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(ші|шы)/,ordinal:function(e){var n=e%10,a=e>=100?100:null;return e+(t[e]||t[n]||t[a])},week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("km",{months:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),monthsShort:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),weekdays:"អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍".split("_"),weekdaysShort:"អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍".split("_"),weekdaysMin:"អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[ថ្ងៃនេះ ម៉ោង] LT",nextDay:"[ស្អែក ម៉ោង] LT",nextWeek:"dddd [ម៉ោង] LT",lastDay:"[ម្សិលមិញ ម៉ោង] LT",lastWeek:"dddd [សប្តាហ៍មុន] [ម៉ោង] LT",sameElse:"L"},relativeTime:{future:"%sទៀត",past:"%sមុន",s:"ប៉ុន្មានវិនាទី",m:"មួយនាទី",mm:"%d នាទី",h:"មួយម៉ោង",hh:"%d ម៉ោង",d:"មួយថ្ងៃ",dd:"%d ថ្ងៃ",M:"មួយខែ",MM:"%d ខែ",y:"មួយឆ្នាំ",yy:"%d ឆ្នាំ"},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"೧",2:"೨",3:"೩",4:"೪",5:"೫",6:"೬",7:"೭",8:"೮",9:"೯",0:"೦"},n={"೧":"1","೨":"2","೩":"3","೪":"4","೫":"5","೬":"6","೭":"7","೮":"8","೯":"9","೦":"0"},a=e.defineLocale("kn",{months:"ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್".split("_"),monthsShort:"ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬ_ಅಕ್ಟೋಬ_ನವೆಂಬ_ಡಿಸೆಂಬ".split("_"),monthsParseExact:!0,weekdays:"ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ".split("_"),weekdaysShort:"ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ".split("_"),weekdaysMin:"ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[ಇಂದು] LT",nextDay:"[ನಾಳೆ] LT",nextWeek:"dddd, LT",lastDay:"[ನಿನ್ನೆ] LT",lastWeek:"[ಕೊನೆಯ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ನಂತರ",past:"%s ಹಿಂದೆ",s:"ಕೆಲವು ಕ್ಷಣಗಳು",m:"ಒಂದು ನಿಮಿಷ",mm:"%d ನಿಮಿಷ",h:"ಒಂದು ಗಂಟೆ",hh:"%d ಗಂಟೆ",d:"ಒಂದು ದಿನ",dd:"%d ದಿನ",M:"ಒಂದು ತಿಂಗಳು",MM:"%d ತಿಂಗಳು",y:"ಒಂದು ವರ್ಷ",yy:"%d ವರ್ಷ"},preparse:function(e){return e.replace(/[೧೨೩೪೫೬೭೮೯೦]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},meridiemParse:/ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ರಾತ್ರಿ"===t?e<4?e:e+12:"ಬೆಳಿಗ್ಗೆ"===t?e:"ಮಧ್ಯಾಹ್ನ"===t?e>=10?e:e+12:"ಸಂಜೆ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"ರಾತ್ರಿ":e<10?"ಬೆಳಿಗ್ಗೆ":e<17?"ಮಧ್ಯಾಹ್ನ":e<20?"ಸಂಜೆ":"ರಾತ್ರಿ"},dayOfMonthOrdinalParse:/\d{1,2}(ನೇ)/,ordinal:function(e){return e+"ನೇ"},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ko",{months:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),monthsShort:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),weekdays:"일요일_월요일_화요일_수요일_목요일_금요일_토요일".split("_"),weekdaysShort:"일_월_화_수_목_금_토".split("_"),weekdaysMin:"일_월_화_수_목_금_토".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"YYYY.MM.DD",LL:"YYYY년 MMMM D일",LLL:"YYYY년 MMMM D일 A h:mm",LLLL:"YYYY년 MMMM D일 dddd A h:mm",l:"YYYY.MM.DD",ll:"YYYY년 MMMM D일",lll:"YYYY년 MMMM D일 A h:mm",llll:"YYYY년 MMMM D일 dddd A h:mm"},calendar:{sameDay:"오늘 LT",nextDay:"내일 LT",nextWeek:"dddd LT",lastDay:"어제 LT",lastWeek:"지난주 dddd LT",sameElse:"L"},relativeTime:{future:"%s 후",past:"%s 전",s:"몇 초",ss:"%d초",m:"1분",mm:"%d분",h:"한 시간",hh:"%d시간",d:"하루",dd:"%d일",M:"한 달",MM:"%d달",y:"일 년",yy:"%d년"},dayOfMonthOrdinalParse:/\d{1,2}일/,ordinal:"%d일",meridiemParse:/오전|오후/,isPM:function(e){return"오후"===e},meridiem:function(e,t,n){return e<12?"오전":"오후"}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={0:"-чү",1:"-чи",2:"-чи",3:"-чү",4:"-чү",5:"-чи",6:"-чы",7:"-чи",8:"-чи",9:"-чу",10:"-чу",20:"-чы",30:"-чу",40:"-чы",50:"-чү",60:"-чы",70:"-чи",80:"-чи",90:"-чу",100:"-чү"},n=e.defineLocale("ky",{months:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_"),monthsShort:"янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек".split("_"),weekdays:"Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби".split("_"),weekdaysShort:"Жек_Дүй_Шей_Шар_Бей_Жум_Ише".split("_"),weekdaysMin:"Жк_Дй_Шй_Шр_Бй_Жм_Иш".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгүн саат] LT",nextDay:"[Эртең саат] LT",nextWeek:"dddd [саат] LT",lastDay:"[Кече саат] LT",lastWeek:"[Өткен аптанын] dddd [күнү] [саат] LT",sameElse:"L"},relativeTime:{future:"%s ичинде",past:"%s мурун",s:"бирнече секунд",m:"бир мүнөт",mm:"%d мүнөт",h:"бир саат",hh:"%d саат",d:"бир күн",dd:"%d күн",M:"бир ай",MM:"%d ай",y:"бир жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(чи|чы|чү|чу)/,ordinal:function(e){var n=e%10,a=e>=100?100:null;return e+(t[e]||t[n]||t[a])},week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r={m:["eng Minutt","enger Minutt"],h:["eng Stonn","enger Stonn"],d:["een Dag","engem Dag"],M:["ee Mount","engem Mount"],y:["ee Joer","engem Joer"]};return t?r[n][0]:r[n][1]}function n(e){var t=e.substr(0,e.indexOf(" "));return r(t)?"a "+e:"an "+e}function a(e){var t=e.substr(0,e.indexOf(" "));return r(t)?"viru "+e:"virun "+e}function r(e){if(e=parseInt(e,10),isNaN(e))return!1;if(e<0)return!0;if(e<10)return 4<=e&&e<=7;if(e<100){var t=e%10,n=e/10;return r(0===t?n:t)}if(e<1e4){for(;e>=10;)e/=10;return r(e)}return e/=1e3,r(e)}var i=e.defineLocale("lb",{months:"Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg".split("_"),weekdaysShort:"So._Mé._Dë._Më._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mé_Dë_Më_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm [Auer]",LTS:"H:mm:ss [Auer]",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm [Auer]",LLLL:"dddd, D. MMMM YYYY H:mm [Auer]"},calendar:{sameDay:"[Haut um] LT",sameElse:"L",nextDay:"[Muer um] LT",nextWeek:"dddd [um] LT",lastDay:"[Gëschter um] LT",lastWeek:function(){switch(this.day()){case 2:case 4:return"[Leschten] dddd [um] LT";default:return"[Leschte] dddd [um] LT"}}},relativeTime:{future:n,past:a,s:"e puer Sekonnen",m:t,mm:"%d Minutten",h:t,hh:"%d Stonnen",d:t,dd:"%d Deeg",M:t,MM:"%d Méint",y:t,yy:"%d Joer"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("lo",{months:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),monthsShort:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),weekdays:"ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysShort:"ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysMin:"ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"ວັນdddd D MMMM YYYY HH:mm"},meridiemParse:/ຕອນເຊົ້າ|ຕອນແລງ/,isPM:function(e){return"ຕອນແລງ"===e},meridiem:function(e,t,n){return e<12?"ຕອນເຊົ້າ":"ຕອນແລງ"},calendar:{sameDay:"[ມື້ນີ້ເວລາ] LT",nextDay:"[ມື້ອື່ນເວລາ] LT",nextWeek:"[ວັນ]dddd[ໜ້າເວລາ] LT",lastDay:"[ມື້ວານນີ້ເວລາ] LT",lastWeek:"[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT",sameElse:"L"},relativeTime:{future:"ອີກ %s",past:"%sຜ່ານມາ",s:"ບໍ່ເທົ່າໃດວິນາທີ",m:"1 ນາທີ",mm:"%d ນາທີ",h:"1 ຊົ່ວໂມງ",hh:"%d ຊົ່ວໂມງ",d:"1 ມື້",dd:"%d ມື້",M:"1 ເດືອນ",MM:"%d ເດືອນ",y:"1 ປີ",yy:"%d ປີ"},dayOfMonthOrdinalParse:/(ທີ່)\d{1,2}/,ordinal:function(e){return"ທີ່"+e}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){return t?"kelios sekundės":a?"kelių sekundžių":"kelias sekundes"}function n(e,t,n,a){return t?r(n)[0]:a?r(n)[1]:r(n)[2]}function a(e){return e%10===0||e>10&&e<20}function r(e){return o[e].split("_")}function i(e,t,i,o){var s=e+" ";return 1===e?s+n(e,t,i[0],o):t?s+(a(e)?r(i)[1]:r(i)[0]):o?s+r(i)[1]:s+(a(e)?r(i)[1]:r(i)[2])}var o={m:"minutė_minutės_minutę",mm:"minutės_minučių_minutes",h:"valanda_valandos_valandą",hh:"valandos_valandų_valandas",d:"diena_dienos_dieną",dd:"dienos_dienų_dienas",M:"mėnuo_mėnesio_mėnesį",MM:"mėnesiai_mėnesių_mėnesius",y:"metai_metų_metus",yy:"metai_metų_metus"},s=e.defineLocale("lt",{months:{format:"sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio".split("_"),standalone:"sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis".split("_"),isFormat:/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/},monthsShort:"sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd".split("_"),weekdays:{format:"sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį".split("_"),standalone:"sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis".split("_"),isFormat:/dddd HH:mm/},weekdaysShort:"Sek_Pir_Ant_Tre_Ket_Pen_Šeš".split("_"),weekdaysMin:"S_P_A_T_K_Pn_Š".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY [m.] MMMM D [d.]",LLL:"YYYY [m.] MMMM D [d.], HH:mm [val.]",LLLL:"YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]",l:"YYYY-MM-DD",ll:"YYYY [m.] MMMM D [d.]",lll:"YYYY [m.] MMMM D [d.], HH:mm [val.]",llll:"YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]"},calendar:{sameDay:"[Šiandien] LT",nextDay:"[Rytoj] LT",nextWeek:"dddd LT",lastDay:"[Vakar] LT",lastWeek:"[Praėjusį] dddd LT",sameElse:"L"},relativeTime:{future:"po %s",past:"prieš %s",s:t,m:n,mm:i,h:n,hh:i,d:n,dd:i,M:n,MM:i,y:n,yy:i},dayOfMonthOrdinalParse:/\d{1,2}-oji/,ordinal:function(e){return e+"-oji"},week:{dow:1,doy:4}});return s})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n){return n?t%10===1&&t%100!==11?e[2]:e[3]:t%10===1&&t%100!==11?e[0]:e[1]}function n(e,n,a){return e+" "+t(i[a],e,n)}function a(e,n,a){return t(i[a],e,n)}function r(e,t){return t?"dažas sekundes":"dažām sekundēm"}var i={m:"minūtes_minūtēm_minūte_minūtes".split("_"),mm:"minūtes_minūtēm_minūte_minūtes".split("_"),h:"stundas_stundām_stunda_stundas".split("_"),hh:"stundas_stundām_stunda_stundas".split("_"),d:"dienas_dienām_diena_dienas".split("_"),dd:"dienas_dienām_diena_dienas".split("_"),M:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),MM:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),y:"gada_gadiem_gads_gadi".split("_"),yy:"gada_gadiem_gads_gadi".split("_")},o=e.defineLocale("lv",{months:"janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris".split("_"),monthsShort:"jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec".split("_"),weekdays:"svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena".split("_"),weekdaysShort:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysMin:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY.",LL:"YYYY. [gada] D. MMMM",LLL:"YYYY. [gada] D. MMMM, HH:mm",LLLL:"YYYY. [gada] D. MMMM, dddd, HH:mm"},calendar:{sameDay:"[Šodien pulksten] LT",nextDay:"[Rīt pulksten] LT",nextWeek:"dddd [pulksten] LT",lastDay:"[Vakar pulksten] LT",lastWeek:"[Pagājušā] dddd [pulksten] LT",sameElse:"L"},relativeTime:{future:"pēc %s",past:"pirms %s",s:r,m:a,mm:n,h:a,hh:n,d:a,dd:n,M:a,MM:n,y:a,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return o})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={words:{m:["jedan minut","jednog minuta"],mm:["minut","minuta","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mjesec","mjeseca","mjeseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,a){var r=t.words[a];return 1===a.length?n?r[0]:r[1]:e+" "+t.correctGrammaticalCase(e,r)}},n=e.defineLocale("me",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sjutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){var e=["[prošle] [nedjelje] [u] LT","[prošlog] [ponedjeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srijede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"];return e[this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"nekoliko sekundi",m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mjesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("mi",{months:"Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea".split("_"),monthsShort:"Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki".split("_"),monthsRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,weekdays:"Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei".split("_"),weekdaysShort:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),weekdaysMin:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [i] HH:mm",LLLL:"dddd, D MMMM YYYY [i] HH:mm"},calendar:{sameDay:"[i teie mahana, i] LT",nextDay:"[apopo i] LT",nextWeek:"dddd [i] LT",lastDay:"[inanahi i] LT",lastWeek:"dddd [whakamutunga i] LT",sameElse:"L"},relativeTime:{future:"i roto i %s",past:"%s i mua",s:"te hēkona ruarua",m:"he meneti",mm:"%d meneti",h:"te haora",hh:"%d haora",d:"he ra",dd:"%d ra",M:"he marama",MM:"%d marama",y:"he tau",yy:"%d tau"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("mk",{months:"јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември".split("_"),monthsShort:"јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек".split("_"),weekdays:"недела_понеделник_вторник_среда_четврток_петок_сабота".split("_"),weekdaysShort:"нед_пон_вто_сре_чет_пет_саб".split("_"),weekdaysMin:"нe_пo_вт_ср_че_пе_сa".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Денес во] LT",nextDay:"[Утре во] LT",nextWeek:"[Во] dddd [во] LT",lastDay:"[Вчера во] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[Изминатата] dddd [во] LT";case 1:case 2:case 4:case 5:return"[Изминатиот] dddd [во] LT"}},sameElse:"L"},relativeTime:{future:"после %s",past:"пред %s",s:"неколку секунди",m:"минута",mm:"%d минути",h:"час",hh:"%d часа",d:"ден",dd:"%d дена",M:"месец",MM:"%d месеци",y:"година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,n=e%100;return 0===e?e+"-ев":0===n?e+"-ен":n>10&&n<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ml",{months:"ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ".split("_"),monthsShort:"ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.".split("_"),monthsParseExact:!0,weekdays:"ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച".split("_"),weekdaysShort:"ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി".split("_"),weekdaysMin:"ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ".split("_"),longDateFormat:{LT:"A h:mm -നു",LTS:"A h:mm:ss -നു",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm -നു",LLLL:"dddd, D MMMM YYYY, A h:mm -നു"},calendar:{sameDay:"[ഇന്ന്] LT",nextDay:"[നാളെ] LT",nextWeek:"dddd, LT",lastDay:"[ഇന്നലെ] LT",lastWeek:"[കഴിഞ്ഞ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s കഴിഞ്ഞ്",past:"%s മുൻപ്",s:"അൽപ നിമിഷങ്ങൾ",m:"ഒരു മിനിറ്റ്",mm:"%d മിനിറ്റ്",h:"ഒരു മണിക്കൂർ",hh:"%d മണിക്കൂർ",d:"ഒരു ദിവസം",dd:"%d ദിവസം",M:"ഒരു മാസം",MM:"%d മാസം",y:"ഒരു വർഷം",yy:"%d വർഷം"},meridiemParse:/രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,meridiemHour:function(e,t){return 12===e&&(e=0),"രാത്രി"===t&&e>=4||"ഉച്ച കഴിഞ്ഞ്"===t||"വൈകുന്നേരം"===t?e+12:e},meridiem:function(e,t,n){return e<4?"രാത്രി":e<12?"രാവിലെ":e<17?"ഉച്ച കഴിഞ്ഞ്":e<20?"വൈകുന്നേരം":"രാത്രി"}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r="";if(t)switch(n){case"s":r="काही सेकंद";break;case"m":r="एक मिनिट";break;case"mm":r="%d मिनिटे";break;case"h":r="एक तास";break;case"hh":r="%d तास";break;case"d":r="एक दिवस";break;case"dd":r="%d दिवस";break;case"M":r="एक महिना";break;case"MM":r="%d महिने";break;case"y":r="एक वर्ष";break;case"yy":r="%d वर्षे"}else switch(n){case"s":r="काही सेकंदां";break;case"m":r="एका मिनिटा";break;case"mm":r="%d मिनिटां";break;case"h":r="एका तासा";break;case"hh":r="%d तासां";break;case"d":r="एका दिवसा";break;case"dd":r="%d दिवसां";break;case"M":r="एका महिन्या";break;case"MM":r="%d महिन्यां";break;case"y":r="एका वर्षा";break;case"yy":r="%d वर्षां"}return r.replace(/%d/i,e)}var n={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},a={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"},r=e.defineLocale("mr",{months:"जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर".split("_"),monthsShort:"जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.".split("_"),monthsParseExact:!0,weekdays:"रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm वाजता",LTS:"A h:mm:ss वाजता",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm वाजता",LLLL:"dddd, D MMMM YYYY, A h:mm वाजता"},calendar:{sameDay:"[आज] LT",nextDay:"[उद्या] LT",nextWeek:"dddd, LT",lastDay:"[काल] LT",lastWeek:"[मागील] dddd, LT",sameElse:"L"},relativeTime:{future:"%sमध्ये",past:"%sपूर्वी",s:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,function(e){return a[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return n[e]})},meridiemParse:/रात्री|सकाळी|दुपारी|सायंकाळी/,meridiemHour:function(e,t){return 12===e&&(e=0),"रात्री"===t?e<4?e:e+12:"सकाळी"===t?e:"दुपारी"===t?e>=10?e:e+12:"सायंकाळी"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"रात्री":e<10?"सकाळी":e<17?"दुपारी":e<20?"सायंकाळी":"रात्री"},week:{dow:0,doy:6}});return r})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ms-my",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ms",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"၁",2:"၂",3:"၃",4:"၄",5:"၅",6:"၆",7:"၇",8:"၈",9:"၉",0:"၀"},n={"၁":"1","၂":"2","၃":"3","၄":"4","၅":"5","၆":"6","၇":"7","၈":"8","၉":"9","၀":"0"},a=e.defineLocale("my",{months:"ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ".split("_"),monthsShort:"ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ".split("_"),weekdays:"တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ".split("_"),weekdaysShort:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),weekdaysMin:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ယနေ.] LT [မှာ]",nextDay:"[မနက်ဖြန်] LT [မှာ]",nextWeek:"dddd LT [မှာ]",lastDay:"[မနေ.က] LT [မှာ]",lastWeek:"[ပြီးခဲ့သော] dddd LT [မှာ]",sameElse:"L"},relativeTime:{future:"လာမည့် %s မှာ",past:"လွန်ခဲ့သော %s က",s:"စက္ကန်.အနည်းငယ်",m:"တစ်မိနစ်",mm:"%d မိနစ်",h:"တစ်နာရီ",hh:"%d နာရီ",d:"တစ်ရက်",dd:"%d ရက်",M:"တစ်လ",MM:"%d လ",y:"တစ်နှစ်",yy:"%d နှစ်"},preparse:function(e){return e.replace(/[၁၂၃၄၅၆၇၈၉၀]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},week:{dow:1,doy:4}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("nb",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.".split("_"),monthsParseExact:!0,weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"sø._ma._ti._on._to._fr._lø.".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] HH:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[forrige] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"noen sekunder",m:"ett minutt",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dager",M:"en måned",MM:"%d måneder",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"},a=e.defineLocale("ne",{months:"जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर".split("_"),monthsShort:"जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.".split("_"),monthsParseExact:!0,weekdays:"आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार".split("_"),weekdaysShort:"आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.".split("_"),
+weekdaysMin:"आ._सो._मं._बु._बि._शु._श.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"Aको h:mm बजे",LTS:"Aको h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, Aको h:mm बजे",LLLL:"dddd, D MMMM YYYY, Aको h:mm बजे"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},meridiemParse:/राति|बिहान|दिउँसो|साँझ/,meridiemHour:function(e,t){return 12===e&&(e=0),"राति"===t?e<4?e:e+12:"बिहान"===t?e:"दिउँसो"===t?e>=10?e:e+12:"साँझ"===t?e+12:void 0},meridiem:function(e,t,n){return e<3?"राति":e<12?"बिहान":e<16?"दिउँसो":e<20?"साँझ":"राति"},calendar:{sameDay:"[आज] LT",nextDay:"[भोलि] LT",nextWeek:"[आउँदो] dddd[,] LT",lastDay:"[हिजो] LT",lastWeek:"[गएको] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%sमा",past:"%s अगाडि",s:"केही क्षण",m:"एक मिनेट",mm:"%d मिनेट",h:"एक घण्टा",hh:"%d घण्टा",d:"एक दिन",dd:"%d दिन",M:"एक महिना",MM:"%d महिना",y:"एक बर्ष",yy:"%d बर्ष"},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),a=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],r=/^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,i=e.defineLocale("nl-be",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,a){return e?/-MMM-/.test(a)?n[e.month()]:t[e.month()]:t},monthsRegex:r,monthsShortRegex:r,monthsStrictRegex:/^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:a,longMonthsParse:a,shortMonthsParse:a,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"Zo_Ma_Di_Wo_Do_Vr_Za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),a=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],r=/^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,i=e.defineLocale("nl",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,a){return e?/-MMM-/.test(a)?n[e.month()]:t[e.month()]:t},monthsRegex:r,monthsShortRegex:r,monthsStrictRegex:/^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:a,longMonthsParse:a,shortMonthsParse:a,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"Zo_Ma_Di_Wo_Do_Vr_Za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("nn",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_"),weekdays:"sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag".split("_"),weekdaysShort:"sun_mån_tys_ons_tor_fre_lau".split("_"),weekdaysMin:"su_må_ty_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[I dag klokka] LT",nextDay:"[I morgon klokka] LT",nextWeek:"dddd [klokka] LT",lastDay:"[I går klokka] LT",lastWeek:"[Føregåande] dddd [klokka] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s sidan",s:"nokre sekund",m:"eit minutt",mm:"%d minutt",h:"ein time",hh:"%d timar",d:"ein dag",dd:"%d dagar",M:"ein månad",MM:"%d månader",y:"eit år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"੧",2:"੨",3:"੩",4:"੪",5:"੫",6:"੬",7:"੭",8:"੮",9:"੯",0:"੦"},n={"੧":"1","੨":"2","੩":"3","੪":"4","੫":"5","੬":"6","੭":"7","੮":"8","੯":"9","੦":"0"},a=e.defineLocale("pa-in",{months:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),monthsShort:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),weekdays:"ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ".split("_"),weekdaysShort:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),weekdaysMin:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),longDateFormat:{LT:"A h:mm ਵਜੇ",LTS:"A h:mm:ss ਵਜੇ",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm ਵਜੇ",LLLL:"dddd, D MMMM YYYY, A h:mm ਵਜੇ"},calendar:{sameDay:"[ਅਜ] LT",nextDay:"[ਕਲ] LT",nextWeek:"dddd, LT",lastDay:"[ਕਲ] LT",lastWeek:"[ਪਿਛਲੇ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ਵਿੱਚ",past:"%s ਪਿਛਲੇ",s:"ਕੁਝ ਸਕਿੰਟ",m:"ਇਕ ਮਿੰਟ",mm:"%d ਮਿੰਟ",h:"ਇੱਕ ਘੰਟਾ",hh:"%d ਘੰਟੇ",d:"ਇੱਕ ਦਿਨ",dd:"%d ਦਿਨ",M:"ਇੱਕ ਮਹੀਨਾ",MM:"%d ਮਹੀਨੇ",y:"ਇੱਕ ਸਾਲ",yy:"%d ਸਾਲ"},preparse:function(e){return e.replace(/[੧੨੩੪੫੬੭੮੯੦]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},meridiemParse:/ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ਰਾਤ"===t?e<4?e:e+12:"ਸਵੇਰ"===t?e:"ਦੁਪਹਿਰ"===t?e>=10?e:e+12:"ਸ਼ਾਮ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"ਰਾਤ":e<10?"ਸਵੇਰ":e<17?"ਦੁਪਹਿਰ":e<20?"ਸ਼ਾਮ":"ਰਾਤ"},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e){return e%10<5&&e%10>1&&~~(e/10)%10!==1}function n(e,n,a){var r=e+" ";switch(a){case"m":return n?"minuta":"minutę";case"mm":return r+(t(e)?"minuty":"minut");case"h":return n?"godzina":"godzinę";case"hh":return r+(t(e)?"godziny":"godzin");case"MM":return r+(t(e)?"miesiące":"miesięcy");case"yy":return r+(t(e)?"lata":"lat")}}var a="styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień".split("_"),r="stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia".split("_"),i=e.defineLocale("pl",{months:function(e,t){return e?""===t?"("+r[e.month()]+"|"+a[e.month()]+")":/D MMMM/.test(t)?r[e.month()]:a[e.month()]:a},monthsShort:"sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru".split("_"),weekdays:"niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota".split("_"),weekdaysShort:"ndz_pon_wt_śr_czw_pt_sob".split("_"),weekdaysMin:"Nd_Pn_Wt_Śr_Cz_Pt_So".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Dziś o] LT",nextDay:"[Jutro o] LT",nextWeek:"[W] dddd [o] LT",lastDay:"[Wczoraj o] LT",lastWeek:function(){switch(this.day()){case 0:return"[W zeszłą niedzielę o] LT";case 3:return"[W zeszłą środę o] LT";case 6:return"[W zeszłą sobotę o] LT";default:return"[W zeszły] dddd [o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"%s temu",s:"kilka sekund",m:n,mm:n,h:n,hh:n,d:"1 dzień",dd:"%d dni",M:"miesiąc",MM:n,y:"rok",yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("pt-br",{months:"Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro".split("_"),monthsShort:"Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez".split("_"),weekdays:"Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY [às] HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY [às] HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"%s atrás",s:"poucos segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº"});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("pt",{months:"Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro".split("_"),monthsShort:"Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez".split("_"),weekdays:"Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n){var a={mm:"minute",hh:"ore",dd:"zile",MM:"luni",yy:"ani"},r=" ";return(e%100>=20||e>=100&&e%100===0)&&(r=" de "),e+r+a[n]}var n=e.defineLocale("ro",{months:"ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie".split("_"),monthsShort:"ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"duminică_luni_marți_miercuri_joi_vineri_sâmbătă".split("_"),weekdaysShort:"Dum_Lun_Mar_Mie_Joi_Vin_Sâm".split("_"),weekdaysMin:"Du_Lu_Ma_Mi_Jo_Vi_Sâ".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[azi la] LT",nextDay:"[mâine la] LT",nextWeek:"dddd [la] LT",lastDay:"[ieri la] LT",lastWeek:"[fosta] dddd [la] LT",sameElse:"L"},relativeTime:{future:"peste %s",past:"%s în urmă",s:"câteva secunde",m:"un minut",mm:t,h:"o oră",hh:t,d:"o zi",dd:t,M:"o lună",MM:t,y:"un an",yy:t},week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t){var n=e.split("_");return t%10===1&&t%100!==11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,a){var r={mm:n?"минута_минуты_минут":"минуту_минуты_минут",hh:"час_часа_часов",dd:"день_дня_дней",MM:"месяц_месяца_месяцев",yy:"год_года_лет"};return"m"===a?n?"минута":"минуту":e+" "+t(r[a],+e)}var a=[/^янв/i,/^фев/i,/^мар/i,/^апр/i,/^ма[йя]/i,/^июн/i,/^июл/i,/^авг/i,/^сен/i,/^окт/i,/^ноя/i,/^дек/i],r=e.defineLocale("ru",{months:{format:"января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря".split("_"),standalone:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_")},monthsShort:{format:"янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.".split("_"),standalone:"янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.".split("_")},weekdays:{standalone:"воскресенье_понедельник_вторник_среда_четверг_пятница_суббота".split("_"),format:"воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу".split("_"),isFormat:/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/},weekdaysShort:"вс_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"вс_пн_вт_ср_чт_пт_сб".split("_"),monthsParse:a,longMonthsParse:a,shortMonthsParse:a,monthsRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsShortRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsStrictRegex:/^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,monthsShortStrictRegex:/^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., HH:mm",LLLL:"dddd, D MMMM YYYY г., HH:mm"},calendar:{sameDay:"[Сегодня в] LT",nextDay:"[Завтра в] LT",lastDay:"[Вчера в] LT",nextWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd [в] LT":"[В] dddd [в] LT";switch(this.day()){case 0:return"[В следующее] dddd [в] LT";case 1:case 2:case 4:return"[В следующий] dddd [в] LT";case 3:case 5:case 6:return"[В следующую] dddd [в] LT"}},lastWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd [в] LT":"[В] dddd [в] LT";switch(this.day()){case 0:return"[В прошлое] dddd [в] LT";case 1:case 2:case 4:return"[В прошлый] dddd [в] LT";case 3:case 5:case 6:return"[В прошлую] dddd [в] LT"}},sameElse:"L"},relativeTime:{future:"через %s",past:"%s назад",s:"несколько секунд",m:n,mm:n,h:"час",hh:n,d:"день",dd:n,M:"месяц",MM:n,y:"год",yy:n},meridiemParse:/ночи|утра|дня|вечера/i,isPM:function(e){return/^(дня|вечера)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночи":e<12?"утра":e<17?"дня":"вечера"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го|я)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":return e+"-й";case"D":return e+"-го";case"w":case"W":return e+"-я";default:return e}},week:{dow:1,doy:7}});return r})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=["جنوري","فيبروري","مارچ","اپريل","مئي","جون","جولاءِ","آگسٽ","سيپٽمبر","آڪٽوبر","نومبر","ڊسمبر"],n=["آچر","سومر","اڱارو","اربع","خميس","جمع","ڇنڇر"],a=e.defineLocale("sd",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:n,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,n){return e<12?"صبح":"شام"},calendar:{sameDay:"[اڄ] LT",nextDay:"[سڀاڻي] LT",nextWeek:"dddd [اڳين هفتي تي] LT",lastDay:"[ڪالهه] LT",lastWeek:"[گزريل هفتي] dddd [تي] LT",sameElse:"L"},relativeTime:{future:"%s پوء",past:"%s اڳ",s:"چند سيڪنڊ",m:"هڪ منٽ",mm:"%d منٽ",h:"هڪ ڪلاڪ",hh:"%d ڪلاڪ",d:"هڪ ڏينهن",dd:"%d ڏينهن",M:"هڪ مهينو",MM:"%d مهينا",y:"هڪ سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("se",{months:"ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu".split("_"),monthsShort:"ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov".split("_"),weekdays:"sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat".split("_"),weekdaysShort:"sotn_vuos_maŋ_gask_duor_bear_láv".split("_"),weekdaysMin:"s_v_m_g_d_b_L".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"MMMM D. [b.] YYYY",LLL:"MMMM D. [b.] YYYY [ti.] HH:mm",LLLL:"dddd, MMMM D. [b.] YYYY [ti.] HH:mm"},calendar:{sameDay:"[otne ti] LT",nextDay:"[ihttin ti] LT",nextWeek:"dddd [ti] LT",lastDay:"[ikte ti] LT",lastWeek:"[ovddit] dddd [ti] LT",sameElse:"L"},relativeTime:{future:"%s geažes",past:"maŋit %s",s:"moadde sekunddat",m:"okta minuhta",mm:"%d minuhtat",h:"okta diimmu",hh:"%d diimmut",d:"okta beaivi",dd:"%d beaivvit",M:"okta mánnu",MM:"%d mánut",y:"okta jahki",yy:"%d jagit"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("si",{months:"ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්".split("_"),monthsShort:"ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ".split("_"),weekdays:"ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා".split("_"),weekdaysShort:"ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන".split("_"),weekdaysMin:"ඉ_ස_අ_බ_බ්‍ර_සි_සෙ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"a h:mm",LTS:"a h:mm:ss",L:"YYYY/MM/DD",LL:"YYYY MMMM D",LLL:"YYYY MMMM D, a h:mm",LLLL:"YYYY MMMM D [වැනි] dddd, a h:mm:ss"},calendar:{sameDay:"[අද] LT[ට]",nextDay:"[හෙට] LT[ට]",nextWeek:"dddd LT[ට]",lastDay:"[ඊයේ] LT[ට]",lastWeek:"[පසුගිය] dddd LT[ට]",sameElse:"L"},relativeTime:{future:"%sකින්",past:"%sකට පෙර",s:"තත්පර කිහිපය",m:"මිනිත්තුව",mm:"මිනිත්තු %d",h:"පැය",hh:"පැය %d",d:"දිනය",dd:"දින %d",M:"මාසය",MM:"මාස %d",y:"වසර",yy:"වසර %d"},dayOfMonthOrdinalParse:/\d{1,2} වැනි/,ordinal:function(e){return e+" වැනි"},meridiemParse:/පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,isPM:function(e){return"ප.ව."===e||"පස් වරු"===e},meridiem:function(e,t,n){return e>11?n?"ප.ව.":"පස් වරු":n?"පෙ.ව.":"පෙර වරු"}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e){return e>1&&e<5}function n(e,n,a,r){var i=e+" ";switch(a){case"s":return n||r?"pár sekúnd":"pár sekundami";case"m":return n?"minúta":r?"minútu":"minútou";case"mm":return n||r?i+(t(e)?"minúty":"minút"):i+"minútami";case"h":return n?"hodina":r?"hodinu":"hodinou";case"hh":return n||r?i+(t(e)?"hodiny":"hodín"):i+"hodinami";case"d":return n||r?"deň":"dňom";case"dd":return n||r?i+(t(e)?"dni":"dní"):i+"dňami";case"M":return n||r?"mesiac":"mesiacom";case"MM":return n||r?i+(t(e)?"mesiace":"mesiacov"):i+"mesiacmi";case"y":return n||r?"rok":"rokom";case"yy":return n||r?i+(t(e)?"roky":"rokov"):i+"rokmi"}}var a="január_február_marec_apríl_máj_jún_júl_august_september_október_november_december".split("_"),r="jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec".split("_"),i=e.defineLocale("sk",{months:a,monthsShort:r,weekdays:"nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota".split("_"),weekdaysShort:"ne_po_ut_st_št_pi_so".split("_"),weekdaysMin:"ne_po_ut_st_št_pi_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm"},calendar:{sameDay:"[dnes o] LT",nextDay:"[zajtra o] LT",nextWeek:function(){switch(this.day()){case 0:return"[v nedeľu o] LT";case 1:case 2:return"[v] dddd [o] LT";case 3:return"[v stredu o] LT";case 4:return"[vo štvrtok o] LT";case 5:return"[v piatok o] LT";case 6:return"[v sobotu o] LT"}},lastDay:"[včera o] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulú nedeľu o] LT";case 1:case 2:return"[minulý] dddd [o] LT";case 3:return"[minulú stredu o] LT";case 4:case 5:return"[minulý] dddd [o] LT";case 6:return"[minulú sobotu o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"pred %s",s:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r=e+" ";switch(n){case"s":return t||a?"nekaj sekund":"nekaj sekundami";case"m":return t?"ena minuta":"eno minuto";case"mm":return r+=1===e?t?"minuta":"minuto":2===e?t||a?"minuti":"minutama":e<5?t||a?"minute":"minutami":t||a?"minut":"minutami";case"h":return t?"ena ura":"eno uro";case"hh":return r+=1===e?t?"ura":"uro":2===e?t||a?"uri":"urama":e<5?t||a?"ure":"urami":t||a?"ur":"urami";case"d":return t||a?"en dan":"enim dnem";case"dd":return r+=1===e?t||a?"dan":"dnem":2===e?t||a?"dni":"dnevoma":t||a?"dni":"dnevi";case"M":return t||a?"en mesec":"enim mesecem";case"MM":return r+=1===e?t||a?"mesec":"mesecem":2===e?t||a?"meseca":"mesecema":e<5?t||a?"mesece":"meseci":t||a?"mesecev":"meseci";case"y":return t||a?"eno leto":"enim letom";case"yy":return r+=1===e?t||a?"leto":"letom":2===e?t||a?"leti":"letoma":e<5?t||a?"leta":"leti":t||a?"let":"leti"}}var n=e.defineLocale("sl",{months:"januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota".split("_"),weekdaysShort:"ned._pon._tor._sre._čet._pet._sob.".split("_"),weekdaysMin:"ne_po_to_sr_če_pe_so".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danes ob] LT",nextDay:"[jutri ob] LT",nextWeek:function(){switch(this.day()){case 0:return"[v] [nedeljo] [ob] LT";case 3:return"[v] [sredo] [ob] LT";case 6:return"[v] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[v] dddd [ob] LT"}},lastDay:"[včeraj ob] LT",lastWeek:function(){switch(this.day()){case 0:return"[prejšnjo] [nedeljo] [ob] LT";case 3:return"[prejšnjo] [sredo] [ob] LT";case 6:return"[prejšnjo] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[prejšnji] dddd [ob] LT"}},sameElse:"L"},relativeTime:{future:"čez %s",past:"pred %s",s:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("sq",{months:"Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor".split("_"),monthsShort:"Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj".split("_"),weekdays:"E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë".split("_"),weekdaysShort:"Die_Hën_Mar_Mër_Enj_Pre_Sht".split("_"),weekdaysMin:"D_H_Ma_Më_E_P_Sh".split("_"),weekdaysParseExact:!0,meridiemParse:/PD|MD/,isPM:function(e){return"M"===e.charAt(0)},meridiem:function(e,t,n){return e<12?"PD":"MD"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Sot në] LT",nextDay:"[Nesër në] LT",nextWeek:"dddd [në] LT",lastDay:"[Dje në] LT",lastWeek:"dddd [e kaluar në] LT",sameElse:"L"},relativeTime:{future:"në %s",past:"%s më parë",s:"disa sekonda",m:"një minutë",mm:"%d minuta",h:"një orë",hh:"%d orë",d:"një ditë",dd:"%d ditë",M:"një muaj",MM:"%d muaj",y:"një vit",yy:"%d vite"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={words:{m:["један минут","једне минуте"],mm:["минут","минуте","минута"],h:["један сат","једног сата"],hh:["сат","сата","сати"],dd:["дан","дана","дана"],MM:["месец","месеца","месеци"],yy:["година","године","година"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,a){var r=t.words[a];return 1===a.length?n?r[0]:r[1]:e+" "+t.correctGrammaticalCase(e,r)}},n=e.defineLocale("sr-cyrl",{months:"јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар".split("_"),monthsShort:"јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.".split("_"),monthsParseExact:!0,weekdays:"недеља_понедељак_уторак_среда_четвртак_петак_субота".split("_"),weekdaysShort:"нед._пон._уто._сре._чет._пет._суб.".split("_"),weekdaysMin:"не_по_ут_ср_че_пе_су".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[данас у] LT",nextDay:"[сутра у] LT",nextWeek:function(){switch(this.day()){case 0:return"[у] [недељу] [у] LT";case 3:return"[у] [среду] [у] LT";case 6:return"[у] [суботу] [у] LT";case 1:case 2:case 4:case 5:return"[у] dddd [у] LT"}},lastDay:"[јуче у] LT",lastWeek:function(){var e=["[прошле] [недеље] [у] LT","[прошлог] [понедељка] [у] LT","[прошлог] [уторка] [у] LT","[прошле] [среде] [у] LT","[прошлог] [четвртка] [у] LT","[прошлог] [петка] [у] LT","[прошле] [суботе] [у] LT"];return e[this.day()]},sameElse:"L"},relativeTime:{future:"за %s",past:"пре %s",s:"неколико секунди",m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"дан",dd:t.translate,M:"месец",MM:t.translate,y:"годину",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={words:{m:["jedan minut","jedne minute"],mm:["minut","minute","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mesec","meseca","meseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,a){var r=t.words[a];return 1===a.length?n?r[0]:r[1]:e+" "+t.correctGrammaticalCase(e,r)}},n=e.defineLocale("sr",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sre._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedelju] [u] LT";case 3:return"[u] [sredu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){var e=["[prošle] [nedelje] [u] LT","[prošlog] [ponedeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"];return e[this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"pre %s",s:"nekoliko sekundi",m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("ss",{months:"Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split("_"),monthsShort:"Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo".split("_"),weekdays:"Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo".split("_"),weekdaysShort:"Lis_Umb_Lsb_Les_Lsi_Lsh_Umg".split("_"),weekdaysMin:"Li_Us_Lb_Lt_Ls_Lh_Ug".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Namuhla nga] LT",nextDay:"[Kusasa nga] LT",nextWeek:"dddd [nga] LT",lastDay:"[Itolo nga] LT",lastWeek:"dddd [leliphelile] [nga] LT",sameElse:"L"},relativeTime:{future:"nga %s",past:"wenteka nga %s",s:"emizuzwana lomcane",m:"umzuzu",mm:"%d emizuzu",h:"lihora",hh:"%d emahora",d:"lilanga",dd:"%d emalanga",M:"inyanga",MM:"%d tinyanga",y:"umnyaka",yy:"%d iminyaka"},meridiemParse:/ekuseni|emini|entsambama|ebusuku/,meridiem:function(e,t,n){return e<11?"ekuseni":e<15?"emini":e<19?"entsambama":"ebusuku"},meridiemHour:function(e,t){return 12===e&&(e=0),"ekuseni"===t?e:"emini"===t?e>=11?e:e+12:"entsambama"===t||"ebusuku"===t?0===e?0:e+12:void 0},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:"%d",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("sv",{months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},calendar:{sameDay:"[Idag] LT",nextDay:"[Imorgon] LT",lastDay:"[Igår] LT",nextWeek:"[På] dddd LT",lastWeek:"[I] dddd[s] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}(e|a)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"e":1===t?"a":2===t?"a":"e";return e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("sw",{months:"Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des".split("_"),weekdays:"Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi".split("_"),weekdaysShort:"Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos".split("_"),weekdaysMin:"J2_J3_J4_J5_Al_Ij_J1".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[leo saa] LT",nextDay:"[kesho saa] LT",nextWeek:"[wiki ijayo] dddd [saat] LT",lastDay:"[jana] LT",lastWeek:"[wiki iliyopita] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s baadaye",past:"tokea %s",s:"hivi punde",m:"dakika moja",mm:"dakika %d",h:"saa limoja",hh:"masaa %d",d:"siku moja",dd:"masiku %d",M:"mwezi mmoja",MM:"miezi %d",y:"mwaka mmoja",yy:"miaka %d"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"௧",2:"௨",3:"௩",4:"௪",5:"௫",6:"௬",7:"௭",8:"௮",9:"௯",0:"௦"},n={"௧":"1","௨":"2","௩":"3","௪":"4","௫":"5","௬":"6","௭":"7","௮":"8","௯":"9","௦":"0"},a=e.defineLocale("ta",{months:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),
+monthsShort:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),weekdays:"ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை".split("_"),weekdaysShort:"ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி".split("_"),weekdaysMin:"ஞா_தி_செ_பு_வி_வெ_ச".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, HH:mm",LLLL:"dddd, D MMMM YYYY, HH:mm"},calendar:{sameDay:"[இன்று] LT",nextDay:"[நாளை] LT",nextWeek:"dddd, LT",lastDay:"[நேற்று] LT",lastWeek:"[கடந்த வாரம்] dddd, LT",sameElse:"L"},relativeTime:{future:"%s இல்",past:"%s முன்",s:"ஒரு சில விநாடிகள்",m:"ஒரு நிமிடம்",mm:"%d நிமிடங்கள்",h:"ஒரு மணி நேரம்",hh:"%d மணி நேரம்",d:"ஒரு நாள்",dd:"%d நாட்கள்",M:"ஒரு மாதம்",MM:"%d மாதங்கள்",y:"ஒரு வருடம்",yy:"%d ஆண்டுகள்"},dayOfMonthOrdinalParse:/\d{1,2}வது/,ordinal:function(e){return e+"வது"},preparse:function(e){return e.replace(/[௧௨௩௪௫௬௭௮௯௦]/g,function(e){return n[e]})},postformat:function(e){return e.replace(/\d/g,function(e){return t[e]})},meridiemParse:/யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,meridiem:function(e,t,n){return e<2?" யாமம்":e<6?" வைகறை":e<10?" காலை":e<14?" நண்பகல்":e<18?" எற்பாடு":e<22?" மாலை":" யாமம்"},meridiemHour:function(e,t){return 12===e&&(e=0),"யாமம்"===t?e<2?e:e+12:"வைகறை"===t||"காலை"===t?e:"நண்பகல்"===t&&e>=10?e:e+12},week:{dow:0,doy:6}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("te",{months:"జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జూలై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్".split("_"),monthsShort:"జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జూలై_ఆగ._సెప్._అక్టో._నవ._డిసె.".split("_"),monthsParseExact:!0,weekdays:"ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం".split("_"),weekdaysShort:"ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని".split("_"),weekdaysMin:"ఆ_సో_మం_బు_గు_శు_శ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[నేడు] LT",nextDay:"[రేపు] LT",nextWeek:"dddd, LT",lastDay:"[నిన్న] LT",lastWeek:"[గత] dddd, LT",sameElse:"L"},relativeTime:{future:"%s లో",past:"%s క్రితం",s:"కొన్ని క్షణాలు",m:"ఒక నిమిషం",mm:"%d నిమిషాలు",h:"ఒక గంట",hh:"%d గంటలు",d:"ఒక రోజు",dd:"%d రోజులు",M:"ఒక నెల",MM:"%d నెలలు",y:"ఒక సంవత్సరం",yy:"%d సంవత్సరాలు"},dayOfMonthOrdinalParse:/\d{1,2}వ/,ordinal:"%dవ",meridiemParse:/రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,meridiemHour:function(e,t){return 12===e&&(e=0),"రాత్రి"===t?e<4?e:e+12:"ఉదయం"===t?e:"మధ్యాహ్నం"===t?e>=10?e:e+12:"సాయంత్రం"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"రాత్రి":e<10?"ఉదయం":e<17?"మధ్యాహ్నం":e<20?"సాయంత్రం":"రాత్రి"},week:{dow:0,doy:6}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("tet",{months:"Janeiru_Fevereiru_Marsu_Abril_Maiu_Juniu_Juliu_Augustu_Setembru_Outubru_Novembru_Dezembru".split("_"),monthsShort:"Jan_Fev_Mar_Abr_Mai_Jun_Jul_Aug_Set_Out_Nov_Dez".split("_"),weekdays:"Domingu_Segunda_Tersa_Kuarta_Kinta_Sexta_Sabadu".split("_"),weekdaysShort:"Dom_Seg_Ters_Kua_Kint_Sext_Sab".split("_"),weekdaysMin:"Do_Seg_Te_Ku_Ki_Sex_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Ohin iha] LT",nextDay:"[Aban iha] LT",nextWeek:"dddd [iha] LT",lastDay:"[Horiseik iha] LT",lastWeek:"dddd [semana kotuk] [iha] LT",sameElse:"L"},relativeTime:{future:"iha %s",past:"%s liuba",s:"minutu balun",m:"minutu ida",mm:"minutus %d",h:"horas ida",hh:"horas %d",d:"loron ida",dd:"loron %d",M:"fulan ida",MM:"fulan %d",y:"tinan ida",yy:"tinan %d"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("th",{months:"มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม".split("_"),monthsShort:"ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.".split("_"),monthsParseExact:!0,weekdays:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์".split("_"),weekdaysShort:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์".split("_"),weekdaysMin:"อา._จ._อ._พ._พฤ._ศ._ส.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY เวลา H:mm",LLLL:"วันddddที่ D MMMM YYYY เวลา H:mm"},meridiemParse:/ก่อนเที่ยง|หลังเที่ยง/,isPM:function(e){return"หลังเที่ยง"===e},meridiem:function(e,t,n){return e<12?"ก่อนเที่ยง":"หลังเที่ยง"},calendar:{sameDay:"[วันนี้ เวลา] LT",nextDay:"[พรุ่งนี้ เวลา] LT",nextWeek:"dddd[หน้า เวลา] LT",lastDay:"[เมื่อวานนี้ เวลา] LT",lastWeek:"[วัน]dddd[ที่แล้ว เวลา] LT",sameElse:"L"},relativeTime:{future:"อีก %s",past:"%sที่แล้ว",s:"ไม่กี่วินาที",m:"1 นาที",mm:"%d นาที",h:"1 ชั่วโมง",hh:"%d ชั่วโมง",d:"1 วัน",dd:"%d วัน",M:"1 เดือน",MM:"%d เดือน",y:"1 ปี",yy:"%d ปี"}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("tl-ph",{months:"Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre".split("_"),monthsShort:"Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis".split("_"),weekdays:"Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado".split("_"),weekdaysShort:"Lin_Lun_Mar_Miy_Huw_Biy_Sab".split("_"),weekdaysMin:"Li_Lu_Ma_Mi_Hu_Bi_Sab".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"MM/D/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY HH:mm",LLLL:"dddd, MMMM DD, YYYY HH:mm"},calendar:{sameDay:"LT [ngayong araw]",nextDay:"[Bukas ng] LT",nextWeek:"LT [sa susunod na] dddd",lastDay:"LT [kahapon]",lastWeek:"LT [noong nakaraang] dddd",sameElse:"L"},relativeTime:{future:"sa loob ng %s",past:"%s ang nakalipas",s:"ilang segundo",m:"isang minuto",mm:"%d minuto",h:"isang oras",hh:"%d oras",d:"isang araw",dd:"%d araw",M:"isang buwan",MM:"%d buwan",y:"isang taon",yy:"%d taon"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e){var t=e;return t=e.indexOf("jaj")!==-1?t.slice(0,-3)+"leS":e.indexOf("jar")!==-1?t.slice(0,-3)+"waQ":e.indexOf("DIS")!==-1?t.slice(0,-3)+"nem":t+" pIq"}function n(e){var t=e;return t=e.indexOf("jaj")!==-1?t.slice(0,-3)+"Hu’":e.indexOf("jar")!==-1?t.slice(0,-3)+"wen":e.indexOf("DIS")!==-1?t.slice(0,-3)+"ben":t+" ret"}function a(e,t,n,a){var i=r(e);switch(n){case"mm":return i+" tup";case"hh":return i+" rep";case"dd":return i+" jaj";case"MM":return i+" jar";case"yy":return i+" DIS"}}function r(e){var t=Math.floor(e%1e3/100),n=Math.floor(e%100/10),a=e%10,r="";return t>0&&(r+=i[t]+"vatlh"),n>0&&(r+=(""!==r?" ":"")+i[n]+"maH"),a>0&&(r+=(""!==r?" ":"")+i[a]),""===r?"pagh":r}var i="pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut".split("_"),o=e.defineLocale("tlh",{months:"tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’".split("_"),monthsShort:"jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’".split("_"),monthsParseExact:!0,weekdays:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysShort:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysMin:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[DaHjaj] LT",nextDay:"[wa’leS] LT",nextWeek:"LLL",lastDay:"[wa’Hu’] LT",lastWeek:"LLL",sameElse:"L"},relativeTime:{future:t,past:n,s:"puS lup",m:"wa’ tup",mm:a,h:"wa’ rep",hh:a,d:"wa’ jaj",dd:a,M:"wa’ jar",MM:a,y:"wa’ DIS",yy:a},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return o})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t={1:"'inci",5:"'inci",8:"'inci",70:"'inci",80:"'inci",2:"'nci",7:"'nci",20:"'nci",50:"'nci",3:"'üncü",4:"'üncü",100:"'üncü",6:"'ncı",9:"'uncu",10:"'uncu",30:"'uncu",60:"'ıncı",90:"'ıncı"},n=e.defineLocale("tr",{months:"Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara".split("_"),weekdays:"Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Çar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ça_Pe_Cu_Ct".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[yarın saat] LT",nextWeek:"[haftaya] dddd [saat] LT",lastDay:"[dün] LT",lastWeek:"[geçen hafta] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},dayOfMonthOrdinalParse:/\d{1,2}'(inci|nci|üncü|ncı|uncu|ıncı)/,ordinal:function(e){if(0===e)return e+"'ıncı";var n=e%10,a=e%100-n,r=e>=100?100:null;return e+(t[n]||t[a]||t[r])},week:{dow:1,doy:7}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t,n,a){var r={s:["viensas secunds","'iensas secunds"],m:["'n míut","'iens míut"],mm:[e+" míuts",""+e+" míuts"],h:["'n þora","'iensa þora"],hh:[e+" þoras",""+e+" þoras"],d:["'n ziua","'iensa ziua"],dd:[e+" ziuas",""+e+" ziuas"],M:["'n mes","'iens mes"],MM:[e+" mesen",""+e+" mesen"],y:["'n ar","'iens ar"],yy:[e+" ars",""+e+" ars"]};return a?r[n][0]:t?r[n][0]:r[n][1]}var n=e.defineLocale("tzl",{months:"Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar".split("_"),monthsShort:"Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec".split("_"),weekdays:"Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi".split("_"),weekdaysShort:"Súl_Lún_Mai_Már_Xhú_Vié_Sát".split("_"),weekdaysMin:"Sú_Lú_Ma_Má_Xh_Vi_Sá".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"D. MMMM [dallas] YYYY",LLL:"D. MMMM [dallas] YYYY HH.mm",LLLL:"dddd, [li] D. MMMM [dallas] YYYY HH.mm"},meridiemParse:/d\'o|d\'a/i,isPM:function(e){return"d'o"===e.toLowerCase()},meridiem:function(e,t,n){return e>11?n?"d'o":"D'O":n?"d'a":"D'A"},calendar:{sameDay:"[oxhi à] LT",nextDay:"[demà à] LT",nextWeek:"dddd [à] LT",lastDay:"[ieiri à] LT",lastWeek:"[sür el] dddd [lasteu à] LT",sameElse:"L"},relativeTime:{future:"osprei %s",past:"ja%s",s:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}});return n})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("tzm-latn",{months:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),monthsShort:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),weekdays:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysShort:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysMin:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[asdkh g] LT",nextDay:"[aska g] LT",nextWeek:"dddd [g] LT",lastDay:"[assant g] LT",lastWeek:"dddd [g] LT",sameElse:"L"},relativeTime:{future:"dadkh s yan %s",past:"yan %s",s:"imik",m:"minuḍ",mm:"%d minuḍ",h:"saɛa",hh:"%d tassaɛin",d:"ass",dd:"%d ossan",M:"ayowr",MM:"%d iyyirn",y:"asgas",yy:"%d isgasn"},week:{dow:6,doy:12}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("tzm",{months:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),monthsShort:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),weekdays:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysShort:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysMin:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ⴰⵙⴷⵅ ⴴ] LT",nextDay:"[ⴰⵙⴽⴰ ⴴ] LT",nextWeek:"dddd [ⴴ] LT",lastDay:"[ⴰⵚⴰⵏⵜ ⴴ] LT",lastWeek:"dddd [ⴴ] LT",sameElse:"L"},relativeTime:{future:"ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s",past:"ⵢⴰⵏ %s",s:"ⵉⵎⵉⴽ",m:"ⵎⵉⵏⵓⴺ",mm:"%d ⵎⵉⵏⵓⴺ",h:"ⵙⴰⵄⴰ",hh:"%d ⵜⴰⵙⵙⴰⵄⵉⵏ",d:"ⴰⵙⵙ",dd:"%d oⵙⵙⴰⵏ",M:"ⴰⵢoⵓⵔ",MM:"%d ⵉⵢⵢⵉⵔⵏ",y:"ⴰⵙⴳⴰⵙ",yy:"%d ⵉⵙⴳⴰⵙⵏ"},week:{dow:6,doy:12}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";function t(e,t){var n=e.split("_");return t%10===1&&t%100!==11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,a){var r={mm:n?"хвилина_хвилини_хвилин":"хвилину_хвилини_хвилин",hh:n?"година_години_годин":"годину_години_годин",dd:"день_дні_днів",MM:"місяць_місяці_місяців",yy:"рік_роки_років"};return"m"===a?n?"хвилина":"хвилину":"h"===a?n?"година":"годину":e+" "+t(r[a],+e)}function a(e,t){var n={nominative:"неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота".split("_"),accusative:"неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу".split("_"),genitive:"неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи".split("_")};if(!e)return n.nominative;var a=/(\[[ВвУу]\]) ?dddd/.test(t)?"accusative":/\[?(?:минулої|наступної)? ?\] ?dddd/.test(t)?"genitive":"nominative";return n[a][e.day()]}function r(e){return function(){return e+"о"+(11===this.hours()?"б":"")+"] LT"}}var i=e.defineLocale("uk",{months:{format:"січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня".split("_"),standalone:"січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень".split("_")},monthsShort:"січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд".split("_"),weekdays:a,weekdaysShort:"нд_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY р.",LLL:"D MMMM YYYY р., HH:mm",LLLL:"dddd, D MMMM YYYY р., HH:mm"},calendar:{sameDay:r("[Сьогодні "),nextDay:r("[Завтра "),lastDay:r("[Вчора "),nextWeek:r("[У] dddd ["),lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return r("[Минулої] dddd [").call(this);case 1:case 2:case 4:return r("[Минулого] dddd [").call(this)}},sameElse:"L"},relativeTime:{future:"за %s",past:"%s тому",s:"декілька секунд",m:n,mm:n,h:"годину",hh:n,d:"день",dd:n,M:"місяць",MM:n,y:"рік",yy:n},meridiemParse:/ночі|ранку|дня|вечора/,isPM:function(e){return/^(дня|вечора)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночі":e<12?"ранку":e<17?"дня":"вечора"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e+"-й";case"D":return e+"-го";default:return e}},week:{dow:1,doy:7}});return i})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=["جنوری","فروری","مارچ","اپریل","مئی","جون","جولائی","اگست","ستمبر","اکتوبر","نومبر","دسمبر"],n=["اتوار","پیر","منگل","بدھ","جمعرات","جمعہ","ہفتہ"],a=e.defineLocale("ur",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:n,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,n){return e<12?"صبح":"شام"},calendar:{sameDay:"[آج بوقت] LT",nextDay:"[کل بوقت] LT",nextWeek:"dddd [بوقت] LT",lastDay:"[گذشتہ روز بوقت] LT",lastWeek:"[گذشتہ] dddd [بوقت] LT",sameElse:"L"},relativeTime:{future:"%s بعد",past:"%s قبل",s:"چند سیکنڈ",m:"ایک منٹ",mm:"%d منٹ",h:"ایک گھنٹہ",hh:"%d گھنٹے",d:"ایک دن",dd:"%d دن",M:"ایک ماہ",MM:"%d ماہ",y:"ایک سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}});return a})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("uz-latn",{months:"Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr".split("_"),monthsShort:"Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek".split("_"),weekdays:"Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba".split("_"),weekdaysShort:"Yak_Dush_Sesh_Chor_Pay_Jum_Shan".split("_"),weekdaysMin:"Ya_Du_Se_Cho_Pa_Ju_Sha".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Bugun soat] LT [da]",nextDay:"[Ertaga] LT [da]",nextWeek:"dddd [kuni soat] LT [da]",lastDay:"[Kecha soat] LT [da]",lastWeek:"[O'tgan] dddd [kuni soat] LT [da]",sameElse:"L"},relativeTime:{future:"Yaqin %s ichida",past:"Bir necha %s oldin",s:"soniya",m:"bir daqiqa",mm:"%d daqiqa",h:"bir soat",hh:"%d soat",d:"bir kun",dd:"%d kun",M:"bir oy",MM:"%d oy",y:"bir yil",yy:"%d yil"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("uz",{months:"январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр".split("_"),monthsShort:"янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек".split("_"),weekdays:"Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба".split("_"),weekdaysShort:"Якш_Душ_Сеш_Чор_Пай_Жум_Шан".split("_"),weekdaysMin:"Як_Ду_Се_Чо_Па_Жу_Ша".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Бугун соат] LT [да]",nextDay:"[Эртага] LT [да]",nextWeek:"dddd [куни соат] LT [да]",lastDay:"[Кеча соат] LT [да]",lastWeek:"[Утган] dddd [куни соат] LT [да]",sameElse:"L"},relativeTime:{future:"Якин %s ичида",past:"Бир неча %s олдин",s:"фурсат",m:"бир дакика",mm:"%d дакика",h:"бир соат",hh:"%d соат",d:"бир кун",dd:"%d кун",M:"бир ой",MM:"%d ой",y:"бир йил",yy:"%d йил"},week:{dow:1,doy:7}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("vi",{months:"tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12".split("_"),monthsShort:"Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12".split("_"),monthsParseExact:!0,weekdays:"chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy".split("_"),weekdaysShort:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysMin:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysParseExact:!0,meridiemParse:/sa|ch/i,isPM:function(e){return/^ch$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"sa":"SA":n?"ch":"CH"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [năm] YYYY",LLL:"D MMMM [năm] YYYY HH:mm",LLLL:"dddd, D MMMM [năm] YYYY HH:mm",l:"DD/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[Hôm nay lúc] LT",nextDay:"[Ngày mai lúc] LT",nextWeek:"dddd [tuần tới lúc] LT",lastDay:"[Hôm qua lúc] LT",lastWeek:"dddd [tuần rồi lúc] LT",sameElse:"L"},relativeTime:{future:"%s tới",past:"%s trước",s:"vài giây",m:"một phút",mm:"%d phút",h:"một giờ",hh:"%d giờ",d:"một ngày",dd:"%d ngày",M:"một tháng",MM:"%d tháng",y:"một năm",yy:"%d năm"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("x-pseudo",{months:"J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér".split("_"),monthsShort:"J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc".split("_"),monthsParseExact:!0,weekdays:"S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý".split("_"),weekdaysShort:"S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát".split("_"),weekdaysMin:"S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[T~ódá~ý át] LT",nextDay:"[T~ómó~rró~w át] LT",nextWeek:"dddd [át] LT",lastDay:"[Ý~ést~érdá~ý át] LT",lastWeek:"[L~ást] dddd [át] LT",sameElse:"L"},relativeTime:{future:"í~ñ %s",past:"%s á~gó",s:"á ~féw ~sécó~ñds",m:"á ~míñ~úté",mm:"%d m~íñú~tés",h:"á~ñ hó~úr",hh:"%d h~óúrs",d:"á ~dáý",dd:"%d d~áýs",M:"á ~móñ~th",MM:"%d m~óñt~hs",y:"á ~ýéár",yy:"%d ý~éárs"},dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10,n=1===~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th";return e+n},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("yo",{months:"Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀".split("_"),monthsShort:"Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀".split("_"),weekdays:"Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta".split("_"),weekdaysShort:"Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá".split("_"),weekdaysMin:"Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Ònì ni] LT",nextDay:"[Ọ̀la ni] LT",nextWeek:"dddd [Ọsẹ̀ tón'bọ] [ni] LT",lastDay:"[Àna ni] LT",lastWeek:"dddd [Ọsẹ̀ tólọ́] [ni] LT",sameElse:"L"},relativeTime:{future:"ní %s",past:"%s kọjá",s:"ìsẹjú aayá die",m:"ìsẹjú kan",mm:"ìsẹjú %d",h:"wákati kan",hh:"wákati %d",d:"ọjọ́ kan",dd:"ọjọ́ %d",M:"osù kan",MM:"osù %d",y:"ọdún kan",yy:"ọdún %d"},dayOfMonthOrdinalParse:/ọjọ́\s\d{1,2}/,ordinal:"ọjọ́ %d",week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("zh-cn",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"周日_周一_周二_周三_周四_周五_周六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY年MMMD日",LL:"YYYY年MMMD日",LLL:"YYYY年MMMD日Ah点mm分",LLLL:"YYYY年MMMD日ddddAh点mm分",l:"YYYY年MMMD日",ll:"YYYY年MMMD日",lll:"YYYY年MMMD日 HH:mm",llll:"YYYY年MMMD日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"下午"===t||"晚上"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,n){var a=100*e+t;return a<600?"凌晨":a<900?"早上":a<1130?"上午":a<1230?"中午":a<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|周)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"周";default:return e}},relativeTime:{future:"%s内",past:"%s前",s:"几秒",m:"1 分钟",mm:"%d 分钟",h:"1 小时",hh:"%d 小时",d:"1 天",dd:"%d 天",M:"1 个月",MM:"%d 个月",y:"1 年",yy:"%d 年"},week:{dow:1,doy:4}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("zh-hk",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY年MMMD日",LL:"YYYY年MMMD日",LLL:"YYYY年MMMD日 HH:mm",LLLL:"YYYY年MMMD日dddd HH:mm",l:"YYYY年MMMD日",ll:"YYYY年MMMD日",lll:"YYYY年MMMD日 HH:mm",llll:"YYYY年MMMD日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var a=100*e+t;return a<600?"凌晨":a<900?"早上":a<1130?"上午":a<1230?"中午":a<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s內",past:"%s前",s:"幾秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}});return t})},function(e,t,n){!function(e,t){t(n(1))}(this,function(e){"use strict";var t=e.defineLocale("zh-tw",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY年MMMD日",LL:"YYYY年MMMD日",LLL:"YYYY年MMMD日 HH:mm",LLLL:"YYYY年MMMD日dddd HH:mm",l:"YYYY年MMMD日",ll:"YYYY年MMMD日",lll:"YYYY年MMMD日 HH:mm",llll:"YYYY年MMMD日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var a=100*e+t;return a<600?"凌晨":a<900?"早上":a<1130?"上午":a<1230?"中午":a<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s內",past:"%s前",s:"幾秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}});return t})},function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children=[],e.webpackPolyfill=1),e}},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"bar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1},categoryPercentage:.5,barPercentage:.2}]}},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"bar",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"bubble-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1},categoryPercentage:.5,barPercentage:.2}]}},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"bubble",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"doughnut-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"doughnut",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"horizontalbar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1},categoryPercentage:.5,barPercentage:.2}]}},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t,n){var a=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"horizontalBar",data:e,options:a,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"line-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1}}]}},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"line",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"pie-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"pie",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{
+default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"polar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"polarArea",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"radar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"radar",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(7),i=a(r),o=n(6),s=a(o),d=n(5);t.default=i.default.extend({render:function(e){return e("div",{style:this.styles,class:this.cssClasses},[e("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"scatter-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{xAxes:[{type:"linear",position:"bottom"}]}},plugins:[]}},methods:{addPlugin:function(e){this.plugins.push(e)},renderChart:function(e,t){var n=(0,d.mergeOptions)(this.defaultOptions,t);this._chart=new s.default(this.$refs.canvas.getContext("2d"),{type:"scatter",data:e,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var r=n(150),i=a(r),o=n(151),s=a(o);t.default={reactiveData:i.default,reactiveProp:s.default}},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}var r=n(17),i=a(r),o=n(16),s=a(o);e.exports={data:function(){return{chartData:null}},watch:{chartData:{handler:function(e,t){if(t){var n=this._chart,a=e.datasets.map(function(e){return e.label}),r=t.datasets.map(function(e){return e.label}),o=(0,s.default)(r),d=(0,s.default)(a);d===o&&t.datasets.length===e.datasets.length?(e.datasets.forEach(function(e,a){var r=(0,i.default)(t.datasets[a]),o=(0,i.default)(e),s=r.filter(function(e){return"_meta"!==e&&o.indexOf(e)===-1});s.forEach(function(e){delete n.data.datasets[a][e]});for(var d in e)e.hasOwnProperty(d)&&(n.data.datasets[a][d]=e[d])}),e.hasOwnProperty("labels")&&(n.data.labels=e.labels),e.hasOwnProperty("xLabels")&&(n.data.xLabels=e.xLabels),e.hasOwnProperty("yLabels")&&(n.data.yLabels=e.yLabels),n.update()):(n.destroy(),this.renderChart(this.chartData,this.options))}else this.renderChart(this.chartData,this.options)}}}}},function(e,t,n){"use strict";function a(e){return e&&e.__esModule?e:{default:e}}var r=n(17),i=a(r),o=n(16),s=a(o);e.exports={props:{chartData:{required:!0}},watch:{chartData:{handler:function(e,t){if(t){var n=this._chart,a=e.datasets.map(function(e){return e.label}),r=t.datasets.map(function(e){return e.label}),o=(0,s.default)(r),d=(0,s.default)(a);d===o&&t.datasets.length===e.datasets.length?(e.datasets.forEach(function(e,a){var r=(0,i.default)(t.datasets[a]),o=(0,i.default)(e),s=r.filter(function(e){return"_meta"!==e&&o.indexOf(e)===-1});s.forEach(function(e){delete n.data.datasets[a][e]});for(var d in e)e.hasOwnProperty(d)&&(n.data.datasets[a][d]=e[d])}),e.hasOwnProperty("labels")&&(n.data.labels=e.labels),e.hasOwnProperty("xLabels")&&(n.data.xLabels=e.xLabels),e.hasOwnProperty("yLabels")&&(n.data.yLabels=e.yLabels),n.update()):(n.destroy(),this.renderChart(this.chartData,this.options))}else this.renderChart(this.chartData,this.options)}}}}},function(e,t){"use strict";e.exports=function(e){e.Bar=function(t,n){return n.type="bar",new e(t,n)}}},function(e,t){"use strict";e.exports=function(e){e.Bubble=function(t,n){return n.type="bubble",new e(t,n)}}},function(e,t){"use strict";e.exports=function(e){e.Doughnut=function(t,n){return n.type="doughnut",new e(t,n)}}},function(e,t){"use strict";e.exports=function(e){e.Line=function(t,n){return n.type="line",new e(t,n)}}},function(e,t){"use strict";e.exports=function(e){e.PolarArea=function(t,n){return n.type="polarArea",new e(t,n)}}},function(e,t){"use strict";e.exports=function(e){e.Radar=function(t,n){return n.type="radar",new e(t,n)}}},function(e,t){"use strict";e.exports=function(e){e.Scatter=function(t,n){return n.type="scatter",new e(t,n)}}},function(e,t,n){"use strict";var a=n(3),r=n(8),i=n(2);a._set("bar",{hover:{mode:"label"},scales:{xAxes:[{type:"category",categoryPercentage:.8,barPercentage:.9,offset:!0,gridLines:{offsetGridLines:!0}}],yAxes:[{type:"linear"}]}}),a._set("horizontalBar",{hover:{mode:"index",axis:"y"},scales:{xAxes:[{type:"linear",position:"bottom"}],yAxes:[{position:"left",type:"category",categoryPercentage:.8,barPercentage:.9,offset:!0,gridLines:{offsetGridLines:!0}}]},elements:{rectangle:{borderSkipped:"left"}},tooltips:{callbacks:{title:function(e,t){var n="";return e.length>0&&(e[0].yLabel?n=e[0].yLabel:t.labels.length>0&&e[0].index<t.labels.length&&(n=t.labels[e[0].index])),n},label:function(e,t){var n=t.datasets[e.datasetIndex].label||"";return n+": "+e.xLabel}},mode:"index",axis:"y"}}),e.exports=function(e){e.controllers.bar=e.DatasetController.extend({dataElementType:r.Rectangle,initialize:function(){var t,n=this;e.DatasetController.prototype.initialize.apply(n,arguments),t=n.getMeta(),t.stack=n.getDataset().stack,t.bar=!0},update:function(e){var t,n,a=this,r=a.getMeta().data;for(a._ruler=a.getRuler(),t=0,n=r.length;t<n;++t)a.updateElement(r[t],t,e)},updateElement:function(e,t,n){var a=this,r=a.chart,o=a.getMeta(),s=a.getDataset(),d=e.custom||{},u=r.options.elements.rectangle;e._xScale=a.getScaleForId(o.xAxisID),e._yScale=a.getScaleForId(o.yAxisID),e._datasetIndex=a.index,e._index=t,e._model={datasetLabel:s.label,label:r.data.labels[t],borderSkipped:d.borderSkipped?d.borderSkipped:u.borderSkipped,backgroundColor:d.backgroundColor?d.backgroundColor:i.valueAtIndexOrDefault(s.backgroundColor,t,u.backgroundColor),borderColor:d.borderColor?d.borderColor:i.valueAtIndexOrDefault(s.borderColor,t,u.borderColor),borderWidth:d.borderWidth?d.borderWidth:i.valueAtIndexOrDefault(s.borderWidth,t,u.borderWidth)},a.updateElementGeometry(e,t,n),e.pivot()},updateElementGeometry:function(e,t,n){var a=this,r=e._model,i=a.getValueScale(),o=i.getBasePixel(),s=i.isHorizontal(),d=a._ruler||a.getRuler(),u=a.calculateBarValuePixels(a.index,t),l=a.calculateBarIndexPixels(a.index,t,d);r.horizontal=s,r.base=n?o:u.base,r.x=s?n?o:u.head:l.center,r.y=s?l.center:n?o:u.head,r.height=s?l.size:void 0,r.width=s?void 0:l.size},getValueScaleId:function(){return this.getMeta().yAxisID},getIndexScaleId:function(){return this.getMeta().xAxisID},getValueScale:function(){return this.getScaleForId(this.getValueScaleId())},getIndexScale:function(){return this.getScaleForId(this.getIndexScaleId())},getStackCount:function(e){var t,n,a=this,r=a.chart,i=a.getIndexScale(),o=i.options.stacked,s=void 0===e?r.data.datasets.length:e+1,d=[];for(t=0;t<s;++t)n=r.getDatasetMeta(t),n.bar&&r.isDatasetVisible(t)&&(o===!1||o===!0&&d.indexOf(n.stack)===-1||void 0===o&&(void 0===n.stack||d.indexOf(n.stack)===-1))&&d.push(n.stack);return d.length},getStackIndex:function(e){return this.getStackCount(e)-1},getRuler:function(){var e,t,n=this,a=n.getIndexScale(),r=n.getStackCount(),i=n.index,o=[],s=a.isHorizontal(),d=s?a.left:a.top,u=d+(s?a.width:a.height);for(e=0,t=n.getMeta().data.length;e<t;++e)o.push(a.getPixelForValue(null,e,i));return{pixels:o,start:d,end:u,stackCount:r,scale:a}},calculateBarValuePixels:function(e,t){var n,a,r,i,o,s,d=this,u=d.chart,l=d.getMeta(),c=d.getValueScale(),h=u.data.datasets,_=c.getRightValue(h[e].data[t]),m=c.options.stacked,f=l.stack,p=0;if(m||void 0===m&&void 0!==f)for(n=0;n<e;++n)a=u.getDatasetMeta(n),a.bar&&a.stack===f&&a.controller.getValueScaleId()===c.id&&u.isDatasetVisible(n)&&(r=c.getRightValue(h[n].data[t]),(_<0&&r<0||_>=0&&r>0)&&(p+=r));return i=c.getPixelForValue(p),o=c.getPixelForValue(p+_),s=(o-i)/2,{size:s,base:i,head:o,center:o+s/2}},calculateBarIndexPixels:function(e,t,n){var a,r,o,s,d,u,l=this,c=n.scale.options,h=l.getStackIndex(e),_=n.pixels,m=_[t],f=_.length,p=n.start,y=n.end;return 1===f?(a=m>p?m-p:y-m,r=m<y?y-m:m-p):(t>0&&(a=(m-_[t-1])/2,t===f-1&&(r=a)),t<f-1&&(r=(_[t+1]-m)/2,0===t&&(a=r))),o=a*c.categoryPercentage,s=r*c.categoryPercentage,d=(o+s)/n.stackCount,u=d*c.barPercentage,u=Math.min(i.valueOrDefault(c.barThickness,u),i.valueOrDefault(c.maxBarThickness,1/0)),m-=o,m+=d*h,m+=(d-u)/2,{size:u,base:m,head:m+u,center:m+u/2}},draw:function(){var e=this,t=e.chart,n=e.getValueScale(),a=e.getMeta().data,r=e.getDataset(),o=a.length,s=0;for(i.canvas.clipArea(t.ctx,t.chartArea);s<o;++s)isNaN(n.getRightValue(r.data[s]))||a[s].draw();i.canvas.unclipArea(t.ctx)},setHoverStyle:function(e){var t=this.chart.data.datasets[e._datasetIndex],n=e._index,a=e.custom||{},r=e._model;r.backgroundColor=a.hoverBackgroundColor?a.hoverBackgroundColor:i.valueAtIndexOrDefault(t.hoverBackgroundColor,n,i.getHoverColor(r.backgroundColor)),r.borderColor=a.hoverBorderColor?a.hoverBorderColor:i.valueAtIndexOrDefault(t.hoverBorderColor,n,i.getHoverColor(r.borderColor)),r.borderWidth=a.hoverBorderWidth?a.hoverBorderWidth:i.valueAtIndexOrDefault(t.hoverBorderWidth,n,r.borderWidth)},removeHoverStyle:function(e){var t=this.chart.data.datasets[e._datasetIndex],n=e._index,a=e.custom||{},r=e._model,o=this.chart.options.elements.rectangle;r.backgroundColor=a.backgroundColor?a.backgroundColor:i.valueAtIndexOrDefault(t.backgroundColor,n,o.backgroundColor),r.borderColor=a.borderColor?a.borderColor:i.valueAtIndexOrDefault(t.borderColor,n,o.borderColor),r.borderWidth=a.borderWidth?a.borderWidth:i.valueAtIndexOrDefault(t.borderWidth,n,o.borderWidth)}}),e.controllers.horizontalBar=e.controllers.bar.extend({getValueScaleId:function(){return this.getMeta().xAxisID},getIndexScaleId:function(){return this.getMeta().yAxisID}})}},function(e,t,n){"use strict";var a=n(3),r=n(8),i=n(2);a._set("bubble",{hover:{mode:"single"},scales:{xAxes:[{type:"linear",position:"bottom",id:"x-axis-0"}],yAxes:[{type:"linear",position:"left",id:"y-axis-0"}]},tooltips:{callbacks:{title:function(){return""},label:function(e,t){var n=t.datasets[e.datasetIndex].label||"",a=t.datasets[e.datasetIndex].data[e.index];return n+": ("+e.xLabel+", "+e.yLabel+", "+a.r+")"}}}}),e.exports=function(e){e.controllers.bubble=e.DatasetController.extend({dataElementType:r.Point,update:function(e){var t=this,n=t.getMeta(),a=n.data;i.each(a,function(n,a){t.updateElement(n,a,e)})},updateElement:function(e,t,n){var a=this,r=a.getMeta(),i=e.custom||{},o=a.getScaleForId(r.xAxisID),s=a.getScaleForId(r.yAxisID),d=a._resolveElementOptions(e,t),u=a.getDataset().data[t],l=a.index,c=n?o.getPixelForDecimal(.5):o.getPixelForValue("object"==typeof u?u:NaN,t,l),h=n?s.getBasePixel():s.getPixelForValue(u,t,l);e._xScale=o,e._yScale=s,e._options=d,e._datasetIndex=l,e._index=t,e._model={backgroundColor:d.backgroundColor,borderColor:d.borderColor,borderWidth:d.borderWidth,hitRadius:d.hitRadius,pointStyle:d.pointStyle,radius:n?0:d.radius,skip:i.skip||isNaN(c)||isNaN(h),x:c,y:h},e.pivot()},setHoverStyle:function(e){var t=e._model,n=e._options;t.backgroundColor=i.valueOrDefault(n.hoverBackgroundColor,i.getHoverColor(n.backgroundColor)),t.borderColor=i.valueOrDefault(n.hoverBorderColor,i.getHoverColor(n.borderColor)),t.borderWidth=i.valueOrDefault(n.hoverBorderWidth,n.borderWidth),t.radius=n.radius+n.hoverRadius},removeHoverStyle:function(e){var t=e._model,n=e._options;t.backgroundColor=n.backgroundColor,t.borderColor=n.borderColor,t.borderWidth=n.borderWidth,t.radius=n.radius},_resolveElementOptions:function(e,t){var n,a,r,o=this,s=o.chart,d=s.data.datasets,u=d[o.index],l=e.custom||{},c=s.options.elements.point,h=i.options.resolve,_=u.data[t],m={},f={chart:s,dataIndex:t,dataset:u,datasetIndex:o.index},p=["backgroundColor","borderColor","borderWidth","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth","hoverRadius","hitRadius","pointStyle"];for(n=0,a=p.length;n<a;++n)r=p[n],m[r]=h([l[r],u[r],c[r]],f,t);return m.radius=h([l.radius,_?_.r:void 0,u.radius,c.radius],f,t),m}})}},function(e,t,n){"use strict";var a=n(3),r=n(8),i=n(2);a._set("doughnut",{animation:{animateRotate:!0,animateScale:!1},hover:{mode:"single"},legendCallback:function(e){var t=[];t.push('<ul class="'+e.id+'-legend">');var n=e.data,a=n.datasets,r=n.labels;if(a.length)for(var i=0;i<a[0].data.length;++i)t.push('<li><span style="background-color:'+a[0].backgroundColor[i]+'"></span>'),r[i]&&t.push(r[i]),t.push("</li>");return t.push("</ul>"),t.join("")},legend:{labels:{generateLabels:function(e){var t=e.data;return t.labels.length&&t.datasets.length?t.labels.map(function(n,a){var r=e.getDatasetMeta(0),o=t.datasets[0],s=r.data[a],d=s&&s.custom||{},u=i.valueAtIndexOrDefault,l=e.options.elements.arc,c=d.backgroundColor?d.backgroundColor:u(o.backgroundColor,a,l.backgroundColor),h=d.borderColor?d.borderColor:u(o.borderColor,a,l.borderColor),_=d.borderWidth?d.borderWidth:u(o.borderWidth,a,l.borderWidth);return{text:n,fillStyle:c,strokeStyle:h,lineWidth:_,hidden:isNaN(o.data[a])||r.data[a].hidden,index:a}}):[]}},onClick:function(e,t){var n,a,r,i=t.index,o=this.chart;for(n=0,a=(o.data.datasets||[]).length;n<a;++n)r=o.getDatasetMeta(n),r.data[i]&&(r.data[i].hidden=!r.data[i].hidden);o.update()}},cutoutPercentage:50,rotation:Math.PI*-.5,circumference:2*Math.PI,tooltips:{callbacks:{title:function(){return""},label:function(e,t){var n=t.labels[e.index],a=": "+t.datasets[e.datasetIndex].data[e.index];return i.isArray(n)?(n=n.slice(),n[0]+=a):n+=a,n}}}}),a._set("pie",i.clone(a.doughnut)),a._set("pie",{cutoutPercentage:0}),e.exports=function(e){e.controllers.doughnut=e.controllers.pie=e.DatasetController.extend({dataElementType:r.Arc,linkScales:i.noop,getRingIndex:function(e){for(var t=0,n=0;n<e;++n)this.chart.isDatasetVisible(n)&&++t;return t},update:function(e){var t=this,n=t.chart,a=n.chartArea,r=n.options,o=r.elements.arc,s=a.right-a.left-o.borderWidth,d=a.bottom-a.top-o.borderWidth,u=Math.min(s,d),l={x:0,y:0},c=t.getMeta(),h=r.cutoutPercentage,_=r.circumference;if(_<2*Math.PI){var m=r.rotation%(2*Math.PI);m+=2*Math.PI*(m>=Math.PI?-1:m<-Math.PI?1:0);var f=m+_,p={x:Math.cos(m),y:Math.sin(m)},y={x:Math.cos(f),y:Math.sin(f)},g=m<=0&&f>=0||m<=2*Math.PI&&2*Math.PI<=f,v=m<=.5*Math.PI&&.5*Math.PI<=f||m<=2.5*Math.PI&&2.5*Math.PI<=f,M=m<=-Math.PI&&-Math.PI<=f||m<=Math.PI&&Math.PI<=f,L=m<=.5*-Math.PI&&.5*-Math.PI<=f||m<=1.5*Math.PI&&1.5*Math.PI<=f,b=h/100,k={x:M?-1:Math.min(p.x*(p.x<0?1:b),y.x*(y.x<0?1:b)),y:L?-1:Math.min(p.y*(p.y<0?1:b),y.y*(y.y<0?1:b))},Y={x:g?1:Math.max(p.x*(p.x>0?1:b),y.x*(y.x>0?1:b)),y:v?1:Math.max(p.y*(p.y>0?1:b),y.y*(y.y>0?1:b))},D={width:.5*(Y.x-k.x),height:.5*(Y.y-k.y)};u=Math.min(s/D.width,d/D.height),l={x:(Y.x+k.x)*-.5,y:(Y.y+k.y)*-.5}}n.borderWidth=t.getMaxBorderWidth(c.data),n.outerRadius=Math.max((u-n.borderWidth)/2,0),n.innerRadius=Math.max(h?n.outerRadius/100*h:0,0),n.radiusLength=(n.outerRadius-n.innerRadius)/n.getVisibleDatasetCount(),n.offsetX=l.x*n.outerRadius,n.offsetY=l.y*n.outerRadius,c.total=t.calculateTotal(),t.outerRadius=n.outerRadius-n.radiusLength*t.getRingIndex(t.index),t.innerRadius=Math.max(t.outerRadius-n.radiusLength,0),i.each(c.data,function(n,a){t.updateElement(n,a,e)})},updateElement:function(e,t,n){var a=this,r=a.chart,o=r.chartArea,s=r.options,d=s.animation,u=(o.left+o.right)/2,l=(o.top+o.bottom)/2,c=s.rotation,h=s.rotation,_=a.getDataset(),m=n&&d.animateRotate?0:e.hidden?0:a.calculateCircumference(_.data[t])*(s.circumference/(2*Math.PI)),f=n&&d.animateScale?0:a.innerRadius,p=n&&d.animateScale?0:a.outerRadius,y=i.valueAtIndexOrDefault;i.extend(e,{_datasetIndex:a.index,_index:t,_model:{x:u+r.offsetX,y:l+r.offsetY,startAngle:c,endAngle:h,circumference:m,outerRadius:p,innerRadius:f,label:y(_.label,t,r.data.labels[t])}});var g=e._model;this.removeHoverStyle(e),n&&d.animateRotate||(0===t?g.startAngle=s.rotation:g.startAngle=a.getMeta().data[t-1]._model.endAngle,g.endAngle=g.startAngle+g.circumference),e.pivot()},removeHoverStyle:function(t){e.DatasetController.prototype.removeHoverStyle.call(this,t,this.chart.options.elements.arc)},calculateTotal:function(){var e,t=this.getDataset(),n=this.getMeta(),a=0;return i.each(n.data,function(n,r){e=t.data[r],isNaN(e)||n.hidden||(a+=Math.abs(e))}),a},calculateCircumference:function(e){var t=this.getMeta().total;return t>0&&!isNaN(e)?2*Math.PI*(e/t):0},getMaxBorderWidth:function(e){for(var t,n,a=0,r=this.index,i=e.length,o=0;o<i;o++)t=e[o]._model?e[o]._model.borderWidth:0,n=e[o]._chart?e[o]._chart.config.data.datasets[r].hoverBorderWidth:0,a=t>a?t:a,a=n>a?n:a;return a}})}},function(e,t,n){"use strict";var a=n(3),r=n(8),i=n(2);a._set("line",{showLines:!0,spanGaps:!1,hover:{mode:"label"},scales:{xAxes:[{type:"category",id:"x-axis-0"}],yAxes:[{type:"linear",id:"y-axis-0"}]}}),e.exports=function(e){function t(e,t){return i.valueOrDefault(e.showLine,t.showLines)}e.controllers.line=e.DatasetController.extend({datasetElementType:r.Line,dataElementType:r.Point,update:function(e){var n,a,r,o=this,s=o.getMeta(),d=s.dataset,u=s.data||[],l=o.chart.options,c=l.elements.line,h=o.getScaleForId(s.yAxisID),_=o.getDataset(),m=t(_,l);for(m&&(r=d.custom||{},void 0!==_.tension&&void 0===_.lineTension&&(_.lineTension=_.tension),d._scale=h,d._datasetIndex=o.index,d._children=u,d._model={spanGaps:_.spanGaps?_.spanGaps:l.spanGaps,tension:r.tension?r.tension:i.valueOrDefault(_.lineTension,c.tension),backgroundColor:r.backgroundColor?r.backgroundColor:_.backgroundColor||c.backgroundColor,borderWidth:r.borderWidth?r.borderWidth:_.borderWidth||c.borderWidth,borderColor:r.borderColor?r.borderColor:_.borderColor||c.borderColor,borderCapStyle:r.borderCapStyle?r.borderCapStyle:_.borderCapStyle||c.borderCapStyle,borderDash:r.borderDash?r.borderDash:_.borderDash||c.borderDash,borderDashOffset:r.borderDashOffset?r.borderDashOffset:_.borderDashOffset||c.borderDashOffset,borderJoinStyle:r.borderJoinStyle?r.borderJoinStyle:_.borderJoinStyle||c.borderJoinStyle,fill:r.fill?r.fill:void 0!==_.fill?_.fill:c.fill,steppedLine:r.steppedLine?r.steppedLine:i.valueOrDefault(_.steppedLine,c.stepped),cubicInterpolationMode:r.cubicInterpolationMode?r.cubicInterpolationMode:i.valueOrDefault(_.cubicInterpolationMode,c.cubicInterpolationMode)},d.pivot()),n=0,a=u.length;n<a;++n)o.updateElement(u[n],n,e);for(m&&0!==d._model.tension&&o.updateBezierControlPoints(),n=0,a=u.length;n<a;++n)u[n].pivot()},getPointBackgroundColor:function(e,t){var n=this.chart.options.elements.point.backgroundColor,a=this.getDataset(),r=e.custom||{};return r.backgroundColor?n=r.backgroundColor:a.pointBackgroundColor?n=i.valueAtIndexOrDefault(a.pointBackgroundColor,t,n):a.backgroundColor&&(n=a.backgroundColor),n},getPointBorderColor:function(e,t){var n=this.chart.options.elements.point.borderColor,a=this.getDataset(),r=e.custom||{};return r.borderColor?n=r.borderColor:a.pointBorderColor?n=i.valueAtIndexOrDefault(a.pointBorderColor,t,n):a.borderColor&&(n=a.borderColor),n},getPointBorderWidth:function(e,t){var n=this.chart.options.elements.point.borderWidth,a=this.getDataset(),r=e.custom||{};return isNaN(r.borderWidth)?!isNaN(a.pointBorderWidth)||i.isArray(a.pointBorderWidth)?n=i.valueAtIndexOrDefault(a.pointBorderWidth,t,n):isNaN(a.borderWidth)||(n=a.borderWidth):n=r.borderWidth,n},updateElement:function(e,t,n){var a,r,o=this,s=o.getMeta(),d=e.custom||{},u=o.getDataset(),l=o.index,c=u.data[t],h=o.getScaleForId(s.yAxisID),_=o.getScaleForId(s.xAxisID),m=o.chart.options.elements.point;void 0!==u.radius&&void 0===u.pointRadius&&(u.pointRadius=u.radius),void 0!==u.hitRadius&&void 0===u.pointHitRadius&&(u.pointHitRadius=u.hitRadius),a=_.getPixelForValue("object"==typeof c?c:NaN,t,l),r=n?h.getBasePixel():o.calculatePointY(c,t,l),e._xScale=_,e._yScale=h,e._datasetIndex=l,e._index=t,e._model={x:a,y:r,skip:d.skip||isNaN(a)||isNaN(r),radius:d.radius||i.valueAtIndexOrDefault(u.pointRadius,t,m.radius),pointStyle:d.pointStyle||i.valueAtIndexOrDefault(u.pointStyle,t,m.pointStyle),backgroundColor:o.getPointBackgroundColor(e,t),borderColor:o.getPointBorderColor(e,t),borderWidth:o.getPointBorderWidth(e,t),tension:s.dataset._model?s.dataset._model.tension:0,steppedLine:!!s.dataset._model&&s.dataset._model.steppedLine,hitRadius:d.hitRadius||i.valueAtIndexOrDefault(u.pointHitRadius,t,m.hitRadius)}},calculatePointY:function(e,t,n){var a,r,i,o=this,s=o.chart,d=o.getMeta(),u=o.getScaleForId(d.yAxisID),l=0,c=0;if(u.options.stacked){for(a=0;a<n;a++)if(r=s.data.datasets[a],i=s.getDatasetMeta(a),"line"===i.type&&i.yAxisID===u.id&&s.isDatasetVisible(a)){var h=Number(u.getRightValue(r.data[t]));h<0?c+=h||0:l+=h||0}var _=Number(u.getRightValue(e));return _<0?u.getPixelForValue(c+_):u.getPixelForValue(l+_)}return u.getPixelForValue(e)},updateBezierControlPoints:function(){function e(e,t,n){return Math.max(Math.min(e,n),t)}var t,n,a,r,o,s=this,d=s.getMeta(),u=s.chart.chartArea,l=d.data||[];if(d.dataset._model.spanGaps&&(l=l.filter(function(e){return!e._model.skip})),"monotone"===d.dataset._model.cubicInterpolationMode)i.splineCurveMonotone(l);else for(t=0,n=l.length;t<n;++t)a=l[t],r=a._model,o=i.splineCurve(i.previousItem(l,t)._model,r,i.nextItem(l,t)._model,d.dataset._model.tension),r.controlPointPreviousX=o.previous.x,r.controlPointPreviousY=o.previous.y,r.controlPointNextX=o.next.x,r.controlPointNextY=o.next.y;if(s.chart.options.elements.line.capBezierPoints)for(t=0,n=l.length;t<n;++t)r=l[t]._model,r.controlPointPreviousX=e(r.controlPointPreviousX,u.left,u.right),r.controlPointPreviousY=e(r.controlPointPreviousY,u.top,u.bottom),r.controlPointNextX=e(r.controlPointNextX,u.left,u.right),r.controlPointNextY=e(r.controlPointNextY,u.top,u.bottom)},draw:function(){var e=this,n=e.chart,a=e.getMeta(),r=a.data||[],o=n.chartArea,s=r.length,d=0;for(i.canvas.clipArea(n.ctx,o),t(e.getDataset(),n.options)&&a.dataset.draw(),i.canvas.unclipArea(n.ctx);d<s;++d)r[d].draw(o)},setHoverStyle:function(e){var t=this.chart.data.datasets[e._datasetIndex],n=e._index,a=e.custom||{},r=e._model;r.radius=a.hoverRadius||i.valueAtIndexOrDefault(t.pointHoverRadius,n,this.chart.options.elements.point.hoverRadius),r.backgroundColor=a.hoverBackgroundColor||i.valueAtIndexOrDefault(t.pointHoverBackgroundColor,n,i.getHoverColor(r.backgroundColor)),r.borderColor=a.hoverBorderColor||i.valueAtIndexOrDefault(t.pointHoverBorderColor,n,i.getHoverColor(r.borderColor)),r.borderWidth=a.hoverBorderWidth||i.valueAtIndexOrDefault(t.pointHoverBorderWidth,n,r.borderWidth)},removeHoverStyle:function(e){var t=this,n=t.chart.data.datasets[e._datasetIndex],a=e._index,r=e.custom||{},o=e._model;void 0!==n.radius&&void 0===n.pointRadius&&(n.pointRadius=n.radius),o.radius=r.radius||i.valueAtIndexOrDefault(n.pointRadius,a,t.chart.options.elements.point.radius),o.backgroundColor=t.getPointBackgroundColor(e,a),o.borderColor=t.getPointBorderColor(e,a),o.borderWidth=t.getPointBorderWidth(e,a)}})}},function(e,t,n){"use strict";var a=n(3),r=n(8),i=n(2);a._set("polarArea",{scale:{type:"radialLinear",angleLines:{display:!1},gridLines:{circular:!0},pointLabels:{display:!1},ticks:{beginAtZero:!0}},animation:{animateRotate:!0,animateScale:!0},startAngle:-.5*Math.PI,legendCallback:function(e){var t=[];t.push('<ul class="'+e.id+'-legend">');var n=e.data,a=n.datasets,r=n.labels;if(a.length)for(var i=0;i<a[0].data.length;++i)t.push('<li><span style="background-color:'+a[0].backgroundColor[i]+'"></span>'),r[i]&&t.push(r[i]),t.push("</li>");return t.push("</ul>"),t.join("")},legend:{labels:{generateLabels:function(e){var t=e.data;return t.labels.length&&t.datasets.length?t.labels.map(function(n,a){var r=e.getDatasetMeta(0),o=t.datasets[0],s=r.data[a],d=s.custom||{},u=i.valueAtIndexOrDefault,l=e.options.elements.arc,c=d.backgroundColor?d.backgroundColor:u(o.backgroundColor,a,l.backgroundColor),h=d.borderColor?d.borderColor:u(o.borderColor,a,l.borderColor),_=d.borderWidth?d.borderWidth:u(o.borderWidth,a,l.borderWidth);return{text:n,fillStyle:c,strokeStyle:h,lineWidth:_,hidden:isNaN(o.data[a])||r.data[a].hidden,index:a}}):[]}},onClick:function(e,t){var n,a,r,i=t.index,o=this.chart;for(n=0,a=(o.data.datasets||[]).length;n<a;++n)r=o.getDatasetMeta(n),r.data[i].hidden=!r.data[i].hidden;o.update()}},tooltips:{callbacks:{title:function(){return""},label:function(e,t){return t.labels[e.index]+": "+e.yLabel}}}}),e.exports=function(e){e.controllers.polarArea=e.DatasetController.extend({dataElementType:r.Arc,linkScales:i.noop,update:function(e){var t=this,n=t.chart,a=n.chartArea,r=t.getMeta(),o=n.options,s=o.elements.arc,d=Math.min(a.right-a.left,a.bottom-a.top);n.outerRadius=Math.max((d-s.borderWidth/2)/2,0),n.innerRadius=Math.max(o.cutoutPercentage?n.outerRadius/100*o.cutoutPercentage:1,0),n.radiusLength=(n.outerRadius-n.innerRadius)/n.getVisibleDatasetCount(),t.outerRadius=n.outerRadius-n.radiusLength*t.index,t.innerRadius=t.outerRadius-n.radiusLength,r.count=t.countVisibleElements(),i.each(r.data,function(n,a){t.updateElement(n,a,e)})},updateElement:function(e,t,n){for(var a=this,r=a.chart,o=a.getDataset(),s=r.options,d=s.animation,u=r.scale,l=r.data.labels,c=a.calculateCircumference(o.data[t]),h=u.xCenter,_=u.yCenter,m=0,f=a.getMeta(),p=0;p<t;++p)isNaN(o.data[p])||f.data[p].hidden||++m;var y=s.startAngle,g=e.hidden?0:u.getDistanceFromCenterForValue(o.data[t]),v=y+c*m,M=v+(e.hidden?0:c),L=d.animateScale?0:u.getDistanceFromCenterForValue(o.data[t]);i.extend(e,{_datasetIndex:a.index,_index:t,_scale:u,_model:{x:h,y:_,innerRadius:0,outerRadius:n?L:g,startAngle:n&&d.animateRotate?y:v,endAngle:n&&d.animateRotate?y:M,label:i.valueAtIndexOrDefault(l,t,l[t])}}),a.removeHoverStyle(e),e.pivot()},removeHoverStyle:function(t){e.DatasetController.prototype.removeHoverStyle.call(this,t,this.chart.options.elements.arc)},countVisibleElements:function(){var e=this.getDataset(),t=this.getMeta(),n=0;return i.each(t.data,function(t,a){isNaN(e.data[a])||t.hidden||n++}),n},calculateCircumference:function(e){var t=this.getMeta().count;return t>0&&!isNaN(e)?2*Math.PI/t:0}})}},function(e,t,n){"use strict";var a=n(3),r=n(8),i=n(2);a._set("radar",{scale:{type:"radialLinear"},elements:{line:{tension:0}}}),e.exports=function(e){e.controllers.radar=e.DatasetController.extend({datasetElementType:r.Line,dataElementType:r.Point,linkScales:i.noop,update:function(e){var t=this,n=t.getMeta(),a=n.dataset,r=n.data,o=a.custom||{},s=t.getDataset(),d=t.chart.options.elements.line,u=t.chart.scale;void 0!==s.tension&&void 0===s.lineTension&&(s.lineTension=s.tension),i.extend(n.dataset,{_datasetIndex:t.index,_scale:u,_children:r,_loop:!0,_model:{tension:o.tension?o.tension:i.valueOrDefault(s.lineTension,d.tension),backgroundColor:o.backgroundColor?o.backgroundColor:s.backgroundColor||d.backgroundColor,borderWidth:o.borderWidth?o.borderWidth:s.borderWidth||d.borderWidth,borderColor:o.borderColor?o.borderColor:s.borderColor||d.borderColor,fill:o.fill?o.fill:void 0!==s.fill?s.fill:d.fill,borderCapStyle:o.borderCapStyle?o.borderCapStyle:s.borderCapStyle||d.borderCapStyle,borderDash:o.borderDash?o.borderDash:s.borderDash||d.borderDash,borderDashOffset:o.borderDashOffset?o.borderDashOffset:s.borderDashOffset||d.borderDashOffset,borderJoinStyle:o.borderJoinStyle?o.borderJoinStyle:s.borderJoinStyle||d.borderJoinStyle}}),n.dataset.pivot(),i.each(r,function(n,a){t.updateElement(n,a,e)},t),t.updateBezierControlPoints()},updateElement:function(e,t,n){var a=this,r=e.custom||{},o=a.getDataset(),s=a.chart.scale,d=a.chart.options.elements.point,u=s.getPointPositionForValue(t,o.data[t]);void 0!==o.radius&&void 0===o.pointRadius&&(o.pointRadius=o.radius),void 0!==o.hitRadius&&void 0===o.pointHitRadius&&(o.pointHitRadius=o.hitRadius),i.extend(e,{_datasetIndex:a.index,_index:t,_scale:s,_model:{x:n?s.xCenter:u.x,y:n?s.yCenter:u.y,tension:r.tension?r.tension:i.valueOrDefault(o.lineTension,a.chart.options.elements.line.tension),radius:r.radius?r.radius:i.valueAtIndexOrDefault(o.pointRadius,t,d.radius),backgroundColor:r.backgroundColor?r.backgroundColor:i.valueAtIndexOrDefault(o.pointBackgroundColor,t,d.backgroundColor),borderColor:r.borderColor?r.borderColor:i.valueAtIndexOrDefault(o.pointBorderColor,t,d.borderColor),borderWidth:r.borderWidth?r.borderWidth:i.valueAtIndexOrDefault(o.pointBorderWidth,t,d.borderWidth),pointStyle:r.pointStyle?r.pointStyle:i.valueAtIndexOrDefault(o.pointStyle,t,d.pointStyle),hitRadius:r.hitRadius?r.hitRadius:i.valueAtIndexOrDefault(o.pointHitRadius,t,d.hitRadius)}}),e._model.skip=r.skip?r.skip:isNaN(e._model.x)||isNaN(e._model.y)},updateBezierControlPoints:function(){var e=this.chart.chartArea,t=this.getMeta();i.each(t.data,function(n,a){var r=n._model,o=i.splineCurve(i.previousItem(t.data,a,!0)._model,r,i.nextItem(t.data,a,!0)._model,r.tension);r.controlPointPreviousX=Math.max(Math.min(o.previous.x,e.right),e.left),r.controlPointPreviousY=Math.max(Math.min(o.previous.y,e.bottom),e.top),r.controlPointNextX=Math.max(Math.min(o.next.x,e.right),e.left),r.controlPointNextY=Math.max(Math.min(o.next.y,e.bottom),e.top),n.pivot()})},setHoverStyle:function(e){var t=this.chart.data.datasets[e._datasetIndex],n=e.custom||{},a=e._index,r=e._model;r.radius=n.hoverRadius?n.hoverRadius:i.valueAtIndexOrDefault(t.pointHoverRadius,a,this.chart.options.elements.point.hoverRadius),r.backgroundColor=n.hoverBackgroundColor?n.hoverBackgroundColor:i.valueAtIndexOrDefault(t.pointHoverBackgroundColor,a,i.getHoverColor(r.backgroundColor)),r.borderColor=n.hoverBorderColor?n.hoverBorderColor:i.valueAtIndexOrDefault(t.pointHoverBorderColor,a,i.getHoverColor(r.borderColor)),r.borderWidth=n.hoverBorderWidth?n.hoverBorderWidth:i.valueAtIndexOrDefault(t.pointHoverBorderWidth,a,r.borderWidth)},removeHoverStyle:function(e){var t=this.chart.data.datasets[e._datasetIndex],n=e.custom||{},a=e._index,r=e._model,o=this.chart.options.elements.point;r.radius=n.radius?n.radius:i.valueAtIndexOrDefault(t.pointRadius,a,o.radius),r.backgroundColor=n.backgroundColor?n.backgroundColor:i.valueAtIndexOrDefault(t.pointBackgroundColor,a,o.backgroundColor),r.borderColor=n.borderColor?n.borderColor:i.valueAtIndexOrDefault(t.pointBorderColor,a,o.borderColor),r.borderWidth=n.borderWidth?n.borderWidth:i.valueAtIndexOrDefault(t.pointBorderWidth,a,o.borderWidth)}})}},function(e,t,n){"use strict";var a=n(3);a._set("scatter",{hover:{mode:"single"},scales:{xAxes:[{id:"x-axis-1",type:"linear",position:"bottom"}],yAxes:[{id:"y-axis-1",type:"linear",position:"left"}]},showLines:!1,tooltips:{callbacks:{title:function(){return""},label:function(e){return"("+e.xLabel+", "+e.yLabel+")"}}}}),e.exports=function(e){e.controllers.scatter=e.controllers.line}},function(e,t,n){"use strict";var a=n(3),r=n(4),i=n(2);a._set("global",{animation:{duration:1e3,easing:"easeOutQuart",onProgress:i.noop,onComplete:i.noop}}),
+e.exports=function(e){e.Animation=r.extend({chart:null,currentStep:0,numSteps:60,easing:"",render:null,onAnimationProgress:null,onAnimationComplete:null}),e.animationService={frameDuration:17,animations:[],dropFrames:0,request:null,addAnimation:function(e,t,n,a){var r,i,o=this.animations;for(t.chart=e,a||(e.animating=!0),r=0,i=o.length;r<i;++r)if(o[r].chart===e)return void(o[r]=t);o.push(t),1===o.length&&this.requestAnimationFrame()},cancelAnimation:function(e){var t=i.findIndex(this.animations,function(t){return t.chart===e});t!==-1&&(this.animations.splice(t,1),e.animating=!1)},requestAnimationFrame:function(){var e=this;null===e.request&&(e.request=i.requestAnimFrame.call(window,function(){e.request=null,e.startDigest()}))},startDigest:function(){var e=this,t=Date.now(),n=0;e.dropFrames>1&&(n=Math.floor(e.dropFrames),e.dropFrames=e.dropFrames%1),e.advance(1+n);var a=Date.now();e.dropFrames+=(a-t)/e.frameDuration,e.animations.length>0&&e.requestAnimationFrame()},advance:function(e){for(var t,n,a=this.animations,r=0;r<a.length;)t=a[r],n=t.chart,t.currentStep=(t.currentStep||0)+e,t.currentStep=Math.min(t.currentStep,t.numSteps),i.callback(t.render,[n,t],n),i.callback(t.onAnimationProgress,[t],n),t.currentStep>=t.numSteps?(i.callback(t.onAnimationComplete,[t],n),n.animating=!1,a.splice(r,1)):++r}},Object.defineProperty(e.Animation.prototype,"animationObject",{get:function(){return this}}),Object.defineProperty(e.Animation.prototype,"chartInstance",{get:function(){return this.chart},set:function(e){this.chart=e}})}},function(e,t,n){"use strict";var a=n(3),r=n(2),i=n(18),o=n(19);e.exports=function(e){function t(e){e=e||{};var t=e.data=e.data||{};return t.datasets=t.datasets||[],t.labels=t.labels||[],e.options=r.configMerge(a.global,a[e.type],e.options||{}),e}function n(e){var t=e.options;t.scale?e.scale.options=t.scale:t.scales&&t.scales.xAxes.concat(t.scales.yAxes).forEach(function(t){e.scales[t.id].options=t}),e.tooltip._options=t.tooltips}function s(e){return"top"===e||"bottom"===e}var d=e.plugins;e.types={},e.instances={},e.controllers={},r.extend(e.prototype,{construct:function(n,a){var i=this;a=t(a);var s=o.acquireContext(n,a),d=s&&s.canvas,u=d&&d.height,l=d&&d.width;return i.id=r.uid(),i.ctx=s,i.canvas=d,i.config=a,i.width=l,i.height=u,i.aspectRatio=u?l/u:null,i.options=a.options,i._bufferedRender=!1,i.chart=i,i.controller=i,e.instances[i.id]=i,Object.defineProperty(i,"data",{get:function(){return i.config.data},set:function(e){i.config.data=e}}),s&&d?(i.initialize(),void i.update()):void console.error("Failed to create chart: can't acquire context from the given item")},initialize:function(){var e=this;return d.notify(e,"beforeInit"),r.retinaScale(e,e.options.devicePixelRatio),e.bindEvents(),e.options.responsive&&e.resize(!0),e.ensureScalesHaveIDs(),e.buildScales(),e.initToolTip(),d.notify(e,"afterInit"),e},clear:function(){return r.canvas.clear(this),this},stop:function(){return e.animationService.cancelAnimation(this),this},resize:function(e){var t=this,n=t.options,a=t.canvas,i=n.maintainAspectRatio&&t.aspectRatio||null,o=Math.max(0,Math.floor(r.getMaximumWidth(a))),s=Math.max(0,Math.floor(i?o/i:r.getMaximumHeight(a)));if((t.width!==o||t.height!==s)&&(a.width=t.width=o,a.height=t.height=s,a.style.width=o+"px",a.style.height=s+"px",r.retinaScale(t,n.devicePixelRatio),!e)){var u={width:o,height:s};d.notify(t,"resize",[u]),t.options.onResize&&t.options.onResize(t,u),t.stop(),t.update(t.options.responsiveAnimationDuration)}},ensureScalesHaveIDs:function(){var e=this.options,t=e.scales||{},n=e.scale;r.each(t.xAxes,function(e,t){e.id=e.id||"x-axis-"+t}),r.each(t.yAxes,function(e,t){e.id=e.id||"y-axis-"+t}),n&&(n.id=n.id||"scale")},buildScales:function(){var t=this,n=t.options,a=t.scales={},i=[];n.scales&&(i=i.concat((n.scales.xAxes||[]).map(function(e){return{options:e,dtype:"category",dposition:"bottom"}}),(n.scales.yAxes||[]).map(function(e){return{options:e,dtype:"linear",dposition:"left"}}))),n.scale&&i.push({options:n.scale,dtype:"radialLinear",isDefault:!0,dposition:"chartArea"}),r.each(i,function(n){var i=n.options,o=r.valueOrDefault(i.type,n.dtype),d=e.scaleService.getScaleConstructor(o);if(d){s(i.position)!==s(n.dposition)&&(i.position=n.dposition);var u=new d({id:i.id,options:i,ctx:t.ctx,chart:t});a[u.id]=u,u.mergeTicksOptions(),n.isDefault&&(t.scale=u)}}),e.scaleService.addScalesToLayout(this)},buildOrUpdateControllers:function(){var t=this,n=[],a=[];return r.each(t.data.datasets,function(r,i){var o=t.getDatasetMeta(i),s=r.type||t.config.type;if(o.type&&o.type!==s&&(t.destroyDatasetMeta(i),o=t.getDatasetMeta(i)),o.type=s,n.push(o.type),o.controller)o.controller.updateIndex(i);else{var d=e.controllers[o.type];if(void 0===d)throw new Error('"'+o.type+'" is not a chart type.');o.controller=new d(t,i),a.push(o.controller)}},t),a},resetElements:function(){var e=this;r.each(e.data.datasets,function(t,n){e.getDatasetMeta(n).controller.reset()},e)},reset:function(){this.resetElements(),this.tooltip.initialize()},update:function(e){var t=this;if(e&&"object"==typeof e||(e={duration:e,lazy:arguments[1]}),n(t),d.notify(t,"beforeUpdate")!==!1){t.tooltip._data=t.data;var a=t.buildOrUpdateControllers();r.each(t.data.datasets,function(e,n){t.getDatasetMeta(n).controller.buildOrUpdateElements()},t),t.updateLayout(),r.each(a,function(e){e.reset()}),t.updateDatasets(),d.notify(t,"afterUpdate"),t._bufferedRender?t._bufferedRequest={duration:e.duration,easing:e.easing,lazy:e.lazy}:t.render(e)}},updateLayout:function(){var t=this;d.notify(t,"beforeLayout")!==!1&&(e.layoutService.update(this,this.width,this.height),d.notify(t,"afterScaleUpdate"),d.notify(t,"afterLayout"))},updateDatasets:function(){var e=this;if(d.notify(e,"beforeDatasetsUpdate")!==!1){for(var t=0,n=e.data.datasets.length;t<n;++t)e.updateDataset(t);d.notify(e,"afterDatasetsUpdate")}},updateDataset:function(e){var t=this,n=t.getDatasetMeta(e),a={meta:n,index:e};d.notify(t,"beforeDatasetUpdate",[a])!==!1&&(n.controller.update(),d.notify(t,"afterDatasetUpdate",[a]))},render:function(t){var n=this;t&&"object"==typeof t||(t={duration:t,lazy:arguments[1]});var a=t.duration,i=t.lazy;if(d.notify(n,"beforeRender")!==!1){var o=n.options.animation,s=function(e){d.notify(n,"afterRender"),r.callback(o&&o.onComplete,[e],n)};if(o&&("undefined"!=typeof a&&0!==a||"undefined"==typeof a&&0!==o.duration)){var u=new e.Animation({numSteps:(a||o.duration)/16.66,easing:t.easing||o.easing,render:function(e,t){var n=r.easing.effects[t.easing],a=t.currentStep,i=a/t.numSteps;e.draw(n(i),i,a)},onAnimationProgress:o.onProgress,onAnimationComplete:s});e.animationService.addAnimation(n,u,a,i)}else n.draw(),s(new e.Animation({numSteps:0,chart:n}));return n}},draw:function(e){var t=this;t.clear(),r.isNullOrUndef(e)&&(e=1),t.transition(e),d.notify(t,"beforeDraw",[e])!==!1&&(r.each(t.boxes,function(e){e.draw(t.chartArea)},t),t.scale&&t.scale.draw(),t.drawDatasets(e),t.tooltip.draw(),d.notify(t,"afterDraw",[e]))},transition:function(e){for(var t=this,n=0,a=(t.data.datasets||[]).length;n<a;++n)t.isDatasetVisible(n)&&t.getDatasetMeta(n).controller.transition(e);t.tooltip.transition(e)},drawDatasets:function(e){var t=this;if(d.notify(t,"beforeDatasetsDraw",[e])!==!1){for(var n=(t.data.datasets||[]).length-1;n>=0;--n)t.isDatasetVisible(n)&&t.drawDataset(n,e);d.notify(t,"afterDatasetsDraw",[e])}},drawDataset:function(e,t){var n=this,a=n.getDatasetMeta(e),r={meta:a,index:e,easingValue:t};d.notify(n,"beforeDatasetDraw",[r])!==!1&&(a.controller.draw(t),d.notify(n,"afterDatasetDraw",[r]))},getElementAtEvent:function(e){return i.modes.single(this,e)},getElementsAtEvent:function(e){return i.modes.label(this,e,{intersect:!0})},getElementsAtXAxis:function(e){return i.modes["x-axis"](this,e,{intersect:!0})},getElementsAtEventForMode:function(e,t,n){var a=i.modes[t];return"function"==typeof a?a(this,e,n):[]},getDatasetAtEvent:function(e){return i.modes.dataset(this,e,{intersect:!0})},getDatasetMeta:function(e){var t=this,n=t.data.datasets[e];n._meta||(n._meta={});var a=n._meta[t.id];return a||(a=n._meta[t.id]={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null}),a},getVisibleDatasetCount:function(){for(var e=0,t=0,n=this.data.datasets.length;t<n;++t)this.isDatasetVisible(t)&&e++;return e},isDatasetVisible:function(e){var t=this.getDatasetMeta(e);return"boolean"==typeof t.hidden?!t.hidden:!this.data.datasets[e].hidden},generateLegend:function(){return this.options.legendCallback(this)},destroyDatasetMeta:function(e){var t=this.id,n=this.data.datasets[e],a=n._meta&&n._meta[t];a&&(a.controller.destroy(),delete n._meta[t])},destroy:function(){var t,n,a=this,i=a.canvas;for(a.stop(),t=0,n=a.data.datasets.length;t<n;++t)a.destroyDatasetMeta(t);i&&(a.unbindEvents(),r.canvas.clear(a),o.releaseContext(a.ctx),a.canvas=null,a.ctx=null),d.notify(a,"destroy"),delete e.instances[a.id]},toBase64Image:function(){return this.canvas.toDataURL.apply(this.canvas,arguments)},initToolTip:function(){var t=this;t.tooltip=new e.Tooltip({_chart:t,_chartInstance:t,_data:t.data,_options:t.options.tooltips},t)},bindEvents:function(){var e=this,t=e._listeners={},n=function(){e.eventHandler.apply(e,arguments)};r.each(e.options.events,function(a){o.addEventListener(e,a,n),t[a]=n}),e.options.responsive&&(n=function(){e.resize()},o.addEventListener(e,"resize",n),t.resize=n)},unbindEvents:function(){var e=this,t=e._listeners;t&&(delete e._listeners,r.each(t,function(t,n){o.removeEventListener(e,n,t)}))},updateHoverStyle:function(e,t,n){var a,r,i,o=n?"setHoverStyle":"removeHoverStyle";for(r=0,i=e.length;r<i;++r)a=e[r],a&&this.getDatasetMeta(a._datasetIndex).controller[o](a)},eventHandler:function(e){var t=this,n=t.tooltip;if(d.notify(t,"beforeEvent",[e])!==!1){t._bufferedRender=!0,t._bufferedRequest=null;var a=t.handleEvent(e);a|=n&&n.handleEvent(e),d.notify(t,"afterEvent",[e]);var r=t._bufferedRequest;return r?t.render(r):a&&!t.animating&&(t.stop(),t.render(t.options.hover.animationDuration,!0)),t._bufferedRender=!1,t._bufferedRequest=null,t}},handleEvent:function(e){var t=this,n=t.options||{},a=n.hover,i=!1;return t.lastActive=t.lastActive||[],"mouseout"===e.type?t.active=[]:t.active=t.getElementsAtEventForMode(e,a.mode,a),r.callback(n.onHover||n.hover.onHover,[e.native,t.active],t),"mouseup"!==e.type&&"click"!==e.type||n.onClick&&n.onClick.call(t,e.native,t.active),t.lastActive.length&&t.updateHoverStyle(t.lastActive,a.mode,!1),t.active.length&&a.mode&&t.updateHoverStyle(t.active,a.mode,!0),i=!r.arrayEquals(t.active,t.lastActive),t.lastActive=t.active,i}}),e.Controller=e}},function(e,t,n){"use strict";var a=n(2);e.exports=function(e){function t(e,t){return e._chartjs?void e._chartjs.listeners.push(t):(Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),void r.forEach(function(t){var n="onData"+t.charAt(0).toUpperCase()+t.slice(1),r=e[t];Object.defineProperty(e,t,{configurable:!0,enumerable:!1,value:function(){var t=Array.prototype.slice.call(arguments),i=r.apply(this,t);return a.each(e._chartjs.listeners,function(e){"function"==typeof e[n]&&e[n].apply(e,t)}),i}})}))}function n(e,t){var n=e._chartjs;if(n){var a=n.listeners,i=a.indexOf(t);i!==-1&&a.splice(i,1),a.length>0||(r.forEach(function(t){delete e[t]}),delete e._chartjs)}}var r=["push","pop","shift","splice","unshift"];e.DatasetController=function(e,t){this.initialize(e,t)},a.extend(e.DatasetController.prototype,{datasetElementType:null,dataElementType:null,initialize:function(e,t){var n=this;n.chart=e,n.index=t,n.linkScales(),n.addElements()},updateIndex:function(e){this.index=e},linkScales:function(){var e=this,t=e.getMeta(),n=e.getDataset();null===t.xAxisID&&(t.xAxisID=n.xAxisID||e.chart.options.scales.xAxes[0].id),null===t.yAxisID&&(t.yAxisID=n.yAxisID||e.chart.options.scales.yAxes[0].id)},getDataset:function(){return this.chart.data.datasets[this.index]},getMeta:function(){return this.chart.getDatasetMeta(this.index)},getScaleForId:function(e){return this.chart.scales[e]},reset:function(){this.update(!0)},destroy:function(){this._data&&n(this._data,this)},createMetaDataset:function(){var e=this,t=e.datasetElementType;return t&&new t({_chart:e.chart,_datasetIndex:e.index})},createMetaData:function(e){var t=this,n=t.dataElementType;return n&&new n({_chart:t.chart,_datasetIndex:t.index,_index:e})},addElements:function(){var e,t,n=this,a=n.getMeta(),r=n.getDataset().data||[],i=a.data;for(e=0,t=r.length;e<t;++e)i[e]=i[e]||n.createMetaData(e);a.dataset=a.dataset||n.createMetaDataset()},addElementAndReset:function(e){var t=this.createMetaData(e);this.getMeta().data.splice(e,0,t),this.updateElement(t,e,!0)},buildOrUpdateElements:function(){var e=this,a=e.getDataset(),r=a.data||(a.data=[]);e._data!==r&&(e._data&&n(e._data,e),t(r,e),e._data=r),e.resyncElements()},update:a.noop,transition:function(e){for(var t=this.getMeta(),n=t.data||[],a=n.length,r=0;r<a;++r)n[r].transition(e);t.dataset&&t.dataset.transition(e)},draw:function(){var e=this.getMeta(),t=e.data||[],n=t.length,a=0;for(e.dataset&&e.dataset.draw();a<n;++a)t[a].draw()},removeHoverStyle:function(e,t){var n=this.chart.data.datasets[e._datasetIndex],r=e._index,i=e.custom||{},o=a.valueAtIndexOrDefault,s=e._model;s.backgroundColor=i.backgroundColor?i.backgroundColor:o(n.backgroundColor,r,t.backgroundColor),s.borderColor=i.borderColor?i.borderColor:o(n.borderColor,r,t.borderColor),s.borderWidth=i.borderWidth?i.borderWidth:o(n.borderWidth,r,t.borderWidth)},setHoverStyle:function(e){var t=this.chart.data.datasets[e._datasetIndex],n=e._index,r=e.custom||{},i=a.valueAtIndexOrDefault,o=a.getHoverColor,s=e._model;s.backgroundColor=r.hoverBackgroundColor?r.hoverBackgroundColor:i(t.hoverBackgroundColor,n,o(s.backgroundColor)),s.borderColor=r.hoverBorderColor?r.hoverBorderColor:i(t.hoverBorderColor,n,o(s.borderColor)),s.borderWidth=r.hoverBorderWidth?r.hoverBorderWidth:i(t.hoverBorderWidth,n,s.borderWidth)},resyncElements:function(){var e=this,t=e.getMeta(),n=e.getDataset().data,a=t.data.length,r=n.length;r<a?t.data.splice(r,a-r):r>a&&e.insertElements(a,r-a)},insertElements:function(e,t){for(var n=0;n<t;++n)this.addElementAndReset(e+n)},onDataPush:function(){this.insertElements(this.getDataset().data.length-1,arguments.length)},onDataPop:function(){this.getMeta().data.pop()},onDataShift:function(){this.getMeta().data.shift()},onDataSplice:function(e,t){this.getMeta().data.splice(e,t),this.insertElements(e,arguments.length-2)},onDataUnshift:function(){this.insertElements(0,arguments.length)}}),e.DatasetController.extend=a.inherits}},function(e,t,n){"use strict";var a=n(20),r=n(3),i=n(2);e.exports=function(e){function t(e,t,n){var a;return"string"==typeof e?(a=parseInt(e,10),e.indexOf("%")!==-1&&(a=a/100*t.parentNode[n])):a=e,a}function n(e){return void 0!==e&&null!==e&&"none"!==e}function o(e,a,r){var i=document.defaultView,o=e.parentNode,s=i.getComputedStyle(e)[a],d=i.getComputedStyle(o)[a],u=n(s),l=n(d),c=Number.POSITIVE_INFINITY;return u||l?Math.min(u?t(s,e,r):c,l?t(d,o,r):c):"none"}i.extend=function(e){for(var t=function(t,n){e[n]=t},n=1,a=arguments.length;n<a;n++)i.each(arguments[n],t);return e},i.configMerge=function(){return i.merge(i.clone(arguments[0]),[].slice.call(arguments,1),{merger:function(t,n,a,r){var o=n[t]||{},s=a[t];"scales"===t?n[t]=i.scaleMerge(o,s):"scale"===t?n[t]=i.merge(o,[e.scaleService.getScaleDefaults(s.type),s]):i._merger(t,n,a,r)}})},i.scaleMerge=function(){return i.merge(i.clone(arguments[0]),[].slice.call(arguments,1),{merger:function(t,n,a,r){if("xAxes"===t||"yAxes"===t){var o,s,d,u=a[t].length;for(n[t]||(n[t]=[]),o=0;o<u;++o)d=a[t][o],s=i.valueOrDefault(d.type,"xAxes"===t?"category":"linear"),o>=n[t].length&&n[t].push({}),!n[t][o].type||d.type&&d.type!==n[t][o].type?i.merge(n[t][o],[e.scaleService.getScaleDefaults(s),d]):i.merge(n[t][o],d)}else i._merger(t,n,a,r)}})},i.where=function(e,t){if(i.isArray(e)&&Array.prototype.filter)return e.filter(t);var n=[];return i.each(e,function(e){t(e)&&n.push(e)}),n},i.findIndex=Array.prototype.findIndex?function(e,t,n){return e.findIndex(t,n)}:function(e,t,n){n=void 0===n?e:n;for(var a=0,r=e.length;a<r;++a)if(t.call(n,e[a],a,e))return a;return-1},i.findNextWhere=function(e,t,n){i.isNullOrUndef(n)&&(n=-1);for(var a=n+1;a<e.length;a++){var r=e[a];if(t(r))return r}},i.findPreviousWhere=function(e,t,n){i.isNullOrUndef(n)&&(n=e.length);for(var a=n-1;a>=0;a--){var r=e[a];if(t(r))return r}},i.inherits=function(e){var t=this,n=e&&e.hasOwnProperty("constructor")?e.constructor:function(){return t.apply(this,arguments)},a=function(){this.constructor=n};return a.prototype=t.prototype,n.prototype=new a,n.extend=i.inherits,e&&i.extend(n.prototype,e),n.__super__=t.prototype,n},i.isNumber=function(e){return!isNaN(parseFloat(e))&&isFinite(e)},i.almostEquals=function(e,t,n){return Math.abs(e-t)<n},i.almostWhole=function(e,t){var n=Math.round(e);return n-t<e&&n+t>e},i.max=function(e){return e.reduce(function(e,t){return isNaN(t)?e:Math.max(e,t)},Number.NEGATIVE_INFINITY)},i.min=function(e){return e.reduce(function(e,t){return isNaN(t)?e:Math.min(e,t)},Number.POSITIVE_INFINITY)},i.sign=Math.sign?function(e){return Math.sign(e)}:function(e){return e=+e,0===e||isNaN(e)?e:e>0?1:-1},i.log10=Math.log10?function(e){return Math.log10(e)}:function(e){return Math.log(e)/Math.LN10},i.toRadians=function(e){return e*(Math.PI/180)},i.toDegrees=function(e){return e*(180/Math.PI)},i.getAngleFromPoint=function(e,t){var n=t.x-e.x,a=t.y-e.y,r=Math.sqrt(n*n+a*a),i=Math.atan2(a,n);return i<-.5*Math.PI&&(i+=2*Math.PI),{angle:i,distance:r}},i.distanceBetweenPoints=function(e,t){return Math.sqrt(Math.pow(t.x-e.x,2)+Math.pow(t.y-e.y,2))},i.aliasPixel=function(e){return e%2===0?0:.5},i.splineCurve=function(e,t,n,a){var r=e.skip?t:e,i=t,o=n.skip?t:n,s=Math.sqrt(Math.pow(i.x-r.x,2)+Math.pow(i.y-r.y,2)),d=Math.sqrt(Math.pow(o.x-i.x,2)+Math.pow(o.y-i.y,2)),u=s/(s+d),l=d/(s+d);u=isNaN(u)?0:u,l=isNaN(l)?0:l;var c=a*u,h=a*l;return{previous:{x:i.x-c*(o.x-r.x),y:i.y-c*(o.y-r.y)},next:{x:i.x+h*(o.x-r.x),y:i.y+h*(o.y-r.y)}}},i.EPSILON=Number.EPSILON||1e-14,i.splineCurveMonotone=function(e){var t,n,a,r,o=(e||[]).map(function(e){return{model:e._model,deltaK:0,mK:0}}),s=o.length;for(t=0;t<s;++t)if(a=o[t],!a.model.skip){if(n=t>0?o[t-1]:null,r=t<s-1?o[t+1]:null,r&&!r.model.skip){var d=r.model.x-a.model.x;a.deltaK=0!==d?(r.model.y-a.model.y)/d:0}!n||n.model.skip?a.mK=a.deltaK:!r||r.model.skip?a.mK=n.deltaK:this.sign(n.deltaK)!==this.sign(a.deltaK)?a.mK=0:a.mK=(n.deltaK+a.deltaK)/2}var u,l,c,h;for(t=0;t<s-1;++t)a=o[t],r=o[t+1],a.model.skip||r.model.skip||(i.almostEquals(a.deltaK,0,this.EPSILON)?a.mK=r.mK=0:(u=a.mK/a.deltaK,l=r.mK/a.deltaK,h=Math.pow(u,2)+Math.pow(l,2),h<=9||(c=3/Math.sqrt(h),a.mK=u*c*a.deltaK,r.mK=l*c*a.deltaK)));var _;for(t=0;t<s;++t)a=o[t],a.model.skip||(n=t>0?o[t-1]:null,r=t<s-1?o[t+1]:null,n&&!n.model.skip&&(_=(a.model.x-n.model.x)/3,a.model.controlPointPreviousX=a.model.x-_,a.model.controlPointPreviousY=a.model.y-_*a.mK),r&&!r.model.skip&&(_=(r.model.x-a.model.x)/3,a.model.controlPointNextX=a.model.x+_,a.model.controlPointNextY=a.model.y+_*a.mK))},i.nextItem=function(e,t,n){return n?t>=e.length-1?e[0]:e[t+1]:t>=e.length-1?e[e.length-1]:e[t+1]},i.previousItem=function(e,t,n){return n?t<=0?e[e.length-1]:e[t-1]:t<=0?e[0]:e[t-1]},i.niceNum=function(e,t){var n,a=Math.floor(i.log10(e)),r=e/Math.pow(10,a);return n=t?r<1.5?1:r<3?2:r<7?5:10:r<=1?1:r<=2?2:r<=5?5:10,n*Math.pow(10,a)},i.requestAnimFrame=function(){return"undefined"==typeof window?function(e){e()}:window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(e){return window.setTimeout(e,1e3/60)}}(),i.getRelativePosition=function(e,t){var n,a,r=e.originalEvent||e,o=e.currentTarget||e.srcElement,s=o.getBoundingClientRect(),d=r.touches;d&&d.length>0?(n=d[0].clientX,a=d[0].clientY):(n=r.clientX,a=r.clientY);var u=parseFloat(i.getStyle(o,"padding-left")),l=parseFloat(i.getStyle(o,"padding-top")),c=parseFloat(i.getStyle(o,"padding-right")),h=parseFloat(i.getStyle(o,"padding-bottom")),_=s.right-s.left-u-c,m=s.bottom-s.top-l-h;return n=Math.round((n-s.left-u)/_*o.width/t.currentDevicePixelRatio),a=Math.round((a-s.top-l)/m*o.height/t.currentDevicePixelRatio),{x:n,y:a}},i.getConstraintWidth=function(e){return o(e,"max-width","clientWidth")},i.getConstraintHeight=function(e){return o(e,"max-height","clientHeight")},i.getMaximumWidth=function(e){var t=e.parentNode;if(!t)return e.clientWidth;var n=parseInt(i.getStyle(t,"padding-left"),10),a=parseInt(i.getStyle(t,"padding-right"),10),r=t.clientWidth-n-a,o=i.getConstraintWidth(e);return isNaN(o)?r:Math.min(r,o)},i.getMaximumHeight=function(e){var t=e.parentNode;if(!t)return e.clientHeight;var n=parseInt(i.getStyle(t,"padding-top"),10),a=parseInt(i.getStyle(t,"padding-bottom"),10),r=t.clientHeight-n-a,o=i.getConstraintHeight(e);return isNaN(o)?r:Math.min(r,o)},i.getStyle=function(e,t){return e.currentStyle?e.currentStyle[t]:document.defaultView.getComputedStyle(e,null).getPropertyValue(t)},i.retinaScale=function(e,t){var n=e.currentDevicePixelRatio=t||window.devicePixelRatio||1;if(1!==n){var a=e.canvas,r=e.height,i=e.width;a.height=r*n,a.width=i*n,e.ctx.scale(n,n),a.style.height=r+"px",a.style.width=i+"px"}},i.fontString=function(e,t,n){return t+" "+e+"px "+n},i.longestText=function(e,t,n,a){a=a||{};var r=a.data=a.data||{},o=a.garbageCollect=a.garbageCollect||[];a.font!==t&&(r=a.data={},o=a.garbageCollect=[],a.font=t),e.font=t;var s=0;i.each(n,function(t){void 0!==t&&null!==t&&i.isArray(t)!==!0?s=i.measureText(e,r,o,s,t):i.isArray(t)&&i.each(t,function(t){void 0===t||null===t||i.isArray(t)||(s=i.measureText(e,r,o,s,t))})});var d=o.length/2;if(d>n.length){for(var u=0;u<d;u++)delete r[o[u]];o.splice(0,d)}return s},i.measureText=function(e,t,n,a,r){var i=t[r];return i||(i=t[r]=e.measureText(r).width,n.push(r)),i>a&&(a=i),a},i.numberOfLabelLines=function(e){var t=1;return i.each(e,function(e){i.isArray(e)&&e.length>t&&(t=e.length)}),t},i.color=a?function(e){return e instanceof CanvasGradient&&(e=r.global.defaultColor),a(e)}:function(e){return console.error("Color.js not found!"),e},i.getHoverColor=function(e){return e instanceof CanvasPattern?e:i.color(e).saturate(.5).darken(.1).rgbString()}}},function(e,t,n){"use strict";var a=n(3);a._set("global",{responsive:!0,responsiveAnimationDuration:0,maintainAspectRatio:!0,events:["mousemove","mouseout","click","touchstart","touchmove"],hover:{onHover:null,mode:"nearest",intersect:!0,animationDuration:400},onClick:null,defaultColor:"rgba(0,0,0,0.1)",defaultFontColor:"#666",defaultFontFamily:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",defaultFontSize:12,defaultFontStyle:"normal",showLines:!0,elements:{},layout:{padding:{top:0,right:0,bottom:0,left:0}}}),e.exports=function(){var e=function(e,t){return this.construct(e,t),this};return e.Chart=e,e}},function(e,t,n){"use strict";var a=n(2);e.exports=function(e){function t(e,t){return a.where(e,function(e){return e.position===t})}function n(e,t){e.forEach(function(e,t){return e._tmpIndex_=t,e}),e.sort(function(e,n){var a=t?n:e,r=t?e:n;return a.weight===r.weight?a._tmpIndex_-r._tmpIndex_:a.weight-r.weight}),e.forEach(function(e){delete e._tmpIndex_})}e.layoutService={defaults:{},addBox:function(e,t){e.boxes||(e.boxes=[]),t.fullWidth=t.fullWidth||!1,t.position=t.position||"top",t.weight=t.weight||0,e.boxes.push(t)},removeBox:function(e,t){var n=e.boxes?e.boxes.indexOf(t):-1;n!==-1&&e.boxes.splice(n,1)},configure:function(e,t,n){for(var a,r=["fullWidth","position","weight"],i=r.length,o=0;o<i;++o)a=r[o],n.hasOwnProperty(a)&&(t[a]=n[a])},update:function(e,r,i){function o(e){var t,n=e.isHorizontal();n?(t=e.update(e.fullWidth?L:x,w),T-=t.height):(t=e.update(D,Y),x-=t.width),S.push({horizontal:n,minSize:t,box:e})}function s(e){var t=a.findNextWhere(S,function(t){return t.box===e});if(t)if(e.isHorizontal()){var n={left:Math.max(A,j),right:Math.max(C,H),top:0,bottom:0};e.update(e.fullWidth?L:x,b/2,n)}else e.update(t.minSize.width,T)}function d(e){var t=a.findNextWhere(S,function(t){return t.box===e}),n={left:0,right:0,top:E,bottom:F};t&&e.update(t.minSize.width,T,n)}function u(e){e.isHorizontal()?(e.left=e.fullWidth?h:A,e.right=e.fullWidth?r-_:A+x,e.top=V,e.bottom=V+e.height,V=e.bottom):(e.left=R,e.right=R+e.width,e.top=E,e.bottom=E+T,R=e.right)}if(e){var l=e.options.layout||{},c=a.options.toPadding(l.padding),h=c.left,_=c.right,m=c.top,f=c.bottom,p=t(e.boxes,"left"),y=t(e.boxes,"right"),g=t(e.boxes,"top"),v=t(e.boxes,"bottom"),M=t(e.boxes,"chartArea");n(p,!0),n(y,!1),n(g,!0),n(v,!1);var L=r-h-_,b=i-m-f,k=L/2,Y=b/2,D=(r-k)/(p.length+y.length),w=(i-Y)/(g.length+v.length),x=L,T=b,S=[];a.each(p.concat(y,g,v),o);var j=0,H=0,O=0,P=0;a.each(g.concat(v),function(e){if(e.getPadding){var t=e.getPadding();j=Math.max(j,t.left),H=Math.max(H,t.right)}}),a.each(p.concat(y),function(e){if(e.getPadding){var t=e.getPadding();O=Math.max(O,t.top),P=Math.max(P,t.bottom)}});var A=h,C=_,E=m,F=f;a.each(p.concat(y),s),a.each(p,function(e){A+=e.width}),a.each(y,function(e){C+=e.width}),a.each(g.concat(v),s),a.each(g,function(e){E+=e.height}),a.each(v,function(e){F+=e.height}),a.each(p.concat(y),d),A=h,C=_,E=m,F=f,a.each(p,function(e){A+=e.width}),a.each(y,function(e){C+=e.width}),a.each(g,function(e){E+=e.height}),a.each(v,function(e){F+=e.height});var W=Math.max(j-A,0);A+=W,C+=Math.max(H-C,0);var I=Math.max(O-E,0);E+=I,F+=Math.max(P-F,0);var N=i-E-F,z=r-A-C;z===x&&N===T||(a.each(p,function(e){e.height=N}),a.each(y,function(e){e.height=N}),a.each(g,function(e){e.fullWidth||(e.width=z)}),a.each(v,function(e){e.fullWidth||(e.width=z)}),T=N,x=z);var R=h+W,V=m+I;a.each(p.concat(g),u),R+=x,V+=T,a.each(y,u),a.each(v,u),e.chartArea={left:A,top:E,right:A+x,bottom:E+T},a.each(M,function(t){t.left=e.chartArea.left,t.top=e.chartArea.top,t.right=e.chartArea.right,t.bottom=e.chartArea.bottom,t.update(x,T)})}}}}},function(e,t,n){"use strict";var a=n(3),r=n(4),i=n(2);a._set("global",{plugins:{}}),e.exports=function(e){e.plugins={_plugins:[],_cacheId:0,register:function(e){var t=this._plugins;[].concat(e).forEach(function(e){t.indexOf(e)===-1&&t.push(e)}),this._cacheId++},unregister:function(e){var t=this._plugins;[].concat(e).forEach(function(e){var n=t.indexOf(e);n!==-1&&t.splice(n,1)}),this._cacheId++},clear:function(){this._plugins=[],this._cacheId++},count:function(){return this._plugins.length},getAll:function(){return this._plugins},notify:function(e,t,n){var a,r,i,o,s,d=this.descriptors(e),u=d.length;for(a=0;a<u;++a)if(r=d[a],i=r.plugin,s=i[t],"function"==typeof s&&(o=[e].concat(n||[]),o.push(r.options),s.apply(i,o)===!1))return!1;return!0},descriptors:function(e){var t=e._plugins||(e._plugins={});if(t.id===this._cacheId)return t.descriptors;var n=[],r=[],o=e&&e.config||{},s=o.options&&o.options.plugins||{};return this._plugins.concat(o.plugins||[]).forEach(function(e){var t=n.indexOf(e);if(t===-1){var o=e.id,d=s[o];d!==!1&&(d===!0&&(d=i.clone(a.global.plugins[o])),n.push(e),r.push({plugin:e,options:d||{}}))}}),t.descriptors=r,t.id=this._cacheId,r}},e.pluginService=e.plugins,e.PluginBase=r.extend({})}},function(e,t,n){"use strict";function a(e){var t,n,a=[];for(t=0,n=e.length;t<n;++t)a.push(e[t].label);return a}function r(e,t,n){var a=e.getPixelForTick(t);return n&&(a-=0===t?(e.getPixelForTick(1)-a)/2:(a-e.getPixelForTick(t-1))/2),a}var i=n(3),o=n(4),s=n(2),d=n(9);i._set("scale",{display:!0,position:"left",offset:!1,gridLines:{display:!0,color:"rgba(0, 0, 0, 0.1)",lineWidth:1,drawBorder:!0,drawOnChartArea:!0,drawTicks:!0,tickMarkLength:10,zeroLineWidth:1,zeroLineColor:"rgba(0,0,0,0.25)",zeroLineBorderDash:[],zeroLineBorderDashOffset:0,offsetGridLines:!1,borderDash:[],borderDashOffset:0},scaleLabel:{display:!1,labelString:"",lineHeight:1.2,padding:{top:4,bottom:4}},ticks:{beginAtZero:!1,minRotation:0,maxRotation:50,mirror:!1,padding:0,reverse:!1,display:!0,autoSkip:!0,autoSkipPadding:0,labelOffset:0,callback:d.formatters.values,minor:{},major:{}}}),e.exports=function(e){function t(e,t,n){return s.isArray(t)?s.longestText(e,n,t):e.measureText(t).width}function n(e){var t=s.valueOrDefault,n=i.global,a=t(e.fontSize,n.defaultFontSize),r=t(e.fontStyle,n.defaultFontStyle),o=t(e.fontFamily,n.defaultFontFamily);return{size:a,style:r,family:o,font:s.fontString(a,r,o)}}function d(e){return s.options.toLineHeight(s.valueOrDefault(e.lineHeight,1.2),s.valueOrDefault(e.fontSize,i.global.defaultFontSize))}e.Scale=o.extend({getPadding:function(){var e=this;return{left:e.paddingLeft||0,top:e.paddingTop||0,right:e.paddingRight||0,bottom:e.paddingBottom||0}},getTicks:function(){return this._ticks},mergeTicksOptions:function(){var e=this.options.ticks;e.minor===!1&&(e.minor={display:!1}),e.major===!1&&(e.major={display:!1});for(var t in e)"major"!==t&&"minor"!==t&&("undefined"==typeof e.minor[t]&&(e.minor[t]=e[t]),"undefined"==typeof e.major[t]&&(e.major[t]=e[t]))},beforeUpdate:function(){s.callback(this.options.beforeUpdate,[this])},update:function(e,t,n){var a,r,i,o,d,u,l=this;for(l.beforeUpdate(),l.maxWidth=e,l.maxHeight=t,l.margins=s.extend({left:0,right:0,top:0,bottom:0},n),l.longestTextCache=l.longestTextCache||{},l.beforeSetDimensions(),l.setDimensions(),l.afterSetDimensions(),l.beforeDataLimits(),l.determineDataLimits(),l.afterDataLimits(),l.beforeBuildTicks(),d=l.buildTicks()||[],l.afterBuildTicks(),l.beforeTickToLabelConversion(),i=l.convertTicksToLabels(d)||l.ticks,l.afterTickToLabelConversion(),l.ticks=i,a=0,r=i.length;a<r;++a)o=i[a],u=d[a],u?u.label=o:d.push(u={label:o,major:!1});return l._ticks=d,l.beforeCalculateTickRotation(),l.calculateTickRotation(),l.afterCalculateTickRotation(),l.beforeFit(),l.fit(),l.afterFit(),l.afterUpdate(),l.minSize},afterUpdate:function(){s.callback(this.options.afterUpdate,[this])},beforeSetDimensions:function(){s.callback(this.options.beforeSetDimensions,[this])},setDimensions:function(){var e=this;e.isHorizontal()?(e.width=e.maxWidth,e.left=0,e.right=e.width):(e.height=e.maxHeight,e.top=0,e.bottom=e.height),e.paddingLeft=0,e.paddingTop=0,e.paddingRight=0,e.paddingBottom=0},afterSetDimensions:function(){s.callback(this.options.afterSetDimensions,[this])},beforeDataLimits:function(){s.callback(this.options.beforeDataLimits,[this])},determineDataLimits:s.noop,afterDataLimits:function(){s.callback(this.options.afterDataLimits,[this])},beforeBuildTicks:function(){s.callback(this.options.beforeBuildTicks,[this])},buildTicks:s.noop,afterBuildTicks:function(){s.callback(this.options.afterBuildTicks,[this])},beforeTickToLabelConversion:function(){s.callback(this.options.beforeTickToLabelConversion,[this])},convertTicksToLabels:function(){var e=this,t=e.options.ticks;e.ticks=e.ticks.map(t.userCallback||t.callback,this)},afterTickToLabelConversion:function(){s.callback(this.options.afterTickToLabelConversion,[this])},beforeCalculateTickRotation:function(){s.callback(this.options.beforeCalculateTickRotation,[this])},calculateTickRotation:function(){var e=this,t=e.ctx,r=e.options.ticks,i=a(e._ticks),o=n(r);t.font=o.font;var d=r.minRotation||0;if(i.length&&e.options.display&&e.isHorizontal())for(var u,l,c=s.longestText(t,o.font,i,e.longestTextCache),h=c,_=e.getPixelForTick(1)-e.getPixelForTick(0)-6;h>_&&d<r.maxRotation;){var m=s.toRadians(d);if(u=Math.cos(m),l=Math.sin(m),l*c>e.maxHeight){d--;break}d++,h=u*c}e.labelRotation=d},afterCalculateTickRotation:function(){s.callback(this.options.afterCalculateTickRotation,[this])},beforeFit:function(){s.callback(this.options.beforeFit,[this])},fit:function(){var e=this,r=e.minSize={width:0,height:0},i=a(e._ticks),o=e.options,u=o.ticks,l=o.scaleLabel,c=o.gridLines,h=o.display,_=e.isHorizontal(),m=n(u),f=o.gridLines.tickMarkLength;if(_?r.width=e.isFullWidth()?e.maxWidth-e.margins.left-e.margins.right:e.maxWidth:r.width=h&&c.drawTicks?f:0,_?r.height=h&&c.drawTicks?f:0:r.height=e.maxHeight,l.display&&h){var p=d(l),y=s.options.toPadding(l.padding),g=p+y.height;_?r.height+=g:r.width+=g}if(u.display&&h){var v=s.longestText(e.ctx,m.font,i,e.longestTextCache),M=s.numberOfLabelLines(i),L=.5*m.size,b=e.options.ticks.padding;
+if(_){e.longestLabelWidth=v;var k=s.toRadians(e.labelRotation),Y=Math.cos(k),D=Math.sin(k),w=D*v+m.size*M+L*(M-1)+L;r.height=Math.min(e.maxHeight,r.height+w+b),e.ctx.font=m.font;var x=t(e.ctx,i[0],m.font),T=t(e.ctx,i[i.length-1],m.font);0!==e.labelRotation?(e.paddingLeft="bottom"===o.position?Y*x+3:Y*L+3,e.paddingRight="bottom"===o.position?Y*L+3:Y*T+3):(e.paddingLeft=x/2+3,e.paddingRight=T/2+3)}else u.mirror?v=0:v+=b+L,r.width=Math.min(e.maxWidth,r.width+v),e.paddingTop=m.size/2,e.paddingBottom=m.size/2}e.handleMargins(),e.width=r.width,e.height=r.height},handleMargins:function(){var e=this;e.margins&&(e.paddingLeft=Math.max(e.paddingLeft-e.margins.left,0),e.paddingTop=Math.max(e.paddingTop-e.margins.top,0),e.paddingRight=Math.max(e.paddingRight-e.margins.right,0),e.paddingBottom=Math.max(e.paddingBottom-e.margins.bottom,0))},afterFit:function(){s.callback(this.options.afterFit,[this])},isHorizontal:function(){return"top"===this.options.position||"bottom"===this.options.position},isFullWidth:function(){return this.options.fullWidth},getRightValue:function(e){if(s.isNullOrUndef(e))return NaN;if("number"==typeof e&&!isFinite(e))return NaN;if(e)if(this.isHorizontal()){if(void 0!==e.x)return this.getRightValue(e.x)}else if(void 0!==e.y)return this.getRightValue(e.y);return e},getLabelForIndex:s.noop,getPixelForValue:s.noop,getValueForPixel:s.noop,getPixelForTick:function(e){var t=this,n=t.options.offset;if(t.isHorizontal()){var a=t.width-(t.paddingLeft+t.paddingRight),r=a/Math.max(t._ticks.length-(n?0:1),1),i=r*e+t.paddingLeft;n&&(i+=r/2);var o=t.left+Math.round(i);return o+=t.isFullWidth()?t.margins.left:0}var s=t.height-(t.paddingTop+t.paddingBottom);return t.top+e*(s/(t._ticks.length-1))},getPixelForDecimal:function(e){var t=this;if(t.isHorizontal()){var n=t.width-(t.paddingLeft+t.paddingRight),a=n*e+t.paddingLeft,r=t.left+Math.round(a);return r+=t.isFullWidth()?t.margins.left:0}return t.top+e*t.height},getBasePixel:function(){return this.getPixelForValue(this.getBaseValue())},getBaseValue:function(){var e=this,t=e.min,n=e.max;return e.beginAtZero?0:t<0&&n<0?n:t>0&&n>0?t:0},_autoSkip:function(e){var t,n,a,r,i,o=this,d=o.isHorizontal(),u=o.options.ticks.minor,l=e.length,c=s.toRadians(o.labelRotation),h=Math.cos(c),_=o.longestLabelWidth*h,m=[];for(u.maxTicksLimit&&(i=u.maxTicksLimit),d&&(t=!1,(_+u.autoSkipPadding)*l>o.width-(o.paddingLeft+o.paddingRight)&&(t=1+Math.floor((_+u.autoSkipPadding)*l/(o.width-(o.paddingLeft+o.paddingRight)))),i&&l>i&&(t=Math.max(t,Math.floor(l/i)))),n=0;n<l;n++)a=e[n],r=t>1&&n%t>0||n%t===0&&n+t>=l,(r&&n!==l-1||s.isNullOrUndef(a.label))&&delete a.label,m.push(a);return m},draw:function(e){var t=this,a=t.options;if(a.display){var o=t.ctx,u=i.global,l=a.ticks.minor,c=a.ticks.major||l,h=a.gridLines,_=a.scaleLabel,m=0!==t.labelRotation,f=t.isHorizontal(),p=l.autoSkip?t._autoSkip(t.getTicks()):t.getTicks(),y=s.valueOrDefault(l.fontColor,u.defaultFontColor),g=n(l),v=s.valueOrDefault(c.fontColor,u.defaultFontColor),M=n(c),L=h.drawTicks?h.tickMarkLength:0,b=s.valueOrDefault(_.fontColor,u.defaultFontColor),k=n(_),Y=s.options.toPadding(_.padding),D=s.toRadians(t.labelRotation),w=[],x="right"===a.position?t.left:t.right-L,T="right"===a.position?t.left+L:t.right,S="bottom"===a.position?t.top:t.bottom-L,j="bottom"===a.position?t.top+L:t.bottom;if(s.each(p,function(n,i){if(void 0!==n.label){var o,d,c,_,y=n.label;i===t.zeroLineIndex&&a.offset===h.offsetGridLines?(o=h.zeroLineWidth,d=h.zeroLineColor,c=h.zeroLineBorderDash,_=h.zeroLineBorderDashOffset):(o=s.valueAtIndexOrDefault(h.lineWidth,i),d=s.valueAtIndexOrDefault(h.color,i),c=s.valueOrDefault(h.borderDash,u.borderDash),_=s.valueOrDefault(h.borderDashOffset,u.borderDashOffset));var g,v,M,b,k,Y,H,O,P,A,C="middle",E="middle",F=l.padding;if(f){var W=L+F;"bottom"===a.position?(E=m?"middle":"top",C=m?"right":"center",A=t.top+W):(E=m?"middle":"bottom",C=m?"left":"center",A=t.bottom-W);var I=r(t,i,h.offsetGridLines&&p.length>1);I<t.left&&(d="rgba(0,0,0,0)"),I+=s.aliasPixel(o),P=t.getPixelForTick(i)+l.labelOffset,g=M=k=H=I,v=S,b=j,Y=e.top,O=e.bottom}else{var N,z="left"===a.position;l.mirror?(C=z?"left":"right",N=F):(C=z?"right":"left",N=L+F),P=z?t.right-N:t.left+N;var R=r(t,i,h.offsetGridLines&&p.length>1);R<t.top&&(d="rgba(0,0,0,0)"),R+=s.aliasPixel(o),A=t.getPixelForTick(i)+l.labelOffset,g=x,M=T,k=e.left,H=e.right,v=b=Y=O=R}w.push({tx1:g,ty1:v,tx2:M,ty2:b,x1:k,y1:Y,x2:H,y2:O,labelX:P,labelY:A,glWidth:o,glColor:d,glBorderDash:c,glBorderDashOffset:_,rotation:-1*D,label:y,major:n.major,textBaseline:E,textAlign:C})}}),s.each(w,function(e){if(h.display&&(o.save(),o.lineWidth=e.glWidth,o.strokeStyle=e.glColor,o.setLineDash&&(o.setLineDash(e.glBorderDash),o.lineDashOffset=e.glBorderDashOffset),o.beginPath(),h.drawTicks&&(o.moveTo(e.tx1,e.ty1),o.lineTo(e.tx2,e.ty2)),h.drawOnChartArea&&(o.moveTo(e.x1,e.y1),o.lineTo(e.x2,e.y2)),o.stroke(),o.restore()),l.display){o.save(),o.translate(e.labelX,e.labelY),o.rotate(e.rotation),o.font=e.major?M.font:g.font,o.fillStyle=e.major?v:y,o.textBaseline=e.textBaseline,o.textAlign=e.textAlign;var t=e.label;if(s.isArray(t))for(var n=0,a=0;n<t.length;++n)o.fillText(""+t[n],0,a),a+=1.5*g.size;else o.fillText(t,0,0);o.restore()}}),_.display){var H,O,P=0,A=d(_)/2;if(f)H=t.left+(t.right-t.left)/2,O="bottom"===a.position?t.bottom-A-Y.bottom:t.top+A+Y.top;else{var C="left"===a.position;H=C?t.left+A+Y.top:t.right-A-Y.top,O=t.top+(t.bottom-t.top)/2,P=C?-.5*Math.PI:.5*Math.PI}o.save(),o.translate(H,O),o.rotate(P),o.textAlign="center",o.textBaseline="middle",o.fillStyle=b,o.font=k.font,o.fillText(_.labelString,0,0),o.restore()}if(h.drawBorder){o.lineWidth=s.valueAtIndexOrDefault(h.lineWidth,0),o.strokeStyle=s.valueAtIndexOrDefault(h.color,0);var E=t.left,F=t.right,W=t.top,I=t.bottom,N=s.aliasPixel(o.lineWidth);f?(W=I="top"===a.position?t.bottom:t.top,W+=N,I+=N):(E=F="left"===a.position?t.right:t.left,E+=N,F+=N),o.beginPath(),o.moveTo(E,W),o.lineTo(F,I),o.stroke()}}}})}},function(e,t,n){"use strict";var a=n(3),r=n(2);e.exports=function(e){e.scaleService={constructors:{},defaults:{},registerScaleType:function(e,t,n){this.constructors[e]=t,this.defaults[e]=r.clone(n)},getScaleConstructor:function(e){return this.constructors.hasOwnProperty(e)?this.constructors[e]:void 0},getScaleDefaults:function(e){return this.defaults.hasOwnProperty(e)?r.merge({},[a.scale,this.defaults[e]]):{}},updateScaleDefaults:function(e,t){var n=this;n.defaults.hasOwnProperty(e)&&(n.defaults[e]=r.extend(n.defaults[e],t))},addScalesToLayout:function(t){r.each(t.scales,function(n){n.fullWidth=n.options.fullWidth,n.position=n.options.position,n.weight=n.options.weight,e.layoutService.addBox(t,n)})}}}},function(e,t,n){"use strict";var a=n(3),r=n(4),i=n(2);a._set("global",{tooltips:{enabled:!0,custom:null,mode:"nearest",position:"average",intersect:!0,backgroundColor:"rgba(0,0,0,0.8)",titleFontStyle:"bold",titleSpacing:2,titleMarginBottom:6,titleFontColor:"#fff",titleAlign:"left",bodySpacing:2,bodyFontColor:"#fff",bodyAlign:"left",footerFontStyle:"bold",footerSpacing:2,footerMarginTop:6,footerFontColor:"#fff",footerAlign:"left",yPadding:6,xPadding:6,caretPadding:2,caretSize:5,cornerRadius:6,multiKeyBackground:"#fff",displayColors:!0,borderColor:"rgba(0,0,0,0)",borderWidth:0,callbacks:{beforeTitle:i.noop,title:function(e,t){var n="",a=t.labels,r=a?a.length:0;if(e.length>0){var i=e[0];i.xLabel?n=i.xLabel:r>0&&i.index<r&&(n=a[i.index])}return n},afterTitle:i.noop,beforeBody:i.noop,beforeLabel:i.noop,label:function(e,t){var n=t.datasets[e.datasetIndex].label||"";return n&&(n+=": "),n+=e.yLabel},labelColor:function(e,t){var n=t.getDatasetMeta(e.datasetIndex),a=n.data[e.index],r=a._view;return{borderColor:r.borderColor,backgroundColor:r.backgroundColor}},labelTextColor:function(){return this._options.bodyFontColor},afterLabel:i.noop,afterBody:i.noop,beforeFooter:i.noop,footer:i.noop,afterFooter:i.noop}}}),e.exports=function(e){function t(e,t){var n=i.color(e);return n.alpha(t*n.alpha()).rgbaString()}function n(e,t){return t&&(i.isArray(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function o(e){var t=e._xScale,n=e._yScale||e._scale,a=e._index,r=e._datasetIndex;return{xLabel:t?t.getLabelForIndex(a,r):"",yLabel:n?n.getLabelForIndex(a,r):"",index:a,datasetIndex:r,x:e._model.x,y:e._model.y}}function s(e){var t=a.global,n=i.valueOrDefault;return{xPadding:e.xPadding,yPadding:e.yPadding,xAlign:e.xAlign,yAlign:e.yAlign,bodyFontColor:e.bodyFontColor,_bodyFontFamily:n(e.bodyFontFamily,t.defaultFontFamily),_bodyFontStyle:n(e.bodyFontStyle,t.defaultFontStyle),_bodyAlign:e.bodyAlign,bodyFontSize:n(e.bodyFontSize,t.defaultFontSize),bodySpacing:e.bodySpacing,titleFontColor:e.titleFontColor,_titleFontFamily:n(e.titleFontFamily,t.defaultFontFamily),_titleFontStyle:n(e.titleFontStyle,t.defaultFontStyle),titleFontSize:n(e.titleFontSize,t.defaultFontSize),_titleAlign:e.titleAlign,titleSpacing:e.titleSpacing,titleMarginBottom:e.titleMarginBottom,footerFontColor:e.footerFontColor,_footerFontFamily:n(e.footerFontFamily,t.defaultFontFamily),_footerFontStyle:n(e.footerFontStyle,t.defaultFontStyle),footerFontSize:n(e.footerFontSize,t.defaultFontSize),_footerAlign:e.footerAlign,footerSpacing:e.footerSpacing,footerMarginTop:e.footerMarginTop,caretSize:e.caretSize,cornerRadius:e.cornerRadius,backgroundColor:e.backgroundColor,opacity:0,legendColorBackground:e.multiKeyBackground,displayColors:e.displayColors,borderColor:e.borderColor,borderWidth:e.borderWidth}}function d(e,t){var n=e._chart.ctx,a=2*t.yPadding,r=0,o=t.body,s=o.reduce(function(e,t){return e+t.before.length+t.lines.length+t.after.length},0);s+=t.beforeBody.length+t.afterBody.length;var d=t.title.length,u=t.footer.length,l=t.titleFontSize,c=t.bodyFontSize,h=t.footerFontSize;a+=d*l,a+=d?(d-1)*t.titleSpacing:0,a+=d?t.titleMarginBottom:0,a+=s*c,a+=s?(s-1)*t.bodySpacing:0,a+=u?t.footerMarginTop:0,a+=u*h,a+=u?(u-1)*t.footerSpacing:0;var _=0,m=function(e){r=Math.max(r,n.measureText(e).width+_)};return n.font=i.fontString(l,t._titleFontStyle,t._titleFontFamily),i.each(t.title,m),n.font=i.fontString(c,t._bodyFontStyle,t._bodyFontFamily),i.each(t.beforeBody.concat(t.afterBody),m),_=t.displayColors?c+2:0,i.each(o,function(e){i.each(e.before,m),i.each(e.lines,m),i.each(e.after,m)}),_=0,n.font=i.fontString(h,t._footerFontStyle,t._footerFontFamily),i.each(t.footer,m),r+=2*t.xPadding,{width:r,height:a}}function u(e,t){var n=e._model,a=e._chart,r=e._chart.chartArea,i="center",o="center";n.y<t.height?o="top":n.y>a.height-t.height&&(o="bottom");var s,d,u,l,c,h=(r.left+r.right)/2,_=(r.top+r.bottom)/2;"center"===o?(s=function(e){return e<=h},d=function(e){return e>h}):(s=function(e){return e<=t.width/2},d=function(e){return e>=a.width-t.width/2}),u=function(e){return e+t.width>a.width},l=function(e){return e-t.width<0},c=function(e){return e<=_?"top":"bottom"},s(n.x)?(i="left",u(n.x)&&(i="center",o=c(n.y))):d(n.x)&&(i="right",l(n.x)&&(i="center",o=c(n.y)));var m=e._options;return{xAlign:m.xAlign?m.xAlign:i,yAlign:m.yAlign?m.yAlign:o}}function l(e,t,n){var a=e.x,r=e.y,i=e.caretSize,o=e.caretPadding,s=e.cornerRadius,d=n.xAlign,u=n.yAlign,l=i+o,c=s+o;return"right"===d?a-=t.width:"center"===d&&(a-=t.width/2),"top"===u?r+=l:r-="bottom"===u?t.height+l:t.height/2,"center"===u?"left"===d?a+=l:"right"===d&&(a-=l):"left"===d?a-=c:"right"===d&&(a+=c),{x:a,y:r}}e.Tooltip=r.extend({initialize:function(){this._model=s(this._options)},getTitle:function(){var e=this,t=e._options,a=t.callbacks,r=a.beforeTitle.apply(e,arguments),i=a.title.apply(e,arguments),o=a.afterTitle.apply(e,arguments),s=[];return s=n(s,r),s=n(s,i),s=n(s,o)},getBeforeBody:function(){var e=this._options.callbacks.beforeBody.apply(this,arguments);return i.isArray(e)?e:void 0!==e?[e]:[]},getBody:function(e,t){var a=this,r=a._options.callbacks,o=[];return i.each(e,function(e){var i={before:[],lines:[],after:[]};n(i.before,r.beforeLabel.call(a,e,t)),n(i.lines,r.label.call(a,e,t)),n(i.after,r.afterLabel.call(a,e,t)),o.push(i)}),o},getAfterBody:function(){var e=this._options.callbacks.afterBody.apply(this,arguments);return i.isArray(e)?e:void 0!==e?[e]:[]},getFooter:function(){var e=this,t=e._options.callbacks,a=t.beforeFooter.apply(e,arguments),r=t.footer.apply(e,arguments),i=t.afterFooter.apply(e,arguments),o=[];return o=n(o,a),o=n(o,r),o=n(o,i)},update:function(t){var n,a,r=this,c=r._options,h=r._model,_=r._model=s(c),m=r._active,f=r._data,p={xAlign:h.xAlign,yAlign:h.yAlign},y={x:h.x,y:h.y},g={width:h.width,height:h.height},v={x:h.caretX,y:h.caretY};if(m.length){_.opacity=1;var M=[],L=[];v=e.Tooltip.positioners[c.position](m,r._eventPosition);var b=[];for(n=0,a=m.length;n<a;++n)b.push(o(m[n]));c.filter&&(b=b.filter(function(e){return c.filter(e,f)})),c.itemSort&&(b=b.sort(function(e,t){return c.itemSort(e,t,f)})),i.each(b,function(e){M.push(c.callbacks.labelColor.call(r,e,r._chart)),L.push(c.callbacks.labelTextColor.call(r,e,r._chart))}),_.title=r.getTitle(b,f),_.beforeBody=r.getBeforeBody(b,f),_.body=r.getBody(b,f),_.afterBody=r.getAfterBody(b,f),_.footer=r.getFooter(b,f),_.x=Math.round(v.x),_.y=Math.round(v.y),_.caretPadding=c.caretPadding,_.labelColors=M,_.labelTextColors=L,_.dataPoints=b,g=d(this,_),p=u(this,g),y=l(_,g,p)}else _.opacity=0;return _.xAlign=p.xAlign,_.yAlign=p.yAlign,_.x=y.x,_.y=y.y,_.width=g.width,_.height=g.height,_.caretX=v.x,_.caretY=v.y,r._model=_,t&&c.custom&&c.custom.call(r,_),r},drawCaret:function(e,t){var n=this._chart.ctx,a=this._view,r=this.getCaretPosition(e,t,a);n.lineTo(r.x1,r.y1),n.lineTo(r.x2,r.y2),n.lineTo(r.x3,r.y3)},getCaretPosition:function(e,t,n){var a,r,i,o,s,d,u=n.caretSize,l=n.cornerRadius,c=n.xAlign,h=n.yAlign,_=e.x,m=e.y,f=t.width,p=t.height;if("center"===h)s=m+p/2,"left"===c?(a=_,r=a-u,i=a,o=s+u,d=s-u):(a=_+f,r=a+u,i=a,o=s-u,d=s+u);else if("left"===c?(r=_+l+u,a=r-u,i=r+u):"right"===c?(r=_+f-l-u,a=r-u,i=r+u):(r=_+f/2,a=r-u,i=r+u),"top"===h)o=m,s=o-u,d=o;else{o=m+p,s=o+u,d=o;var y=i;i=a,a=y}return{x1:a,x2:r,x3:i,y1:o,y2:s,y3:d}},drawTitle:function(e,n,a,r){var o=n.title;if(o.length){a.textAlign=n._titleAlign,a.textBaseline="top";var s=n.titleFontSize,d=n.titleSpacing;a.fillStyle=t(n.titleFontColor,r),a.font=i.fontString(s,n._titleFontStyle,n._titleFontFamily);var u,l;for(u=0,l=o.length;u<l;++u)a.fillText(o[u],e.x,e.y),e.y+=s+d,u+1===o.length&&(e.y+=n.titleMarginBottom-d)}},drawBody:function(e,n,a,r){var o=n.bodyFontSize,s=n.bodySpacing,d=n.body;a.textAlign=n._bodyAlign,a.textBaseline="top",a.font=i.fontString(o,n._bodyFontStyle,n._bodyFontFamily);var u=0,l=function(t){a.fillText(t,e.x+u,e.y),e.y+=o+s};i.each(n.beforeBody,l);var c=n.displayColors;u=c?o+2:0,i.each(d,function(s,d){i.each(s.before,l),i.each(s.lines,function(i){if(c){a.fillStyle=t(n.legendColorBackground,r),a.fillRect(e.x,e.y,o,o),a.lineWidth=1,a.strokeStyle=t(n.labelColors[d].borderColor,r),a.strokeRect(e.x,e.y,o,o),a.fillStyle=t(n.labelColors[d].backgroundColor,r),a.fillRect(e.x+1,e.y+1,o-2,o-2);var s=t(n.labelTextColors[d],r);a.fillStyle=s}l(i)}),i.each(s.after,l)}),u=0,i.each(n.afterBody,l),e.y-=s},drawFooter:function(e,n,a,r){var o=n.footer;o.length&&(e.y+=n.footerMarginTop,a.textAlign=n._footerAlign,a.textBaseline="top",a.fillStyle=t(n.footerFontColor,r),a.font=i.fontString(n.footerFontSize,n._footerFontStyle,n._footerFontFamily),i.each(o,function(t){a.fillText(t,e.x,e.y),e.y+=n.footerFontSize+n.footerSpacing}))},drawBackground:function(e,n,a,r,i){a.fillStyle=t(n.backgroundColor,i),a.strokeStyle=t(n.borderColor,i),a.lineWidth=n.borderWidth;var o=n.xAlign,s=n.yAlign,d=e.x,u=e.y,l=r.width,c=r.height,h=n.cornerRadius;a.beginPath(),a.moveTo(d+h,u),"top"===s&&this.drawCaret(e,r),a.lineTo(d+l-h,u),a.quadraticCurveTo(d+l,u,d+l,u+h),"center"===s&&"right"===o&&this.drawCaret(e,r),a.lineTo(d+l,u+c-h),a.quadraticCurveTo(d+l,u+c,d+l-h,u+c),"bottom"===s&&this.drawCaret(e,r),a.lineTo(d+h,u+c),a.quadraticCurveTo(d,u+c,d,u+c-h),"center"===s&&"left"===o&&this.drawCaret(e,r),a.lineTo(d,u+h),a.quadraticCurveTo(d,u,d+h,u),a.closePath(),a.fill(),n.borderWidth>0&&a.stroke()},draw:function(){var e=this._chart.ctx,t=this._view;if(0!==t.opacity){var n={width:t.width,height:t.height},a={x:t.x,y:t.y},r=Math.abs(t.opacity<.001)?0:t.opacity,i=t.title.length||t.beforeBody.length||t.body.length||t.afterBody.length||t.footer.length;this._options.enabled&&i&&(this.drawBackground(a,t,e,n,r),a.x+=t.xPadding,a.y+=t.yPadding,this.drawTitle(a,t,e,r),this.drawBody(a,t,e,r),this.drawFooter(a,t,e,r))}},handleEvent:function(e){var t=this,n=t._options,a=!1;if(t._lastActive=t._lastActive||[],"mouseout"===e.type?t._active=[]:t._active=t._chart.getElementsAtEventForMode(e,n.mode,n),a=!i.arrayEquals(t._active,t._lastActive),!a)return!1;if(t._lastActive=t._active,n.enabled||n.custom){t._eventPosition={x:e.x,y:e.y};var r=t._model;t.update(!0),t.pivot(),a|=r.x!==t._model.x||r.y!==t._model.y}return a}}),e.Tooltip.positioners={average:function(e){if(!e.length)return!1;var t,n,a=0,r=0,i=0;for(t=0,n=e.length;t<n;++t){var o=e[t];if(o&&o.hasValue()){var s=o.tooltipPosition();a+=s.x,r+=s.y,++i}}return{x:Math.round(a/i),y:Math.round(r/i)}},nearest:function(e,t){var n,a,r,o=t.x,s=t.y,d=Number.POSITIVE_INFINITY;for(n=0,a=e.length;n<a;++n){var u=e[n];if(u&&u.hasValue()){var l=u.getCenterPoint(),c=i.distanceBetweenPoints(t,l);c<d&&(d=c,r=u)}}if(r){var h=r.tooltipPosition();o=h.x,s=h.y}return{x:o,y:s}}}}},function(e,t,n){"use strict";var a=n(3),r=n(4),i=n(2);a._set("global",{elements:{arc:{backgroundColor:a.global.defaultColor,borderColor:"#fff",borderWidth:2}}}),e.exports=r.extend({inLabelRange:function(e){var t=this._view;return!!t&&Math.pow(e-t.x,2)<Math.pow(t.radius+t.hoverRadius,2)},inRange:function(e,t){var n=this._view;if(n){for(var a=i.getAngleFromPoint(n,{x:e,y:t}),r=a.angle,o=a.distance,s=n.startAngle,d=n.endAngle;d<s;)d+=2*Math.PI;for(;r>d;)r-=2*Math.PI;for(;r<s;)r+=2*Math.PI;var u=r>=s&&r<=d,l=o>=n.innerRadius&&o<=n.outerRadius;return u&&l}return!1},getCenterPoint:function(){var e=this._view,t=(e.startAngle+e.endAngle)/2,n=(e.innerRadius+e.outerRadius)/2;return{x:e.x+Math.cos(t)*n,y:e.y+Math.sin(t)*n}},getArea:function(){var e=this._view;return Math.PI*((e.endAngle-e.startAngle)/(2*Math.PI))*(Math.pow(e.outerRadius,2)-Math.pow(e.innerRadius,2))},tooltipPosition:function(){var e=this._view,t=e.startAngle+(e.endAngle-e.startAngle)/2,n=(e.outerRadius-e.innerRadius)/2+e.innerRadius;return{x:e.x+Math.cos(t)*n,y:e.y+Math.sin(t)*n}},draw:function(){var e=this._chart.ctx,t=this._view,n=t.startAngle,a=t.endAngle;e.beginPath(),e.arc(t.x,t.y,t.outerRadius,n,a),e.arc(t.x,t.y,t.innerRadius,a,n,!0),e.closePath(),e.strokeStyle=t.borderColor,e.lineWidth=t.borderWidth,e.fillStyle=t.backgroundColor,e.fill(),e.lineJoin="bevel",t.borderWidth&&e.stroke()}})},function(e,t,n){"use strict";var a=n(3),r=n(4),i=n(2),o=a.global;a._set("global",{elements:{line:{tension:.4,backgroundColor:o.defaultColor,borderWidth:3,borderColor:o.defaultColor,borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",capBezierPoints:!0,fill:!0}}}),e.exports=r.extend({draw:function(){var e,t,n,a,r=this,s=r._view,d=r._chart.ctx,u=s.spanGaps,l=r._children.slice(),c=o.elements.line,h=-1;for(r._loop&&l.length&&l.push(l[0]),d.save(),d.lineCap=s.borderCapStyle||c.borderCapStyle,d.setLineDash&&d.setLineDash(s.borderDash||c.borderDash),d.lineDashOffset=s.borderDashOffset||c.borderDashOffset,d.lineJoin=s.borderJoinStyle||c.borderJoinStyle,d.lineWidth=s.borderWidth||c.borderWidth,d.strokeStyle=s.borderColor||o.defaultColor,d.beginPath(),h=-1,e=0;e<l.length;++e)t=l[e],n=i.previousItem(l,e),a=t._view,0===e?a.skip||(d.moveTo(a.x,a.y),h=e):(n=h===-1?n:l[h],a.skip||(h!==e-1&&!u||h===-1?d.moveTo(a.x,a.y):i.canvas.lineTo(d,n._view,t._view),h=e));d.stroke(),d.restore()}})},function(e,t,n){"use strict";function a(e){var t=this._view;return!!t&&Math.pow(e-t.x,2)<Math.pow(t.radius+t.hitRadius,2)}function r(e){var t=this._view;return!!t&&Math.pow(e-t.y,2)<Math.pow(t.radius+t.hitRadius,2)}var i=n(3),o=n(4),s=n(2),d=i.global.defaultColor;i._set("global",{elements:{point:{radius:3,pointStyle:"circle",backgroundColor:d,borderColor:d,borderWidth:1,hitRadius:1,hoverRadius:4,hoverBorderWidth:1}}}),e.exports=o.extend({inRange:function(e,t){var n=this._view;return!!n&&Math.pow(e-n.x,2)+Math.pow(t-n.y,2)<Math.pow(n.hitRadius+n.radius,2)},inLabelRange:a,inXRange:a,inYRange:r,getCenterPoint:function(){var e=this._view;return{x:e.x,y:e.y}},getArea:function(){return Math.PI*Math.pow(this._view.radius,2)},tooltipPosition:function(){var e=this._view;return{x:e.x,y:e.y,padding:e.radius+e.borderWidth}},draw:function(e){var t=this._view,n=this._model,a=this._chart.ctx,r=t.pointStyle,o=t.radius,u=t.x,l=t.y,c=s.color,h=1.01,_=0;t.skip||(a.strokeStyle=t.borderColor||d,a.lineWidth=s.valueOrDefault(t.borderWidth,i.global.elements.point.borderWidth),a.fillStyle=t.backgroundColor||d,void 0!==e&&(n.x<e.left||e.right*h<n.x||n.y<e.top||e.bottom*h<n.y)&&(n.x<e.left?_=(u-n.x)/(e.left-n.x):e.right*h<n.x?_=(n.x-u)/(n.x-e.right):n.y<e.top?_=(l-n.y)/(e.top-n.y):e.bottom*h<n.y&&(_=(n.y-l)/(n.y-e.bottom)),_=Math.round(100*_)/100,a.strokeStyle=c(a.strokeStyle).alpha(_).rgbString(),a.fillStyle=c(a.fillStyle).alpha(_).rgbString()),s.canvas.drawPoint(a,r,o,u,l))}})},function(e,t,n){"use strict";function a(e){return void 0!==e._view.width}function r(e){var t,n,r,i,o=e._view;if(a(e)){var s=o.width/2;t=o.x-s,n=o.x+s,r=Math.min(o.y,o.base),i=Math.max(o.y,o.base)}else{var d=o.height/2;t=Math.min(o.x,o.base),n=Math.max(o.x,o.base),r=o.y-d,i=o.y+d}return{left:t,top:r,right:n,bottom:i}}var i=n(3),o=n(4);i._set("global",{elements:{rectangle:{backgroundColor:i.global.defaultColor,borderColor:i.global.defaultColor,borderSkipped:"bottom",borderWidth:0}}}),e.exports=o.extend({draw:function(){function e(e){return y[(v+e)%4]}var t,n,a,r,i,o,s,d=this._chart.ctx,u=this._view,l=u.borderWidth;if(u.horizontal?(t=u.base,n=u.x,a=u.y-u.height/2,r=u.y+u.height/2,i=n>t?1:-1,o=1,s=u.borderSkipped||"left"):(t=u.x-u.width/2,n=u.x+u.width/2,a=u.y,r=u.base,i=1,o=r>a?1:-1,s=u.borderSkipped||"bottom"),l){var c=Math.min(Math.abs(t-n),Math.abs(a-r));l=l>c?c:l;var h=l/2,_=t+("left"!==s?h*i:0),m=n+("right"!==s?-h*i:0),f=a+("top"!==s?h*o:0),p=r+("bottom"!==s?-h*o:0);_!==m&&(a=f,r=p),f!==p&&(t=_,n=m)}d.beginPath(),d.fillStyle=u.backgroundColor,d.strokeStyle=u.borderColor,d.lineWidth=l;var y=[[t,r],[t,a],[n,a],[n,r]],g=["bottom","left","top","right"],v=g.indexOf(s,0);v===-1&&(v=0);var M=e(0);d.moveTo(M[0],M[1]);for(var L=1;L<4;L++)M=e(L),d.lineTo(M[0],M[1]);d.fill(),l&&d.stroke()},height:function(){var e=this._view;return e.base-e.y},inRange:function(e,t){var n=!1;if(this._view){var a=r(this);n=e>=a.left&&e<=a.right&&t>=a.top&&t<=a.bottom}return n},inLabelRange:function(e,t){var n=this;if(!n._view)return!1;var i=!1,o=r(n);return i=a(n)?e>=o.left&&e<=o.right:t>=o.top&&t<=o.bottom},inXRange:function(e){var t=r(this);return e>=t.left&&e<=t.right},inYRange:function(e){var t=r(this);return e>=t.top&&e<=t.bottom},getCenterPoint:function(){var e,t,n=this._view;return a(this)?(e=n.x,t=(n.y+n.base)/2):(e=(n.x+n.base)/2,t=n.y),{x:e,y:t}},getArea:function(){var e=this._view;return e.width*Math.abs(e.y-e.base)},tooltipPosition:function(){var e=this._view;return{x:e.x,y:e.y}}})},function(e,t,n){"use strict";var a=n(10),t=e.exports={clear:function(e){e.ctx.clearRect(0,0,e.width,e.height)},roundedRect:function(e,t,n,a,r,i){if(i){var o=Math.min(i,a/2),s=Math.min(i,r/2);e.moveTo(t+o,n),e.lineTo(t+a-o,n),e.quadraticCurveTo(t+a,n,t+a,n+s),e.lineTo(t+a,n+r-s),e.quadraticCurveTo(t+a,n+r,t+a-o,n+r),e.lineTo(t+o,n+r),e.quadraticCurveTo(t,n+r,t,n+r-s),e.lineTo(t,n+s),e.quadraticCurveTo(t,n,t+o,n)}else e.rect(t,n,a,r)},drawPoint:function(e,t,n,a,r){var i,o,s,d,u,l;if("object"==typeof t&&(i=t.toString(),"[object HTMLImageElement]"===i||"[object HTMLCanvasElement]"===i))return void e.drawImage(t,a-t.width/2,r-t.height/2,t.width,t.height);if(!(isNaN(n)||n<=0)){switch(t){default:e.beginPath(),e.arc(a,r,n,0,2*Math.PI),e.closePath(),e.fill();break;case"triangle":e.beginPath(),o=3*n/Math.sqrt(3),u=o*Math.sqrt(3)/2,e.moveTo(a-o/2,r+u/3),e.lineTo(a+o/2,r+u/3),e.lineTo(a,r-2*u/3),e.closePath(),e.fill();break;case"rect":l=1/Math.SQRT2*n,e.beginPath(),e.fillRect(a-l,r-l,2*l,2*l),e.strokeRect(a-l,r-l,2*l,2*l);break;case"rectRounded":var c=n/Math.SQRT2,h=a-c,_=r-c,m=Math.SQRT2*n;e.beginPath(),this.roundedRect(e,h,_,m,m,n/2),e.closePath(),e.fill();break;case"rectRot":l=1/Math.SQRT2*n,e.beginPath(),e.moveTo(a-l,r),e.lineTo(a,r+l),e.lineTo(a+l,r),e.lineTo(a,r-l),e.closePath(),e.fill();break;case"cross":e.beginPath(),e.moveTo(a,r+n),e.lineTo(a,r-n),e.moveTo(a-n,r),e.lineTo(a+n,r),e.closePath();break;case"crossRot":e.beginPath(),s=Math.cos(Math.PI/4)*n,d=Math.sin(Math.PI/4)*n,e.moveTo(a-s,r-d),e.lineTo(a+s,r+d),e.moveTo(a-s,r+d),e.lineTo(a+s,r-d),e.closePath();break;case"star":e.beginPath(),e.moveTo(a,r+n),e.lineTo(a,r-n),e.moveTo(a-n,r),e.lineTo(a+n,r),s=Math.cos(Math.PI/4)*n,d=Math.sin(Math.PI/4)*n,e.moveTo(a-s,r-d),e.lineTo(a+s,r+d),e.moveTo(a-s,r+d),e.lineTo(a+s,r-d),e.closePath();break;case"line":e.beginPath(),e.moveTo(a-n,r),e.lineTo(a+n,r),e.closePath();break;case"dash":e.beginPath(),e.moveTo(a,r),e.lineTo(a+n,r),e.closePath()}e.stroke()}},clipArea:function(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()},unclipArea:function(e){e.restore()},lineTo:function(e,t,n,a){return n.steppedLine?("after"===n.steppedLine&&!a||"after"!==n.steppedLine&&a?e.lineTo(t.x,n.y):e.lineTo(n.x,t.y),void e.lineTo(n.x,n.y)):n.tension?void e.bezierCurveTo(a?t.controlPointPreviousX:t.controlPointNextX,a?t.controlPointPreviousY:t.controlPointNextY,a?n.controlPointNextX:n.controlPointPreviousX,a?n.controlPointNextY:n.controlPointPreviousY,n.x,n.y):void e.lineTo(n.x,n.y)}};a.clear=t.clear,a.drawRoundedRectangle=function(e){e.beginPath(),t.roundedRect.apply(t,arguments),e.closePath()}},function(e,t,n){"use strict";var a=n(10),r={linear:function(e){return e},easeInQuad:function(e){return e*e},easeOutQuad:function(e){return-e*(e-2)},easeInOutQuad:function(e){return(e/=.5)<1?.5*e*e:-.5*(--e*(e-2)-1)},easeInCubic:function(e){return e*e*e},easeOutCubic:function(e){return(e-=1)*e*e+1},easeInOutCubic:function(e){return(e/=.5)<1?.5*e*e*e:.5*((e-=2)*e*e+2)},easeInQuart:function(e){return e*e*e*e},easeOutQuart:function(e){return-((e-=1)*e*e*e-1)},easeInOutQuart:function(e){return(e/=.5)<1?.5*e*e*e*e:-.5*((e-=2)*e*e*e-2)},easeInQuint:function(e){return e*e*e*e*e},easeOutQuint:function(e){return(e-=1)*e*e*e*e+1},easeInOutQuint:function(e){return(e/=.5)<1?.5*e*e*e*e*e:.5*((e-=2)*e*e*e*e+2)},easeInSine:function(e){return-Math.cos(e*(Math.PI/2))+1},easeOutSine:function(e){return Math.sin(e*(Math.PI/2))},easeInOutSine:function(e){return-.5*(Math.cos(Math.PI*e)-1)},easeInExpo:function(e){return 0===e?0:Math.pow(2,10*(e-1))},easeOutExpo:function(e){return 1===e?1:-Math.pow(2,-10*e)+1},easeInOutExpo:function(e){return 0===e?0:1===e?1:(e/=.5)<1?.5*Math.pow(2,10*(e-1)):.5*(-Math.pow(2,-10*--e)+2)},easeInCirc:function(e){return e>=1?e:-(Math.sqrt(1-e*e)-1)},easeOutCirc:function(e){return Math.sqrt(1-(e-=1)*e)},easeInOutCirc:function(e){return(e/=.5)<1?-.5*(Math.sqrt(1-e*e)-1):.5*(Math.sqrt(1-(e-=2)*e)+1)},easeInElastic:function(e){var t=1.70158,n=0,a=1;return 0===e?0:1===e?1:(n||(n=.3),a<1?(a=1,t=n/4):t=n/(2*Math.PI)*Math.asin(1/a),-(a*Math.pow(2,10*(e-=1))*Math.sin((e-t)*(2*Math.PI)/n)))},easeOutElastic:function(e){var t=1.70158,n=0,a=1;return 0===e?0:1===e?1:(n||(n=.3),a<1?(a=1,t=n/4):t=n/(2*Math.PI)*Math.asin(1/a),a*Math.pow(2,-10*e)*Math.sin((e-t)*(2*Math.PI)/n)+1)},easeInOutElastic:function(e){var t=1.70158,n=0,a=1;return 0===e?0:2===(e/=.5)?1:(n||(n=.45),a<1?(a=1,t=n/4):t=n/(2*Math.PI)*Math.asin(1/a),e<1?-.5*(a*Math.pow(2,10*(e-=1))*Math.sin((e-t)*(2*Math.PI)/n)):a*Math.pow(2,-10*(e-=1))*Math.sin((e-t)*(2*Math.PI)/n)*.5+1)},easeInBack:function(e){var t=1.70158;return e*e*((t+1)*e-t)},easeOutBack:function(e){var t=1.70158;return(e-=1)*e*((t+1)*e+t)+1},easeInOutBack:function(e){var t=1.70158;return(e/=.5)<1?.5*(e*e*(((t*=1.525)+1)*e-t)):.5*((e-=2)*e*(((t*=1.525)+1)*e+t)+2)},easeInBounce:function(e){return 1-r.easeOutBounce(1-e)},easeOutBounce:function(e){return e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375},easeInOutBounce:function(e){return e<.5?.5*r.easeInBounce(2*e):.5*r.easeOutBounce(2*e-1)+.5}};e.exports={effects:r},a.easingEffects=r},function(e,t,n){"use strict";var a=n(10);e.exports={toLineHeight:function(e,t){var n=(""+e).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);if(!n||"normal"===n[1])return 1.2*t;switch(e=+n[2],n[3]){case"px":return e;case"%":e/=100}return t*e},toPadding:function(e){var t,n,r,i;return a.isObject(e)?(t=+e.top||0,n=+e.right||0,r=+e.bottom||0,i=+e.left||0):t=n=r=i=+e||0,{top:t,right:n,bottom:r,left:i,height:t+r,width:i+n}},resolve:function(e,t,n){var r,i,o;for(r=0,i=e.length;r<i;++r)if(o=e[r],void 0!==o&&(void 0!==t&&"function"==typeof o&&(o=o(t)),void 0!==n&&a.isArray(o)&&(o=o[n]),void 0!==o))return o}}},function(e,t){e.exports={acquireContext:function(e){return e&&e.canvas&&(e=e.canvas),e&&e.getContext("2d")||null}}},function(e,t,n){"use strict";function a(e,t){var n=p.getStyle(e,t),a=n&&n.match(/^(\d+)(\.\d+)?px$/);return a?Number(a[1]):void 0}function r(e,t){var n=e.style,r=e.getAttribute("height"),i=e.getAttribute("width");if(e[y]={initial:{height:r,width:i,style:{display:n.display,height:n.height,width:n.width}}},n.display=n.display||"block",null===i||""===i){var o=a(e,"width");void 0!==o&&(e.width=o)}if(null===r||""===r)if(""===e.style.height)e.height=e.width/(t.options.aspectRatio||2);else{var s=a(e,"height");void 0!==o&&(e.height=s)}return e}function i(e,t,n){e.addEventListener(t,n,Y)}function o(e,t,n){e.removeEventListener(t,n,Y)}function s(e,t,n,a,r){return{type:e,chart:t,native:r||null,x:void 0!==n?n:null,y:void 0!==a?a:null}}function d(e,t){var n=b[e.type]||e.type,a=p.getRelativePosition(e,t);return s(n,t,a.x,a.y,e)}function u(e,t){var n=!1,a=[];return function(){a=Array.prototype.slice.call(arguments),t=t||this,n||(n=!0,p.requestAnimFrame.call(window,function(){n=!1,e.apply(t,a)}))}}function l(e){var t=document.createElement("div"),n=g+"size-monitor",a=1e6,r="position:absolute;left:0;top:0;right:0;bottom:0;overflow:hidden;pointer-events:none;visibility:hidden;z-index:-1;";t.style.cssText=r,t.className=n,t.innerHTML='<div class="'+n+'-expand" style="'+r+'"><div style="position:absolute;width:'+a+"px;height:"+a+'px;left:0;top:0"></div></div><div class="'+n+'-shrink" style="'+r+'"><div style="position:absolute;width:200%;height:200%;left:0; top:0"></div></div>';var o=t.childNodes[0],s=t.childNodes[1];t._reset=function(){o.scrollLeft=a,o.scrollTop=a,s.scrollLeft=a,s.scrollTop=a};var d=function(){t._reset(),e()};return i(o,"scroll",d.bind(o,"expand")),i(s,"scroll",d.bind(s,"shrink")),t}function c(e,t){var n=e[y]||(e[y]={}),a=n.renderProxy=function(e){e.animationName===M&&t()};p.each(L,function(t){i(e,t,a)}),e.classList.add(v)}function h(e){var t=e[y]||{},n=t.renderProxy;n&&(p.each(L,function(t){o(e,t,n)}),delete t.renderProxy),e.classList.remove(v)}function _(e,t,n){var a=e[y]||(e[y]={}),r=a.resizer=l(u(function(){if(a.resizer)return t(s("resize",n))}));c(e,function(){if(a.resizer){var t=e.parentNode;t&&t!==r.parentNode&&t.insertBefore(r,t.firstChild),r._reset()}})}function m(e){var t=e[y]||{},n=t.resizer;delete t.resizer,h(e),n&&n.parentNode&&n.parentNode.removeChild(n)}function f(e,t){var n=e._style||document.createElement("style");e._style||(e._style=n,t="/* Chart.js */\n"+t,n.setAttribute("type","text/css"),document.getElementsByTagName("head")[0].appendChild(n)),n.appendChild(document.createTextNode(t))}var p=n(2),y="$chartjs",g="chartjs-",v=g+"render-monitor",M=g+"render-animation",L=["animationstart","webkitAnimationStart"],b={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"},k=function(){var e=!1;try{var t=Object.defineProperty({},"passive",{
+get:function(){e=!0}});window.addEventListener("e",null,t)}catch(e){}return e}(),Y=!!k&&{passive:!0};e.exports={_enabled:"undefined"!=typeof window&&"undefined"!=typeof document,initialize:function(){var e="from{opacity:0.99}to{opacity:1}";f(this,"@-webkit-keyframes "+M+"{"+e+"}@keyframes "+M+"{"+e+"}."+v+"{-webkit-animation:"+M+" 0.001s;animation:"+M+" 0.001s;}")},acquireContext:function(e,t){"string"==typeof e?e=document.getElementById(e):e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas);var n=e&&e.getContext&&e.getContext("2d");return n&&n.canvas===e?(r(e,t),n):null},releaseContext:function(e){var t=e.canvas;if(t[y]){var n=t[y].initial;["height","width"].forEach(function(e){var a=n[e];p.isNullOrUndef(a)?t.removeAttribute(e):t.setAttribute(e,a)}),p.each(n.style||{},function(e,n){t.style[n]=e}),t.width=t.width,delete t[y]}},addEventListener:function(e,t,n){var a=e.canvas;if("resize"===t)return void _(a,n,e);var r=n[y]||(n[y]={}),o=r.proxies||(r.proxies={}),s=o[e.id+"_"+t]=function(t){n(d(t,e))};i(a,t,s)},removeEventListener:function(e,t,n){var a=e.canvas;if("resize"===t)return void m(a,n);var r=n[y]||{},i=r.proxies||{},s=i[e.id+"_"+t];s&&o(a,t,s)}},p.addEvent=i,p.removeEvent=o},function(e,t,n){"use strict";var a=n(3),r=n(8),i=n(2);a._set("global",{plugins:{filler:{propagate:!0}}}),e.exports=function(){function e(e,t,n){var a,r=e._model||{},i=r.fill;if(void 0===i&&(i=!!r.backgroundColor),i===!1||null===i)return!1;if(i===!0)return"origin";if(a=parseFloat(i,10),isFinite(a)&&Math.floor(a)===a)return"-"!==i[0]&&"+"!==i[0]||(a=t+a),!(a===t||a<0||a>=n)&&a;switch(i){case"bottom":return"start";case"top":return"end";case"zero":return"origin";case"origin":case"start":case"end":return i;default:return!1}}function t(e){var t,n=e.el._model||{},a=e.el._scale||{},r=e.fill,i=null;if(isFinite(r))return null;if("start"===r?i=void 0===n.scaleBottom?a.bottom:n.scaleBottom:"end"===r?i=void 0===n.scaleTop?a.top:n.scaleTop:void 0!==n.scaleZero?i=n.scaleZero:a.getBasePosition?i=a.getBasePosition():a.getBasePixel&&(i=a.getBasePixel()),void 0!==i&&null!==i){if(void 0!==i.x&&void 0!==i.y)return i;if("number"==typeof i&&isFinite(i))return t=a.isHorizontal(),{x:t?i:null,y:t?null:i}}return null}function n(e,t,n){var a,r=e[t],i=r.fill,o=[t];if(!n)return i;for(;i!==!1&&o.indexOf(i)===-1;){if(!isFinite(i))return i;if(a=e[i],!a)return!1;if(a.visible)return i;o.push(i),i=a.fill}return!1}function o(e){var t=e.fill,n="dataset";return t===!1?null:(isFinite(t)||(n="boundary"),l[n](e))}function s(e){return e&&!e.skip}function d(e,t,n,a,r){var o;if(a&&r){for(e.moveTo(t[0].x,t[0].y),o=1;o<a;++o)i.canvas.lineTo(e,t[o-1],t[o]);for(e.lineTo(n[r-1].x,n[r-1].y),o=r-1;o>0;--o)i.canvas.lineTo(e,n[o],n[o-1],!0)}}function u(e,t,n,a,r,i){var o,u,l,c,h,_,m,f=t.length,p=a.spanGaps,y=[],g=[],v=0,M=0;for(e.beginPath(),o=0,u=f+!!i;o<u;++o)l=o%f,c=t[l]._view,h=n(c,l,a),_=s(c),m=s(h),_&&m?(v=y.push(c),M=g.push(h)):v&&M&&(p?(_&&y.push(c),m&&g.push(h)):(d(e,y,g,v,M),v=M=0,y=[],g=[]));d(e,y,g,v,M),e.closePath(),e.fillStyle=r,e.fill()}var l={dataset:function(e){var t=e.fill,n=e.chart,a=n.getDatasetMeta(t),r=a&&n.isDatasetVisible(t),i=r&&a.dataset._children||[],o=i.length||0;return o?function(e,t){return t<o&&i[t]._view||null}:null},boundary:function(e){var t=e.boundary,n=t?t.x:null,a=t?t.y:null;return function(e){return{x:null===n?e.x:n,y:null===a?e.y:a}}}};return{id:"filler",afterDatasetsUpdate:function(a,i){var s,d,u,l,c=(a.data.datasets||[]).length,h=i.propagate,_=[];for(d=0;d<c;++d)s=a.getDatasetMeta(d),u=s.dataset,l=null,u&&u._model&&u instanceof r.Line&&(l={visible:a.isDatasetVisible(d),fill:e(u,d,c),chart:a,el:u}),s.$filler=l,_.push(l);for(d=0;d<c;++d)l=_[d],l&&(l.fill=n(_,d,h),l.boundary=t(l),l.mapper=o(l))},beforeDatasetDraw:function(e,t){var n=t.meta.$filler;if(n){var r=e.ctx,o=n.el,s=o._view,d=o._children||[],l=n.mapper,c=s.backgroundColor||a.global.defaultColor;l&&c&&d.length&&(i.canvas.clipArea(r,e.chartArea),u(r,d,l,s,c,o._loop),i.canvas.unclipArea(r))}}}}},function(e,t,n){"use strict";var a=n(3),r=n(4),i=n(2);a._set("global",{legend:{display:!0,position:"top",fullWidth:!0,reverse:!1,weight:1e3,onClick:function(e,t){var n=t.datasetIndex,a=this.chart,r=a.getDatasetMeta(n);r.hidden=null===r.hidden?!a.data.datasets[n].hidden:null,a.update()},onHover:null,labels:{boxWidth:40,padding:10,generateLabels:function(e){var t=e.data;return i.isArray(t.datasets)?t.datasets.map(function(t,n){return{text:t.label,fillStyle:i.isArray(t.backgroundColor)?t.backgroundColor[0]:t.backgroundColor,hidden:!e.isDatasetVisible(n),lineCap:t.borderCapStyle,lineDash:t.borderDash,lineDashOffset:t.borderDashOffset,lineJoin:t.borderJoinStyle,lineWidth:t.borderWidth,strokeStyle:t.borderColor,pointStyle:t.pointStyle,datasetIndex:n}},this):[]}}},legendCallback:function(e){var t=[];t.push('<ul class="'+e.id+'-legend">');for(var n=0;n<e.data.datasets.length;n++)t.push('<li><span style="background-color:'+e.data.datasets[n].backgroundColor+'"></span>'),e.data.datasets[n].label&&t.push(e.data.datasets[n].label),t.push("</li>");return t.push("</ul>"),t.join("")}}),e.exports=function(e){function t(e,t){return e.usePointStyle?t*Math.SQRT2:e.boxWidth}function n(t,n){var a=new e.Legend({ctx:t.ctx,options:n,chart:t});o.configure(t,a,n),o.addBox(t,a),t.legend=a}var o=e.layoutService,s=i.noop;return e.Legend=r.extend({initialize:function(e){i.extend(this,e),this.legendHitBoxes=[],this.doughnutMode=!1},beforeUpdate:s,update:function(e,t,n){var a=this;return a.beforeUpdate(),a.maxWidth=e,a.maxHeight=t,a.margins=n,a.beforeSetDimensions(),a.setDimensions(),a.afterSetDimensions(),a.beforeBuildLabels(),a.buildLabels(),a.afterBuildLabels(),a.beforeFit(),a.fit(),a.afterFit(),a.afterUpdate(),a.minSize},afterUpdate:s,beforeSetDimensions:s,setDimensions:function(){var e=this;e.isHorizontal()?(e.width=e.maxWidth,e.left=0,e.right=e.width):(e.height=e.maxHeight,e.top=0,e.bottom=e.height),e.paddingLeft=0,e.paddingTop=0,e.paddingRight=0,e.paddingBottom=0,e.minSize={width:0,height:0}},afterSetDimensions:s,beforeBuildLabels:s,buildLabels:function(){var e=this,t=e.options.labels||{},n=i.callback(t.generateLabels,[e.chart],e)||[];t.filter&&(n=n.filter(function(n){return t.filter(n,e.chart.data)})),e.options.reverse&&n.reverse(),e.legendItems=n},afterBuildLabels:s,beforeFit:s,fit:function(){var e=this,n=e.options,r=n.labels,o=n.display,s=e.ctx,d=a.global,u=i.valueOrDefault,l=u(r.fontSize,d.defaultFontSize),c=u(r.fontStyle,d.defaultFontStyle),h=u(r.fontFamily,d.defaultFontFamily),_=i.fontString(l,c,h),m=e.legendHitBoxes=[],f=e.minSize,p=e.isHorizontal();if(p?(f.width=e.maxWidth,f.height=o?10:0):(f.width=o?10:0,f.height=e.maxHeight),o)if(s.font=_,p){var y=e.lineWidths=[0],g=e.legendItems.length?l+r.padding:0;s.textAlign="left",s.textBaseline="top",i.each(e.legendItems,function(n,a){var i=t(r,l),o=i+l/2+s.measureText(n.text).width;y[y.length-1]+o+r.padding>=e.width&&(g+=l+r.padding,y[y.length]=e.left),m[a]={left:0,top:0,width:o,height:l},y[y.length-1]+=o+r.padding}),f.height+=g}else{var v=r.padding,M=e.columnWidths=[],L=r.padding,b=0,k=0,Y=l+v;i.each(e.legendItems,function(e,n){var a=t(r,l),i=a+l/2+s.measureText(e.text).width;k+Y>f.height&&(L+=b+r.padding,M.push(b),b=0,k=0),b=Math.max(b,i),k+=Y,m[n]={left:0,top:0,width:i,height:l}}),L+=b,M.push(b),f.width+=L}e.width=f.width,e.height=f.height},afterFit:s,isHorizontal:function(){return"top"===this.options.position||"bottom"===this.options.position},draw:function(){var e=this,n=e.options,r=n.labels,o=a.global,s=o.elements.line,d=e.width,u=e.lineWidths;if(n.display){var l,c=e.ctx,h=i.valueOrDefault,_=h(r.fontColor,o.defaultFontColor),m=h(r.fontSize,o.defaultFontSize),f=h(r.fontStyle,o.defaultFontStyle),p=h(r.fontFamily,o.defaultFontFamily),y=i.fontString(m,f,p);c.textAlign="left",c.textBaseline="middle",c.lineWidth=.5,c.strokeStyle=_,c.fillStyle=_,c.font=y;var g=t(r,m),v=e.legendHitBoxes,M=function(e,t,a){if(!(isNaN(g)||g<=0)){c.save(),c.fillStyle=h(a.fillStyle,o.defaultColor),c.lineCap=h(a.lineCap,s.borderCapStyle),c.lineDashOffset=h(a.lineDashOffset,s.borderDashOffset),c.lineJoin=h(a.lineJoin,s.borderJoinStyle),c.lineWidth=h(a.lineWidth,s.borderWidth),c.strokeStyle=h(a.strokeStyle,o.defaultColor);var r=0===h(a.lineWidth,s.borderWidth);if(c.setLineDash&&c.setLineDash(h(a.lineDash,s.borderDash)),n.labels&&n.labels.usePointStyle){var d=m*Math.SQRT2/2,u=d/Math.SQRT2,l=e+u,_=t+u;i.canvas.drawPoint(c,a.pointStyle,d,l,_)}else r||c.strokeRect(e,t,g,m),c.fillRect(e,t,g,m);c.restore()}},L=function(e,t,n,a){var r=m/2,i=g+r+e,o=t+r;c.fillText(n.text,i,o),n.hidden&&(c.beginPath(),c.lineWidth=2,c.moveTo(i,o),c.lineTo(i+a,o),c.stroke())},b=e.isHorizontal();l=b?{x:e.left+(d-u[0])/2,y:e.top+r.padding,line:0}:{x:e.left+r.padding,y:e.top+r.padding,line:0};var k=m+r.padding;i.each(e.legendItems,function(t,n){var a=c.measureText(t.text).width,i=g+m/2+a,o=l.x,s=l.y;b?o+i>=d&&(s=l.y+=k,l.line++,o=l.x=e.left+(d-u[l.line])/2):s+k>e.bottom&&(o=l.x=o+e.columnWidths[l.line]+r.padding,s=l.y=e.top+r.padding,l.line++),M(o,s,t),v[n].left=o,v[n].top=s,L(o,s,t,a),b?l.x+=i+r.padding:l.y+=k})}},handleEvent:function(e){var t=this,n=t.options,a="mouseup"===e.type?"click":e.type,r=!1;if("mousemove"===a){if(!n.onHover)return}else{if("click"!==a)return;if(!n.onClick)return}var i=e.x,o=e.y;if(i>=t.left&&i<=t.right&&o>=t.top&&o<=t.bottom)for(var s=t.legendHitBoxes,d=0;d<s.length;++d){var u=s[d];if(i>=u.left&&i<=u.left+u.width&&o>=u.top&&o<=u.top+u.height){if("click"===a){n.onClick.call(t,e.native,t.legendItems[d]),r=!0;break}if("mousemove"===a){n.onHover.call(t,e.native,t.legendItems[d]),r=!0;break}}}return r}}),{id:"legend",beforeInit:function(e){var t=e.options.legend;t&&n(e,t)},beforeUpdate:function(e){var t=e.options.legend,r=e.legend;t?(i.mergeIf(t,a.global.legend),r?(o.configure(e,r,t),r.options=t):n(e,t)):r&&(o.removeBox(e,r),delete e.legend)},afterEvent:function(e,t){var n=e.legend;n&&n.handleEvent(t)}}}},function(e,t,n){"use strict";var a=n(3),r=n(4),i=n(2);a._set("global",{title:{display:!1,fontStyle:"bold",fullWidth:!0,lineHeight:1.2,padding:10,position:"top",text:"",weight:2e3}}),e.exports=function(e){function t(t,a){var r=new e.Title({ctx:t.ctx,options:a,chart:t});n.configure(t,r,a),n.addBox(t,r),t.titleBlock=r}var n=e.layoutService,o=i.noop;return e.Title=r.extend({initialize:function(e){var t=this;i.extend(t,e),t.legendHitBoxes=[]},beforeUpdate:o,update:function(e,t,n){var a=this;return a.beforeUpdate(),a.maxWidth=e,a.maxHeight=t,a.margins=n,a.beforeSetDimensions(),a.setDimensions(),a.afterSetDimensions(),a.beforeBuildLabels(),a.buildLabels(),a.afterBuildLabels(),a.beforeFit(),a.fit(),a.afterFit(),a.afterUpdate(),a.minSize},afterUpdate:o,beforeSetDimensions:o,setDimensions:function(){var e=this;e.isHorizontal()?(e.width=e.maxWidth,e.left=0,e.right=e.width):(e.height=e.maxHeight,e.top=0,e.bottom=e.height),e.paddingLeft=0,e.paddingTop=0,e.paddingRight=0,e.paddingBottom=0,e.minSize={width:0,height:0}},afterSetDimensions:o,beforeBuildLabels:o,buildLabels:o,afterBuildLabels:o,beforeFit:o,fit:function(){var e=this,t=i.valueOrDefault,n=e.options,r=n.display,o=t(n.fontSize,a.global.defaultFontSize),s=e.minSize,d=i.isArray(n.text)?n.text.length:1,u=i.options.toLineHeight(n.lineHeight,o),l=r?d*u+2*n.padding:0;e.isHorizontal()?(s.width=e.maxWidth,s.height=l):(s.width=l,s.height=e.maxHeight),e.width=s.width,e.height=s.height},afterFit:o,isHorizontal:function(){var e=this.options.position;return"top"===e||"bottom"===e},draw:function(){var e=this,t=e.ctx,n=i.valueOrDefault,r=e.options,o=a.global;if(r.display){var s,d,u,l=n(r.fontSize,o.defaultFontSize),c=n(r.fontStyle,o.defaultFontStyle),h=n(r.fontFamily,o.defaultFontFamily),_=i.fontString(l,c,h),m=i.options.toLineHeight(r.lineHeight,l),f=m/2+r.padding,p=0,y=e.top,g=e.left,v=e.bottom,M=e.right;t.fillStyle=n(r.fontColor,o.defaultFontColor),t.font=_,e.isHorizontal()?(d=g+(M-g)/2,u=y+f,s=M-g):(d="left"===r.position?g+f:M-f,u=y+(v-y)/2,s=v-y,p=Math.PI*("left"===r.position?-.5:.5)),t.save(),t.translate(d,u),t.rotate(p),t.textAlign="center",t.textBaseline="middle";var L=r.text;if(i.isArray(L))for(var b=0,k=0;k<L.length;++k)t.fillText(L[k],0,b,s),b+=m;else t.fillText(L,0,0,s);t.restore()}}}),{id:"title",beforeInit:function(e){var n=e.options.title;n&&t(e,n)},beforeUpdate:function(r){var o=r.options.title,s=r.titleBlock;o?(i.mergeIf(o,a.global.title),s?(n.configure(r,s,o),s.options=o):t(r,o)):s&&(e.layoutService.removeBox(r,s),delete r.titleBlock)}}}},function(e,t){"use strict";e.exports=function(e){var t={position:"bottom"},n=e.Scale.extend({getLabels:function(){var e=this.chart.data;return this.options.labels||(this.isHorizontal()?e.xLabels:e.yLabels)||e.labels},determineDataLimits:function(){var e=this,t=e.getLabels();e.minIndex=0,e.maxIndex=t.length-1;var n;void 0!==e.options.ticks.min&&(n=t.indexOf(e.options.ticks.min),e.minIndex=n!==-1?n:e.minIndex),void 0!==e.options.ticks.max&&(n=t.indexOf(e.options.ticks.max),e.maxIndex=n!==-1?n:e.maxIndex),e.min=t[e.minIndex],e.max=t[e.maxIndex]},buildTicks:function(){var e=this,t=e.getLabels();e.ticks=0===e.minIndex&&e.maxIndex===t.length-1?t:t.slice(e.minIndex,e.maxIndex+1)},getLabelForIndex:function(e,t){var n=this,a=n.chart.data,r=n.isHorizontal();return a.yLabels&&!r?n.getRightValue(a.datasets[t].data[e]):n.ticks[e-n.minIndex]},getPixelForValue:function(e,t){var n,a=this,r=a.options.offset,i=Math.max(a.maxIndex+1-a.minIndex-(r?0:1),1);if(void 0!==e&&null!==e&&(n=a.isHorizontal()?e.x:e.y),void 0!==n||void 0!==e&&isNaN(t)){var o=a.getLabels();e=n||e;var s=o.indexOf(e);t=s!==-1?s:t}if(a.isHorizontal()){var d=a.width/i,u=d*(t-a.minIndex);return r&&(u+=d/2),a.left+Math.round(u)}var l=a.height/i,c=l*(t-a.minIndex);return r&&(c+=l/2),a.top+Math.round(c)},getPixelForTick:function(e){return this.getPixelForValue(this.ticks[e],e+this.minIndex,null)},getValueForPixel:function(e){var t,n=this,a=n.options.offset,r=Math.max(n._ticks.length-(a?0:1),1),i=n.isHorizontal(),o=(i?n.width:n.height)/r;return e-=i?n.left:n.top,a&&(e-=o/2),t=e<=0?0:Math.round(e/o),t+n.minIndex},getBasePixel:function(){return this.bottom}});e.scaleService.registerScaleType("category",n,t)}},function(e,t,n){"use strict";var a=n(3),r=n(2),i=n(9);e.exports=function(e){var t={position:"left",ticks:{callback:i.formatters.linear}},n=e.LinearScaleBase.extend({determineDataLimits:function(){function e(e){return s?e.xAxisID===t.id:e.yAxisID===t.id}var t=this,n=t.options,a=t.chart,i=a.data,o=i.datasets,s=t.isHorizontal(),d=0,u=1;t.min=null,t.max=null;var l=n.stacked;if(void 0===l&&r.each(o,function(t,n){if(!l){var r=a.getDatasetMeta(n);a.isDatasetVisible(n)&&e(r)&&void 0!==r.stack&&(l=!0)}}),n.stacked||l){var c={};r.each(o,function(i,o){var s=a.getDatasetMeta(o),d=[s.type,void 0===n.stacked&&void 0===s.stack?o:"",s.stack].join(".");void 0===c[d]&&(c[d]={positiveValues:[],negativeValues:[]});var u=c[d].positiveValues,l=c[d].negativeValues;a.isDatasetVisible(o)&&e(s)&&r.each(i.data,function(e,a){var r=+t.getRightValue(e);isNaN(r)||s.data[a].hidden||(u[a]=u[a]||0,l[a]=l[a]||0,n.relativePoints?u[a]=100:r<0?l[a]+=r:u[a]+=r)})}),r.each(c,function(e){var n=e.positiveValues.concat(e.negativeValues),a=r.min(n),i=r.max(n);t.min=null===t.min?a:Math.min(t.min,a),t.max=null===t.max?i:Math.max(t.max,i)})}else r.each(o,function(n,i){var o=a.getDatasetMeta(i);a.isDatasetVisible(i)&&e(o)&&r.each(n.data,function(e,n){var a=+t.getRightValue(e);isNaN(a)||o.data[n].hidden||(null===t.min?t.min=a:a<t.min&&(t.min=a),null===t.max?t.max=a:a>t.max&&(t.max=a))})});t.min=isFinite(t.min)&&!isNaN(t.min)?t.min:d,t.max=isFinite(t.max)&&!isNaN(t.max)?t.max:u,this.handleTickRangeOptions()},getTickLimit:function(){var e,t=this,n=t.options.ticks;if(t.isHorizontal())e=Math.min(n.maxTicksLimit?n.maxTicksLimit:11,Math.ceil(t.width/50));else{var i=r.valueOrDefault(n.fontSize,a.global.defaultFontSize);e=Math.min(n.maxTicksLimit?n.maxTicksLimit:11,Math.ceil(t.height/(2*i)))}return e},handleDirectionalChanges:function(){this.isHorizontal()||this.ticks.reverse()},getLabelForIndex:function(e,t){return+this.getRightValue(this.chart.data.datasets[t].data[e])},getPixelForValue:function(e){var t,n=this,a=n.start,r=+n.getRightValue(e),i=n.end-a;return n.isHorizontal()?(t=n.left+n.width/i*(r-a),Math.round(t)):(t=n.bottom-n.height/i*(r-a),Math.round(t))},getValueForPixel:function(e){var t=this,n=t.isHorizontal(),a=n?t.width:t.height,r=(n?e-t.left:t.bottom-e)/a;return t.start+(t.end-t.start)*r},getPixelForTick:function(e){return this.getPixelForValue(this.ticksAsNumbers[e])}});e.scaleService.registerScaleType("linear",n,t)}},function(e,t,n){"use strict";var a=n(2),r=n(9);e.exports=function(e){var t=a.noop;e.LinearScaleBase=e.Scale.extend({getRightValue:function(t){return"string"==typeof t?+t:e.Scale.prototype.getRightValue.call(this,t)},handleTickRangeOptions:function(){var e=this,t=e.options,n=t.ticks;if(n.beginAtZero){var r=a.sign(e.min),i=a.sign(e.max);r<0&&i<0?e.max=0:r>0&&i>0&&(e.min=0)}var o=void 0!==n.min||void 0!==n.suggestedMin,s=void 0!==n.max||void 0!==n.suggestedMax;void 0!==n.min?e.min=n.min:void 0!==n.suggestedMin&&(null===e.min?e.min=n.suggestedMin:e.min=Math.min(e.min,n.suggestedMin)),void 0!==n.max?e.max=n.max:void 0!==n.suggestedMax&&(null===e.max?e.max=n.suggestedMax:e.max=Math.max(e.max,n.suggestedMax)),o!==s&&e.min>=e.max&&(o?e.max=e.min+1:e.min=e.max-1),e.min===e.max&&(e.max++,n.beginAtZero||e.min--)},getTickLimit:t,handleDirectionalChanges:t,buildTicks:function(){var e=this,t=e.options,n=t.ticks,i=e.getTickLimit();i=Math.max(2,i);var o={maxTicks:i,min:n.min,max:n.max,stepSize:a.valueOrDefault(n.fixedStepSize,n.stepSize)},s=e.ticks=r.generators.linear(o,e);e.handleDirectionalChanges(),e.max=a.max(s),e.min=a.min(s),n.reverse?(s.reverse(),e.start=e.max,e.end=e.min):(e.start=e.min,e.end=e.max)},convertTicksToLabels:function(){var t=this;t.ticksAsNumbers=t.ticks.slice(),t.zeroLineIndex=t.ticks.indexOf(0),e.Scale.prototype.convertTicksToLabels.call(t)}})}},function(e,t,n){"use strict";var a=n(2),r=n(9);e.exports=function(e){var t={position:"left",ticks:{callback:r.formatters.logarithmic}},n=e.Scale.extend({determineDataLimits:function(){function e(e){return u?e.xAxisID===t.id:e.yAxisID===t.id}var t=this,n=t.options,r=n.ticks,i=t.chart,o=i.data,s=o.datasets,d=a.valueOrDefault,u=t.isHorizontal();t.min=null,t.max=null,t.minNotZero=null;var l=n.stacked;if(void 0===l&&a.each(s,function(t,n){if(!l){var a=i.getDatasetMeta(n);i.isDatasetVisible(n)&&e(a)&&void 0!==a.stack&&(l=!0)}}),n.stacked||l){var c={};a.each(s,function(r,o){var s=i.getDatasetMeta(o),d=[s.type,void 0===n.stacked&&void 0===s.stack?o:"",s.stack].join(".");i.isDatasetVisible(o)&&e(s)&&(void 0===c[d]&&(c[d]=[]),a.each(r.data,function(e,a){var r=c[d],i=+t.getRightValue(e);isNaN(i)||s.data[a].hidden||(r[a]=r[a]||0,n.relativePoints?r[a]=100:r[a]+=i)}))}),a.each(c,function(e){var n=a.min(e),r=a.max(e);t.min=null===t.min?n:Math.min(t.min,n),t.max=null===t.max?r:Math.max(t.max,r)})}else a.each(s,function(n,r){var o=i.getDatasetMeta(r);i.isDatasetVisible(r)&&e(o)&&a.each(n.data,function(e,n){var a=+t.getRightValue(e);isNaN(a)||o.data[n].hidden||(null===t.min?t.min=a:a<t.min&&(t.min=a),null===t.max?t.max=a:a>t.max&&(t.max=a),0!==a&&(null===t.minNotZero||a<t.minNotZero)&&(t.minNotZero=a))})});t.min=d(r.min,t.min),t.max=d(r.max,t.max),t.min===t.max&&(0!==t.min&&null!==t.min?(t.min=Math.pow(10,Math.floor(a.log10(t.min))-1),t.max=Math.pow(10,Math.floor(a.log10(t.max))+1)):(t.min=1,t.max=10))},buildTicks:function(){var e=this,t=e.options,n=t.ticks,i={min:n.min,max:n.max},o=e.ticks=r.generators.logarithmic(i,e);e.isHorizontal()||o.reverse(),e.max=a.max(o),e.min=a.min(o),n.reverse?(o.reverse(),e.start=e.max,e.end=e.min):(e.start=e.min,e.end=e.max)},convertTicksToLabels:function(){this.tickValues=this.ticks.slice(),e.Scale.prototype.convertTicksToLabels.call(this)},getLabelForIndex:function(e,t){return+this.getRightValue(this.chart.data.datasets[t].data[e])},getPixelForTick:function(e){return this.getPixelForValue(this.tickValues[e])},getPixelForValue:function(e){var t,n,r,i=this,o=i.start,s=+i.getRightValue(e),d=i.options,u=d.ticks;return i.isHorizontal()?(r=a.log10(i.end)-a.log10(o),0===s?n=i.left:(t=i.width,n=i.left+t/r*(a.log10(s)-a.log10(o)))):(t=i.height,0!==o||u.reverse?0===i.end&&u.reverse?(r=a.log10(i.start)-a.log10(i.minNotZero),n=s===i.end?i.top:s===i.minNotZero?i.top+.02*t:i.top+.02*t+.98*t/r*(a.log10(s)-a.log10(i.minNotZero))):0===s?n=u.reverse?i.top:i.bottom:(r=a.log10(i.end)-a.log10(o),t=i.height,n=i.bottom-t/r*(a.log10(s)-a.log10(o))):(r=a.log10(i.end)-a.log10(i.minNotZero),n=s===o?i.bottom:s===i.minNotZero?i.bottom-.02*t:i.bottom-.02*t-.98*t/r*(a.log10(s)-a.log10(i.minNotZero)))),n},getValueForPixel:function(e){var t,n,r=this,i=a.log10(r.end)-a.log10(r.start);return r.isHorizontal()?(n=r.width,t=r.start*Math.pow(10,(e-r.left)*i/n)):(n=r.height,t=Math.pow(10,(r.bottom-e)*i/n)/r.start),t}});e.scaleService.registerScaleType("logarithmic",n,t)}},function(e,t,n){"use strict";var a=n(3),r=n(2),i=n(9);e.exports=function(e){function t(e){var t=e.options;return t.angleLines.display||t.pointLabels.display?e.chart.data.labels.length:0}function n(e){var t=e.options.pointLabels,n=r.valueOrDefault(t.fontSize,p.defaultFontSize),a=r.valueOrDefault(t.fontStyle,p.defaultFontStyle),i=r.valueOrDefault(t.fontFamily,p.defaultFontFamily),o=r.fontString(n,a,i);return{size:n,style:a,family:i,font:o}}function o(e,t,n){return r.isArray(n)?{w:r.longestText(e,e.font,n),h:n.length*t+1.5*(n.length-1)*t}:{w:e.measureText(n).width,h:t}}function s(e,t,n,a,r){return e===a||e===r?{start:t-n/2,end:t+n/2}:e<a||e>r?{start:t-n-5,end:t}:{start:t,end:t+n+5}}function d(e){var a,i,d,u=n(e),l=Math.min(e.height/2,e.width/2),c={r:e.width,l:0,t:e.height,b:0},h={};e.ctx.font=u.font,e._pointLabelSizes=[];var _=t(e);for(a=0;a<_;a++){d=e.getPointPosition(a,l),i=o(e.ctx,u.size,e.pointLabels[a]||""),e._pointLabelSizes[a]=i;var m=e.getIndexAngle(a),f=r.toDegrees(m)%360,p=s(f,d.x,i.w,0,180),y=s(f,d.y,i.h,90,270);p.start<c.l&&(c.l=p.start,h.l=m),p.end>c.r&&(c.r=p.end,h.r=m),y.start<c.t&&(c.t=y.start,h.t=m),y.end>c.b&&(c.b=y.end,h.b=m)}e.setReductions(l,c,h)}function u(e){var t=Math.min(e.height/2,e.width/2);e.drawingArea=Math.round(t),e.setCenterPoint(0,0,0,0)}function l(e){return 0===e||180===e?"center":e<180?"left":"right"}function c(e,t,n,a){if(r.isArray(t))for(var i=n.y,o=1.5*a,s=0;s<t.length;++s)e.fillText(t[s],n.x,i),i+=o;else e.fillText(t,n.x,n.y)}function h(e,t,n){90===e||270===e?n.y-=t.h/2:(e>270||e<90)&&(n.y-=t.h)}function _(e){var a=e.ctx,i=r.valueOrDefault,o=e.options,s=o.angleLines,d=o.pointLabels;a.lineWidth=s.lineWidth,a.strokeStyle=s.color;var u=e.getDistanceFromCenterForValue(o.ticks.reverse?e.min:e.max),_=n(e);a.textBaseline="top";for(var m=t(e)-1;m>=0;m--){if(s.display){var f=e.getPointPosition(m,u);a.beginPath(),a.moveTo(e.xCenter,e.yCenter),a.lineTo(f.x,f.y),a.stroke(),a.closePath()}if(d.display){var y=e.getPointPosition(m,u+5),g=i(d.fontColor,p.defaultFontColor);a.font=_.font,a.fillStyle=g;var v=e.getIndexAngle(m),M=r.toDegrees(v);a.textAlign=l(M),h(M,e._pointLabelSizes[m],y),c(a,e.pointLabels[m]||"",y,_.size)}}}function m(e,n,a,i){var o=e.ctx;if(o.strokeStyle=r.valueAtIndexOrDefault(n.color,i-1),o.lineWidth=r.valueAtIndexOrDefault(n.lineWidth,i-1),e.options.gridLines.circular)o.beginPath(),o.arc(e.xCenter,e.yCenter,a,0,2*Math.PI),o.closePath(),o.stroke();else{var s=t(e);if(0===s)return;o.beginPath();var d=e.getPointPosition(0,a);o.moveTo(d.x,d.y);for(var u=1;u<s;u++)d=e.getPointPosition(u,a),o.lineTo(d.x,d.y);o.closePath(),o.stroke()}}function f(e){return r.isNumber(e)?e:0}var p=a.global,y={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,color:"rgba(0, 0, 0, 0.1)",lineWidth:1},gridLines:{circular:!1},ticks:{showLabelBackdrop:!0,backdropColor:"rgba(255,255,255,0.75)",backdropPaddingY:2,backdropPaddingX:2,callback:i.formatters.linear},pointLabels:{display:!0,fontSize:10,callback:function(e){return e}}},g=e.LinearScaleBase.extend({setDimensions:function(){var e=this,t=e.options,n=t.ticks;e.width=e.maxWidth,e.height=e.maxHeight,e.xCenter=Math.round(e.width/2),e.yCenter=Math.round(e.height/2);var a=r.min([e.height,e.width]),i=r.valueOrDefault(n.fontSize,p.defaultFontSize);e.drawingArea=t.display?a/2-(i/2+n.backdropPaddingY):a/2},determineDataLimits:function(){var e=this,t=e.chart,n=Number.POSITIVE_INFINITY,a=Number.NEGATIVE_INFINITY;r.each(t.data.datasets,function(i,o){if(t.isDatasetVisible(o)){var s=t.getDatasetMeta(o);r.each(i.data,function(t,r){var i=+e.getRightValue(t);isNaN(i)||s.data[r].hidden||(n=Math.min(i,n),a=Math.max(i,a))})}}),e.min=n===Number.POSITIVE_INFINITY?0:n,e.max=a===Number.NEGATIVE_INFINITY?0:a,e.handleTickRangeOptions()},getTickLimit:function(){var e=this.options.ticks,t=r.valueOrDefault(e.fontSize,p.defaultFontSize);return Math.min(e.maxTicksLimit?e.maxTicksLimit:11,Math.ceil(this.drawingArea/(1.5*t)))},convertTicksToLabels:function(){var t=this;e.LinearScaleBase.prototype.convertTicksToLabels.call(t),t.pointLabels=t.chart.data.labels.map(t.options.pointLabels.callback,t)},getLabelForIndex:function(e,t){return+this.getRightValue(this.chart.data.datasets[t].data[e])},fit:function(){this.options.pointLabels.display?d(this):u(this)},setReductions:function(e,t,n){var a=this,r=t.l/Math.sin(n.l),i=Math.max(t.r-a.width,0)/Math.sin(n.r),o=-t.t/Math.cos(n.t),s=-Math.max(t.b-a.height,0)/Math.cos(n.b);r=f(r),i=f(i),o=f(o),s=f(s),a.drawingArea=Math.min(Math.round(e-(r+i)/2),Math.round(e-(o+s)/2)),a.setCenterPoint(r,i,o,s)},setCenterPoint:function(e,t,n,a){var r=this,i=r.width-t-r.drawingArea,o=e+r.drawingArea,s=n+r.drawingArea,d=r.height-a-r.drawingArea;r.xCenter=Math.round((o+i)/2+r.left),r.yCenter=Math.round((s+d)/2+r.top)},getIndexAngle:function(e){var n=2*Math.PI/t(this),a=this.chart.options&&this.chart.options.startAngle?this.chart.options.startAngle:0,r=a*Math.PI*2/360;return e*n+r},getDistanceFromCenterForValue:function(e){var t=this;if(null===e)return 0;var n=t.drawingArea/(t.max-t.min);return t.options.ticks.reverse?(t.max-e)*n:(e-t.min)*n},getPointPosition:function(e,t){var n=this,a=n.getIndexAngle(e)-Math.PI/2;return{x:Math.round(Math.cos(a)*t)+n.xCenter,y:Math.round(Math.sin(a)*t)+n.yCenter}},getPointPositionForValue:function(e,t){return this.getPointPosition(e,this.getDistanceFromCenterForValue(t))},getBasePosition:function(){var e=this,t=e.min,n=e.max;return e.getPointPositionForValue(0,e.beginAtZero?0:t<0&&n<0?n:t>0&&n>0?t:0)},draw:function(){var e=this,t=e.options,n=t.gridLines,a=t.ticks,i=r.valueOrDefault;if(t.display){var o=e.ctx,s=this.getIndexAngle(0),d=i(a.fontSize,p.defaultFontSize),u=i(a.fontStyle,p.defaultFontStyle),l=i(a.fontFamily,p.defaultFontFamily),c=r.fontString(d,u,l);r.each(e.ticks,function(t,r){if(r>0||a.reverse){var u=e.getDistanceFromCenterForValue(e.ticksAsNumbers[r]);if(n.display&&0!==r&&m(e,n,u,r),a.display){var l=i(a.fontColor,p.defaultFontColor);if(o.font=c,o.save(),o.translate(e.xCenter,e.yCenter),o.rotate(s),a.showLabelBackdrop){var h=o.measureText(t).width;o.fillStyle=a.backdropColor,o.fillRect(-h/2-a.backdropPaddingX,-u-d/2-a.backdropPaddingY,h+2*a.backdropPaddingX,d+2*a.backdropPaddingY)}o.textAlign="center",o.textBaseline="middle",o.fillStyle=l,o.fillText(t,0,-u),o.restore()}}}),(t.angleLines.display||t.pointLabels.display)&&_(e)}}});e.scaleService.registerScaleType("radialLinear",g,y)}},function(e,t,n){"use strict";function a(e,t){return e-t}function r(e){var t,n,a,r={},i=[];for(t=0,n=e.length;t<n;++t)a=e[t],r[a]||(r[a]=!0,i.push(a));return i}function i(e,t,n,a){if("linear"===a||!e.length)return[{time:t,pos:0},{time:n,pos:1}];var r,i,o,s,d,u=[],l=[t];for(r=0,i=e.length;r<i;++r)s=e[r],s>t&&s<n&&l.push(s);for(l.push(n),r=0,i=l.length;r<i;++r)d=l[r+1],o=l[r-1],s=l[r],void 0!==o&&void 0!==d&&Math.round((d+o)/2)===s||u.push({time:s,pos:r/(i-1)});return u}function o(e,t,n){for(var a,r,i,o=0,s=e.length-1;o>=0&&o<=s;){if(a=o+s>>1,r=e[a-1]||null,i=e[a],!r)return{lo:null,hi:i};if(i[t]<n)o=a+1;else{if(!(r[t]>n))return{lo:r,hi:i};s=a-1}}return{lo:i,hi:null}}function s(e,t,n,a){var r=o(e,t,n),i=r.lo?r.hi?r.lo:e[e.length-2]:e[0],s=r.lo?r.hi?r.hi:e[e.length-1]:e[1],d=s[t]-i[t],u=d?(n-i[t])/d:0,l=(s[a]-i[a])*u;return i[a]+l}function d(e,t){var n=t.parser,a=t.parser||t.format;return"function"==typeof n?n(e):"string"==typeof e&&"string"==typeof a?p(e,a):(e instanceof p||(e=p(e)),e.isValid()?e:"function"==typeof a?a(e):e)}function u(e,t){if(g.isNullOrUndef(e))return null;var n=t.options.time,a=d(t.getRightValue(e),n);return a.isValid()?(n.round&&a.startOf(n.round),a.valueOf()):null}function l(e,t,n,a){var r,i,o,s=t-e,d=L[n],u=d.size,l=d.steps;if(!l)return Math.ceil(s/((a||1)*u));for(r=0,i=l.length;r<i&&(o=l[r],!(Math.ceil(s/(u*o))<=a));++r);return o}function c(e,t,n,a){var r,i,o,s=b.length;for(r=b.indexOf(e);r<s-1;++r)if(i=L[b[r]],o=i.steps?i.steps[i.steps.length-1]:M,Math.ceil((n-t)/(o*i.size))<=a)return b[r];return b[s-1]}function h(e){for(var t=b.indexOf(e)+1,n=b.length;t<n;++t)if(L[b[t]].major)return b[t]}function _(e,t,n,a,r,i){var o,s=i.time,d=g.valueOrDefault(s.stepSize,s.unitStepSize),u="week"===n&&s.isoWeekday,c=i.ticks.major.enabled,h=L[n],_=p(e),m=p(t),f=[];for(d||(d=l(e,t,n,r)),u&&(_=_.isoWeekday(u),m=m.isoWeekday(u)),_=_.startOf(u?"day":n),m=m.startOf(u?"day":n),m<t&&m.add(1,n),o=p(_),c&&a&&!u&&!s.round&&(o.startOf(a),o.add(~~((_-o)/(h.size*d))*d,n));o<m;o.add(d,n))f.push(+o);return f.push(+o),f}function m(e,t,n,a,r){var i,o,d=0,u=0;return r.offset&&t.length&&(r.time.min||(i=t.length>1?t[1]:a,o=t[0],d=(s(e,"time",i,"pos")-s(e,"time",o,"pos"))/2),r.time.max||(i=t[t.length-1],o=t.length>1?t[t.length-2]:n,u=(s(e,"time",i,"pos")-s(e,"time",o,"pos"))/2)),{left:d,right:u}}function f(e,t){var n,a,r,i,o=[];for(n=0,a=e.length;n<a;++n)r=e[n],i=!!t&&r===+p(r).startOf(t),o.push({value:r,major:i});return o}var p=n(1);p="function"==typeof p?p:window.moment;var y=n(3),g=n(2),v=Number.MIN_SAFE_INTEGER||-9007199254740991,M=Number.MAX_SAFE_INTEGER||9007199254740991,L={millisecond:{major:!0,size:1,steps:[1,2,5,10,20,50,100,250,500]},second:{major:!0,size:1e3,steps:[1,2,5,10,30]},minute:{major:!0,size:6e4,steps:[1,2,5,10,30]},hour:{major:!0,size:36e5,steps:[1,2,3,6,12]},day:{major:!0,size:864e5,steps:[1,2,5]},week:{major:!1,size:6048e5,steps:[1,2,3,4]},month:{major:!0,size:2628e6,steps:[1,2,3]},quarter:{major:!1,size:7884e6,steps:[1,2,3,4]},year:{major:!0,size:3154e7}},b=Object.keys(L);e.exports=function(e){var t={position:"bottom",distribution:"linear",bounds:"data",time:{parser:!1,format:!1,unit:!1,round:!1,displayFormat:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{millisecond:"h:mm:ss.SSS a",second:"h:mm:ss a",minute:"h:mm a",hour:"hA",day:"MMM D",week:"ll",month:"MMM YYYY",quarter:"[Q]Q - YYYY",year:"YYYY"}},ticks:{autoSkip:!1,source:"auto",major:{enabled:!1}}},n=e.Scale.extend({initialize:function(){if(!p)throw new Error("Chart.js - Moment.js could not be found! You must include it before Chart.js to use the time scale. Download at https://momentjs.com");this.mergeTicksOptions(),e.Scale.prototype.initialize.call(this)},update:function(){var t=this,n=t.options;return n.time&&n.time.format&&console.warn("options.time.format is deprecated and replaced by options.time.parser."),e.Scale.prototype.update.apply(t,arguments)},getRightValue:function(t){return t&&void 0!==t.t&&(t=t.t),e.Scale.prototype.getRightValue.call(this,t)},determineDataLimits:function(){var e,t,n,i,o,s,d=this,l=d.chart,c=d.options.time,h=u(c.min,d)||M,_=u(c.max,d)||v,m=[],f=[],y=[];for(e=0,n=l.data.labels.length;e<n;++e)y.push(u(l.data.labels[e],d));for(e=0,n=(l.data.datasets||[]).length;e<n;++e)if(l.isDatasetVisible(e))if(o=l.data.datasets[e].data,g.isObject(o[0]))for(f[e]=[],t=0,i=o.length;t<i;++t)s=u(o[t],d),m.push(s),f[e][t]=s;else m.push.apply(m,y),f[e]=y.slice(0);else f[e]=[];y.length&&(y=r(y).sort(a),h=Math.min(h,y[0]),_=Math.max(_,y[y.length-1])),m.length&&(m=r(m).sort(a),h=Math.min(h,m[0]),_=Math.max(_,m[m.length-1])),h=h===M?+p().startOf("day"):h,_=_===v?+p().endOf("day")+1:_,d.min=Math.min(h,_),d.max=Math.max(h+1,_),d._horizontal=d.isHorizontal(),
+d._table=[],d._timestamps={data:m,datasets:f,labels:y}},buildTicks:function(){var e,t,n,a=this,r=a.min,o=a.max,s=a.options,d=s.time,l=d.displayFormats,p=a.getLabelCapacity(r),y=d.unit||c(d.minUnit,r,o,p),g=h(y),v=[],M=[];switch(s.ticks.source){case"data":v=a._timestamps.data;break;case"labels":v=a._timestamps.labels;break;case"auto":default:v=_(r,o,y,g,p,s)}for("ticks"===s.bounds&&v.length&&(r=v[0],o=v[v.length-1]),r=u(d.min,a)||r,o=u(d.max,a)||o,e=0,t=v.length;e<t;++e)n=v[e],n>=r&&n<=o&&M.push(n);return a.min=r,a.max=o,a._unit=y,a._majorUnit=g,a._minorFormat=l[y],a._majorFormat=l[g],a._table=i(a._timestamps.data,r,o,s.distribution),a._offsets=m(a._table,M,r,o,s),f(M,g)},getLabelForIndex:function(e,t){var n=this,a=n.chart.data,r=n.options.time,i=a.labels&&e<a.labels.length?a.labels[e]:"",o=a.datasets[t].data[e];return g.isObject(o)&&(i=n.getRightValue(o)),r.tooltipFormat&&(i=d(i,r).format(r.tooltipFormat)),i},tickFormatFunction:function(e,t,n){var a=this,r=a.options,i=e.valueOf(),o=a._majorUnit,s=a._majorFormat,d=e.clone().startOf(a._majorUnit).valueOf(),u=r.ticks.major,l=u.enabled&&o&&s&&i===d,c=e.format(l?s:a._minorFormat),h=l?u:r.ticks.minor,_=g.valueOrDefault(h.callback,h.userCallback);return _?_(c,t,n):c},convertTicksToLabels:function(e){var t,n,a=[];for(t=0,n=e.length;t<n;++t)a.push(this.tickFormatFunction(p(e[t].value),t,e));return a},getPixelForOffset:function(e){var t=this,n=t._horizontal?t.width:t.height,a=t._horizontal?t.left:t.top,r=s(t._table,"time",e,"pos");return a+n*(t._offsets.left+r)/(t._offsets.left+1+t._offsets.right)},getPixelForValue:function(e,t,n){var a=this,r=null;if(void 0!==t&&void 0!==n&&(r=a._timestamps.datasets[n][t]),null===r&&(r=u(e,a)),null!==r)return a.getPixelForOffset(r)},getPixelForTick:function(e){var t=this.getTicks();return e>=0&&e<t.length?this.getPixelForOffset(t[e].value):null},getValueForPixel:function(e){var t=this,n=t._horizontal?t.width:t.height,a=t._horizontal?t.left:t.top,r=(n?(e-a)/n:0)*(t._offsets.left+1+t._offsets.left)-t._offsets.right,i=s(t._table,"pos",r,"time");return p(i)},getLabelWidth:function(e){var t=this,n=t.options.ticks,a=t.ctx.measureText(e).width,r=g.toRadians(n.maxRotation),i=Math.cos(r),o=Math.sin(r),s=g.valueOrDefault(n.fontSize,y.global.defaultFontSize);return a*i+s*o},getLabelCapacity:function(e){var t=this;t._minorFormat=t.options.time.displayFormats.millisecond;var n=t.tickFormatFunction(p(e),0,[]),a=t.getLabelWidth(n),r=t.isHorizontal()?t.width:t.height;return Math.floor(r/a)}});e.scaleService.registerScaleType("time",n,t)}},function(e,t,n){function a(e){if(e){var t=/^#([a-fA-F0-9]{3})$/i,n=/^#([a-fA-F0-9]{6})$/i,a=/^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,r=/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,i=/(\w+)/,o=[0,0,0],s=1,d=e.match(t);if(d){d=d[1];for(var u=0;u<o.length;u++)o[u]=parseInt(d[u]+d[u],16)}else if(d=e.match(n)){d=d[1];for(var u=0;u<o.length;u++)o[u]=parseInt(d.slice(2*u,2*u+2),16)}else if(d=e.match(a)){for(var u=0;u<o.length;u++)o[u]=parseInt(d[u+1]);s=parseFloat(d[4])}else if(d=e.match(r)){for(var u=0;u<o.length;u++)o[u]=Math.round(2.55*parseFloat(d[u+1]));s=parseFloat(d[4])}else if(d=e.match(i)){if("transparent"==d[1])return[0,0,0,0];if(o=M[d[1]],!o)return}for(var u=0;u<o.length;u++)o[u]=g(o[u],0,255);return s=s||0==s?g(s,0,1):1,o[3]=s,o}}function r(e){if(e){var t=/^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/,n=e.match(t);if(n){var a=parseFloat(n[4]),r=g(parseInt(n[1]),0,360),i=g(parseFloat(n[2]),0,100),o=g(parseFloat(n[3]),0,100),s=g(isNaN(a)?1:a,0,1);return[r,i,o,s]}}}function i(e){if(e){var t=/^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/,n=e.match(t);if(n){var a=parseFloat(n[4]),r=g(parseInt(n[1]),0,360),i=g(parseFloat(n[2]),0,100),o=g(parseFloat(n[3]),0,100),s=g(isNaN(a)?1:a,0,1);return[r,i,o,s]}}}function o(e){var t=a(e);return t&&t.slice(0,3)}function s(e){var t=r(e);return t&&t.slice(0,3)}function d(e){var t=a(e);return t?t[3]:(t=r(e))?t[3]:(t=i(e))?t[3]:void 0}function u(e){return"#"+v(e[0])+v(e[1])+v(e[2])}function l(e,t){return t<1||e[3]&&e[3]<1?c(e,t):"rgb("+e[0]+", "+e[1]+", "+e[2]+")"}function c(e,t){return void 0===t&&(t=void 0!==e[3]?e[3]:1),"rgba("+e[0]+", "+e[1]+", "+e[2]+", "+t+")"}function h(e,t){if(t<1||e[3]&&e[3]<1)return _(e,t);var n=Math.round(e[0]/255*100),a=Math.round(e[1]/255*100),r=Math.round(e[2]/255*100);return"rgb("+n+"%, "+a+"%, "+r+"%)"}function _(e,t){var n=Math.round(e[0]/255*100),a=Math.round(e[1]/255*100),r=Math.round(e[2]/255*100);return"rgba("+n+"%, "+a+"%, "+r+"%, "+(t||e[3]||1)+")"}function m(e,t){return t<1||e[3]&&e[3]<1?f(e,t):"hsl("+e[0]+", "+e[1]+"%, "+e[2]+"%)"}function f(e,t){return void 0===t&&(t=void 0!==e[3]?e[3]:1),"hsla("+e[0]+", "+e[1]+"%, "+e[2]+"%, "+t+")"}function p(e,t){return void 0===t&&(t=void 0!==e[3]?e[3]:1),"hwb("+e[0]+", "+e[1]+"%, "+e[2]+"%"+(void 0!==t&&1!==t?", "+t:"")+")"}function y(e){return L[e.slice(0,3)]}function g(e,t,n){return Math.min(Math.max(t,e),n)}function v(e){var t=e.toString(16).toUpperCase();return t.length<2?"0"+t:t}var M=n(197);e.exports={getRgba:a,getHsla:r,getRgb:o,getHsl:s,getHwb:i,getAlpha:d,hexString:u,rgbString:l,rgbaString:c,percentString:h,percentaString:_,hslString:m,hslaString:f,hwbString:p,keyword:y};var L={};for(var b in M)L[M[b]]=b},function(e,t){function n(e){var t,n,a,r=e[0]/255,i=e[1]/255,o=e[2]/255,s=Math.min(r,i,o),d=Math.max(r,i,o),u=d-s;return d==s?t=0:r==d?t=(i-o)/u:i==d?t=2+(o-r)/u:o==d&&(t=4+(r-i)/u),t=Math.min(60*t,360),t<0&&(t+=360),a=(s+d)/2,n=d==s?0:a<=.5?u/(d+s):u/(2-d-s),[t,100*n,100*a]}function a(e){var t,n,a,r=e[0],i=e[1],o=e[2],s=Math.min(r,i,o),d=Math.max(r,i,o),u=d-s;return n=0==d?0:u/d*1e3/10,d==s?t=0:r==d?t=(i-o)/u:i==d?t=2+(o-r)/u:o==d&&(t=4+(r-i)/u),t=Math.min(60*t,360),t<0&&(t+=360),a=d/255*1e3/10,[t,n,a]}function i(e){var t=e[0],a=e[1],r=e[2],i=n(e)[0],o=1/255*Math.min(t,Math.min(a,r)),r=1-1/255*Math.max(t,Math.max(a,r));return[i,100*o,100*r]}function o(e){var t,n,a,r,i=e[0]/255,o=e[1]/255,s=e[2]/255;return r=Math.min(1-i,1-o,1-s),t=(1-i-r)/(1-r)||0,n=(1-o-r)/(1-r)||0,a=(1-s-r)/(1-r)||0,[100*t,100*n,100*a,100*r]}function s(e){return K[JSON.stringify(e)]}function d(e){var t=e[0]/255,n=e[1]/255,a=e[2]/255;t=t>.04045?Math.pow((t+.055)/1.055,2.4):t/12.92,n=n>.04045?Math.pow((n+.055)/1.055,2.4):n/12.92,a=a>.04045?Math.pow((a+.055)/1.055,2.4):a/12.92;var r=.4124*t+.3576*n+.1805*a,i=.2126*t+.7152*n+.0722*a,o=.0193*t+.1192*n+.9505*a;return[100*r,100*i,100*o]}function u(e){var t,n,a,r=d(e),i=r[0],o=r[1],s=r[2];return i/=95.047,o/=100,s/=108.883,i=i>.008856?Math.pow(i,1/3):7.787*i+16/116,o=o>.008856?Math.pow(o,1/3):7.787*o+16/116,s=s>.008856?Math.pow(s,1/3):7.787*s+16/116,t=116*o-16,n=500*(i-o),a=200*(o-s),[t,n,a]}function l(e){return F(u(e))}function c(e){var t,n,a,r,i,o=e[0]/360,s=e[1]/100,d=e[2]/100;if(0==s)return i=255*d,[i,i,i];n=d<.5?d*(1+s):d+s-d*s,t=2*d-n,r=[0,0,0];for(var u=0;u<3;u++)a=o+1/3*-(u-1),a<0&&a++,a>1&&a--,i=6*a<1?t+6*(n-t)*a:2*a<1?n:3*a<2?t+(n-t)*(2/3-a)*6:t,r[u]=255*i;return r}function h(e){var t,n,a=e[0],r=e[1]/100,i=e[2]/100;return 0===i?[0,0,0]:(i*=2,r*=i<=1?i:2-i,n=(i+r)/2,t=2*r/(i+r),[a,100*t,100*n])}function _(e){return i(c(e))}function m(e){return o(c(e))}function f(e){return s(c(e))}function p(e){var t=e[0]/60,n=e[1]/100,a=e[2]/100,r=Math.floor(t)%6,i=t-Math.floor(t),o=255*a*(1-n),s=255*a*(1-n*i),d=255*a*(1-n*(1-i)),a=255*a;switch(r){case 0:return[a,d,o];case 1:return[s,a,o];case 2:return[o,a,d];case 3:return[o,s,a];case 4:return[d,o,a];case 5:return[a,o,s]}}function y(e){var t,n,a=e[0],r=e[1]/100,i=e[2]/100;return n=(2-r)*i,t=r*i,t/=n<=1?n:2-n,t=t||0,n/=2,[a,100*t,100*n]}function v(e){return i(p(e))}function M(e){return o(p(e))}function L(e){return s(p(e))}function k(e){var t,n,a,i,o=e[0]/360,s=e[1]/100,d=e[2]/100,u=s+d;switch(u>1&&(s/=u,d/=u),t=Math.floor(6*o),n=1-d,a=6*o-t,0!=(1&t)&&(a=1-a),i=s+a*(n-s),t){default:case 6:case 0:r=n,g=i,b=s;break;case 1:r=i,g=n,b=s;break;case 2:r=s,g=n,b=i;break;case 3:r=s,g=i,b=n;break;case 4:r=i,g=s,b=n;break;case 5:r=n,g=s,b=i}return[255*r,255*g,255*b]}function Y(e){return n(k(e))}function D(e){return a(k(e))}function w(e){return o(k(e))}function x(e){return s(k(e))}function T(e){var t,n,a,r=e[0]/100,i=e[1]/100,o=e[2]/100,s=e[3]/100;return t=1-Math.min(1,r*(1-s)+s),n=1-Math.min(1,i*(1-s)+s),a=1-Math.min(1,o*(1-s)+s),[255*t,255*n,255*a]}function S(e){return n(T(e))}function j(e){return a(T(e))}function H(e){return i(T(e))}function O(e){return s(T(e))}function P(e){var t,n,a,r=e[0]/100,i=e[1]/100,o=e[2]/100;return t=3.2406*r+i*-1.5372+o*-.4986,n=r*-.9689+1.8758*i+.0415*o,a=.0557*r+i*-.204+1.057*o,t=t>.0031308?1.055*Math.pow(t,1/2.4)-.055:t*=12.92,n=n>.0031308?1.055*Math.pow(n,1/2.4)-.055:n*=12.92,a=a>.0031308?1.055*Math.pow(a,1/2.4)-.055:a*=12.92,t=Math.min(Math.max(0,t),1),n=Math.min(Math.max(0,n),1),a=Math.min(Math.max(0,a),1),[255*t,255*n,255*a]}function A(e){var t,n,a,r=e[0],i=e[1],o=e[2];return r/=95.047,i/=100,o/=108.883,r=r>.008856?Math.pow(r,1/3):7.787*r+16/116,i=i>.008856?Math.pow(i,1/3):7.787*i+16/116,o=o>.008856?Math.pow(o,1/3):7.787*o+16/116,t=116*i-16,n=500*(r-i),a=200*(i-o),[t,n,a]}function C(e){return F(A(e))}function E(e){var t,n,a,r,i=e[0],o=e[1],s=e[2];return i<=8?(n=100*i/903.3,r=7.787*(n/100)+16/116):(n=100*Math.pow((i+16)/116,3),r=Math.pow(n/100,1/3)),t=t/95.047<=.008856?t=95.047*(o/500+r-16/116)/7.787:95.047*Math.pow(o/500+r,3),a=a/108.883<=.008859?a=108.883*(r-s/200-16/116)/7.787:108.883*Math.pow(r-s/200,3),[t,n,a]}function F(e){var t,n,a,r=e[0],i=e[1],o=e[2];return t=Math.atan2(o,i),n=360*t/2/Math.PI,n<0&&(n+=360),a=Math.sqrt(i*i+o*o),[r,a,n]}function W(e){return P(E(e))}function I(e){var t,n,a,r=e[0],i=e[1],o=e[2];return a=o/360*2*Math.PI,t=i*Math.cos(a),n=i*Math.sin(a),[r,t,n]}function N(e){return E(I(e))}function z(e){return W(I(e))}function R(e){return q[e]}function V(e){return n(R(e))}function B(e){return a(R(e))}function $(e){return i(R(e))}function J(e){return o(R(e))}function U(e){return u(R(e))}function G(e){return d(R(e))}e.exports={rgb2hsl:n,rgb2hsv:a,rgb2hwb:i,rgb2cmyk:o,rgb2keyword:s,rgb2xyz:d,rgb2lab:u,rgb2lch:l,hsl2rgb:c,hsl2hsv:h,hsl2hwb:_,hsl2cmyk:m,hsl2keyword:f,hsv2rgb:p,hsv2hsl:y,hsv2hwb:v,hsv2cmyk:M,hsv2keyword:L,hwb2rgb:k,hwb2hsl:Y,hwb2hsv:D,hwb2cmyk:w,hwb2keyword:x,cmyk2rgb:T,cmyk2hsl:S,cmyk2hsv:j,cmyk2hwb:H,cmyk2keyword:O,keyword2rgb:R,keyword2hsl:V,keyword2hsv:B,keyword2hwb:$,keyword2cmyk:J,keyword2lab:U,keyword2xyz:G,xyz2rgb:P,xyz2lab:A,xyz2lch:C,lab2xyz:E,lab2rgb:W,lab2lch:F,lch2lab:I,lch2xyz:N,lch2rgb:z};var q={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]},K={};for(var Z in q)K[JSON.stringify(q[Z])]=Z},function(e,t,n){var a=n(195),r=function(){return new u};for(var i in a){r[i+"Raw"]=function(e){return function(t){return"number"==typeof t&&(t=Array.prototype.slice.call(arguments)),a[e](t)}}(i);var o=/(\w+)2(\w+)/.exec(i),s=o[1],d=o[2];r[s]=r[s]||{},r[s][d]=r[i]=function(e){return function(t){"number"==typeof t&&(t=Array.prototype.slice.call(arguments));var n=a[e](t);if("string"==typeof n||void 0===n)return n;for(var r=0;r<n.length;r++)n[r]=Math.round(n[r]);return n}}(i)}var u=function(){this.convs={}};u.prototype.routeSpace=function(e,t){var n=t[0];return void 0===n?this.getValues(e):("number"==typeof n&&(n=Array.prototype.slice.call(t)),this.setValues(e,n))},u.prototype.setValues=function(e,t){return this.space=e,this.convs={},this.convs[e]=t,this},u.prototype.getValues=function(e){var t=this.convs[e];if(!t){var n=this.space,a=this.convs[n];t=r[n][e](a),this.convs[e]=t}return t},["rgb","hsl","hsv","cmyk","keyword"].forEach(function(e){u.prototype[e]=function(t){return this.routeSpace(e,arguments)}}),e.exports=r},function(e,t){e.exports={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]}},function(e,t,n){var a=n(11),r=a.JSON||(a.JSON={stringify:JSON.stringify});e.exports=function(e){return r.stringify.apply(r,arguments)}},function(e,t,n){n(224),e.exports=n(11).Object.keys},function(e,t){e.exports=function(e){if("function"!=typeof e)throw TypeError(e+" is not a function!");return e}},function(e,t,n){var a=n(15);e.exports=function(e){if(!a(e))throw TypeError(e+" is not an object!");return e}},function(e,t,n){var a=n(23),r=n(220),i=n(219);e.exports=function(e){return function(t,n,o){var s,d=a(t),u=r(d.length),l=i(o,u);if(e&&n!=n){for(;u>l;)if(s=d[l++],s!=s)return!0}else for(;u>l;l++)if((e||l in d)&&d[l]===n)return e||l||0;return!e&&-1}}},function(e,t){var n={}.toString;e.exports=function(e){return n.call(e).slice(8,-1)}},function(e,t,n){var a=n(200);e.exports=function(e,t,n){if(a(e),void 0===t)return e;switch(n){case 1:return function(n){return e.call(t,n)};case 2:return function(n,a){return e.call(t,n,a)};case 3:return function(n,a,r){return e.call(t,n,a,r)}}return function(){return e.apply(t,arguments)}}},function(e,t,n){var a=n(15),r=n(14).document,i=a(r)&&a(r.createElement);e.exports=function(e){return i?r.createElement(e):{}}},function(e,t){e.exports="constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(",")},function(e,t,n){var a=n(14),r=n(11),i=n(204),o=n(209),s="prototype",d=function(e,t,n){var u,l,c,h=e&d.F,_=e&d.G,m=e&d.S,f=e&d.P,p=e&d.B,y=e&d.W,g=_?r:r[t]||(r[t]={}),v=g[s],M=_?a:m?a[t]:(a[t]||{})[s];_&&(n=t);for(u in n)l=!h&&M&&void 0!==M[u],l&&u in g||(c=l?M[u]:n[u],g[u]=_&&"function"!=typeof M[u]?n[u]:p&&l?i(c,a):y&&M[u]==c?function(e){var t=function(t,n,a){if(this instanceof e){switch(arguments.length){case 0:return new e;case 1:return new e(t);case 2:return new e(t,n)}return new e(t,n,a)}return e.apply(this,arguments)};return t[s]=e[s],t}(c):f&&"function"==typeof c?i(Function.call,c):c,f&&((g.virtual||(g.virtual={}))[u]=c,e&d.R&&v&&!v[u]&&o(v,u,c)))};d.F=1,d.G=2,d.S=4,d.P=8,d.B=16,d.W=32,d.U=64,d.R=128,e.exports=d},function(e,t){var n={}.hasOwnProperty;e.exports=function(e,t){return n.call(e,t)}},function(e,t,n){var a=n(212),r=n(216);e.exports=n(12)?function(e,t,n){return a.f(e,t,r(1,n))}:function(e,t,n){return e[t]=n,e}},function(e,t,n){e.exports=!n(12)&&!n(13)(function(){return 7!=Object.defineProperty(n(205)("div"),"a",{get:function(){return 7}}).a})},function(e,t,n){var a=n(203);e.exports=Object("z").propertyIsEnumerable(0)?Object:function(e){return"String"==a(e)?e.split(""):Object(e)}},function(e,t,n){var a=n(201),r=n(210),i=n(222),o=Object.defineProperty;t.f=n(12)?Object.defineProperty:function(e,t,n){if(a(e),t=i(t,!0),a(n),r)try{return o(e,t,n)}catch(e){}if("get"in n||"set"in n)throw TypeError("Accessors not supported!");return"value"in n&&(e[t]=n.value),e}},function(e,t,n){var a=n(208),r=n(23),i=n(202)(!1),o=n(217)("IE_PROTO");e.exports=function(e,t){var n,s=r(e),d=0,u=[];for(n in s)n!=o&&a(s,n)&&u.push(n);for(;t.length>d;)a(s,n=t[d++])&&(~i(u,n)||u.push(n));return u}},function(e,t,n){var a=n(213),r=n(206);e.exports=Object.keys||function(e){return a(e,r)}},function(e,t,n){var a=n(207),r=n(11),i=n(13);e.exports=function(e,t){var n=(r.Object||{})[e]||Object[e],o={};o[e]=t(n),a(a.S+a.F*i(function(){n(1)}),"Object",o)}},function(e,t){e.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},function(e,t,n){var a=n(218)("keys"),r=n(223);e.exports=function(e){return a[e]||(a[e]=r(e))}},function(e,t,n){var a=n(14),r="__core-js_shared__",i=a[r]||(a[r]={});e.exports=function(e){return i[e]||(i[e]={})}},function(e,t,n){var a=n(22),r=Math.max,i=Math.min;e.exports=function(e,t){return e=a(e),e<0?r(e+t,0):i(e,t)}},function(e,t,n){var a=n(22),r=Math.min;e.exports=function(e){return e>0?r(a(e),9007199254740991):0}},function(e,t,n){var a=n(21);e.exports=function(e){return Object(a(e))}},function(e,t,n){var a=n(15);e.exports=function(e,t){if(!a(e))return e;var n,r;if(t&&"function"==typeof(n=e.toString)&&!a(r=n.call(e)))return r;if("function"==typeof(n=e.valueOf)&&!a(r=n.call(e)))return r;if(!t&&"function"==typeof(n=e.toString)&&!a(r=n.call(e)))return r;throw TypeError("Can't convert object to primitive value")}},function(e,t){var n=0,a=Math.random();e.exports=function(e){return"Symbol(".concat(void 0===e?"":e,")_",(++n+a).toString(36))}},function(e,t,n){var a=n(221),r=n(214);n(215)("keys",function(){return function(e){return r(a(e))}})},function(e,t){e.exports={name:"vue-chartjs",version:"2.8.7",description:"Vue.js wrapper for chart.js for creating beautiful charts.",author:"Jakub Juszczak <jakub@posteo.de>",homepage:"http://vue-chartjs.org",license:"MIT",contributors:[{name:"Thorsten Lünborg",web:"https://github.com/LinusBorg"},{name:"Juan Carlos Alonso",web:"https://github.com/jcalonso"}],maintainers:[{name:"Jakub Juszczak",email:"jakub@posteo.de",web:"http://www.jakubjuszczak.de"}],repository:{type:"git",url:"git+ssh://git@github.com:apertureless/vue-chartjs.git"},bugs:{url:"https://github.com/apertureless/vue-chartjs/issues"},keywords:["ChartJs","Vue","Visualisation","Wrapper","Charts"],main:"dist/vue-chartjs.js",unpkg:"dist/vue-chartjs.full.min.js",module:"es/index.js","jsnext:main":"es/index.js",files:["src","dist","es"],scripts:{dev:"node build/dev-server.js",build:"yarn run release && yarn run build:es","build:es":"cross-env BABEL_ENV=es babel src --out-dir es",unit:"karma start test/unit/karma.conf.js --single-run",e2e:"node test/e2e/runner.js",test:"npm run unit",lint:"eslint --ext .js,.vue src test/unit/specs test/e2e/specs",release:"webpack --progress --hide-modules --config  ./build/webpack.release.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.min.js && webpack --progress --hide-modules --config  ./build/webpack.release.full.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.full.min.js",prepublish:"yarn run lint && yarn run test && yarn run build"},dependencies:{"lodash.merge":"^4.6.0"},peerDependencies:{"chart.js":"^2.7.0",vue:"^2.4.4"},devDependencies:{"babel-cli":"^6.24.1","babel-core":"^6.25.0","babel-loader":"^7.0.0","babel-plugin-transform-object-assign":"^6.22.0","babel-plugin-transform-runtime":"^6.23.0","babel-preset-es2015":"^6.24.1","babel-preset-stage-2":"^6.24.1","babel-runtime":"^6.23.0",chai:"^3.5.0","chart.js":"^2.7.0",chromedriver:"^2.28.0","connect-history-api-fallback":"^1.1.0","cross-env":"^3.2.4","cross-spawn":"^5.1.0","css-loader":"^0.28.0",eslint:"^3.19.0","eslint-config-standard":"^10.2.1","eslint-friendly-formatter":"^2.0.7","eslint-loader":"^1.7.1","eslint-plugin-html":"^2.0.1","eslint-plugin-import":"^2.2.0","eslint-plugin-node":"^4.2.2","eslint-plugin-promise":"^3.5.0","eslint-plugin-standard":"^3.0.1","eventsource-polyfill":"^0.9.6",express:"^4.15.2","extract-text-webpack-plugin":"^1.0.1","file-loader":"^0.10.1","function-bind":"^1.0.2","html-webpack-plugin":"^2.28.0","http-proxy-middleware":"^0.17.4","inject-loader":"^3.0.0","isparta-loader":"^2.0.0","jasmine-core":"^2.5.2","json-loader":"^0.5.4",karma:"^1.5.0","karma-coverage":"^1.1.1","karma-jasmine":"^1.0.2","karma-mocha":"^1.2.0","karma-phantomjs-launcher":"^1.0.4","karma-sinon-chai":"^1.2.0","karma-sourcemap-loader":"^0.3.7","karma-spec-reporter":"0.0.30","karma-webpack":"1.8.1",lolex:"^1.6.0",mocha:"^3.1.0",nightwatch:"^0.9.14",ora:"^1.2.0","phantomjs-prebuilt":"^2.1.13","selenium-server":"^3.3.1",shelljs:"^0.7.7",sinon:"^2.1.0","sinon-chai":"^2.9.0","url-loader":"^0.5.8",vue:"^2.4.4","vue-hot-reload-api":"^2.1.0","vue-html-loader":"^1.2.4","vue-loader":"^12.2.2","vue-style-loader":"^3.0.1","vue-template-compiler":"^2.4.2",webpack:"^1.13.2","webpack-dev-middleware":"^1.10.1","webpack-hot-middleware":"^2.17.1","webpack-merge":"1.1.1"},engines:{node:">=6.9.0"},babel:{presets:["es2015"]},browserify:{transform:["babelify"]},greenkeeper:{ignore:["extract-text-webpack-plugin","karma-webpack","webpack","webpack-merge"]}}},function(e,t,n){(function(e,n){function a(e,t){return e.set(t[0],t[1]),e}function r(e,t){return e.add(t),e}function i(e,t,n){switch(n.length){case 0:return e.call(t);case 1:return e.call(t,n[0]);case 2:return e.call(t,n[0],n[1]);case 3:return e.call(t,n[0],n[1],n[2])}return e.apply(t,n)}function o(e,t){for(var n=-1,a=e?e.length:0;++n<a&&t(e[n],n,e)!==!1;);return e}function s(e,t){for(var n=-1,a=t.length,r=e.length;++n<a;)e[r+n]=t[n];return e}function d(e,t,n,a){var r=-1,i=e?e.length:0;for(a&&i&&(n=e[++r]);++r<i;)n=t(n,e[r],r,e);return n}function u(e,t){for(var n=-1,a=Array(e);++n<e;)a[n]=t(n);return a}function l(e){return function(t){return e(t)}}function c(e,t){return null==e?void 0:e[t]}function h(e){var t=!1;if(null!=e&&"function"!=typeof e.toString)try{t=!!(e+"")}catch(e){}return t}function _(e){var t=-1,n=Array(e.size);return e.forEach(function(e,a){n[++t]=[a,e]}),n}function m(e,t){return function(n){return e(t(n))}}function f(e){var t=-1,n=Array(e.size);return e.forEach(function(e){n[++t]=e}),n}function p(e){var t=-1,n=e?e.length:0;for(this.clear();++t<n;){var a=e[t];this.set(a[0],a[1])}}function y(){this.__data__=rn?rn(null):{}}function g(e){return this.has(e)&&delete this.__data__[e]}function v(e){var t=this.__data__;if(rn){var n=t[e];return n===Re?void 0:n}return Wt.call(t,e)?t[e]:void 0}function M(e){var t=this.__data__;return rn?void 0!==t[e]:Wt.call(t,e)}function L(e,t){var n=this.__data__;return n[e]=rn&&void 0===t?Re:t,this}function b(e){var t=-1,n=e?e.length:0;for(this.clear();++t<n;){var a=e[t];this.set(a[0],a[1])}}function k(){this.__data__=[]}function Y(e){var t=this.__data__,n=V(t,e);if(n<0)return!1;var a=t.length-1;return n==a?t.pop():Gt.call(t,n,1),!0}function D(e){var t=this.__data__,n=V(t,e);return n<0?void 0:t[n][1]}function w(e){return V(this.__data__,e)>-1}function x(e,t){var n=this.__data__,a=V(n,e);return a<0?n.push([e,t]):n[a][1]=t,this}function T(e){var t=-1,n=e?e.length:0;for(this.clear();++t<n;){var a=e[t];this.set(a[0],a[1])}}function S(){this.__data__={hash:new p,map:new(en||b),string:new p}}function j(e){return fe(this,e).delete(e)}function H(e){return fe(this,e).get(e)}function O(e){return fe(this,e).has(e)}function P(e,t){return fe(this,e).set(e,t),this}function A(e){this.__data__=new b(e)}function C(){this.__data__=new b}function E(e){return this.__data__.delete(e)}function F(e){return this.__data__.get(e)}function W(e){return this.__data__.has(e)}function I(e,t){var n=this.__data__;if(n instanceof b){var a=n.__data__;if(!en||a.length<ze-1)return a.push([e,t]),this;n=this.__data__=new T(a)}return n.set(e,t),this}function N(e,t){var n=fn(e)||Te(e)?u(e.length,String):[],a=n.length,r=!!a;for(var i in e)!t&&!Wt.call(e,i)||r&&("length"==i||Me(i,a))||n.push(i);return n}function z(e,t,n){(void 0===n||xe(e[t],n))&&("number"!=typeof t||void 0!==n||t in e)||(e[t]=n)}function R(e,t,n){var a=e[t];Wt.call(e,t)&&xe(a,n)&&(void 0!==n||t in e)||(e[t]=n)}function V(e,t){for(var n=e.length;n--;)if(xe(e[n][0],t))return n;return-1}function B(e,t){return e&&ce(t,Fe(t),e)}function $(e,t,n,a,r,i,s){var d;if(a&&(d=i?a(e,r,i,s):a(e)),void 0!==d)return d;if(!Pe(e))return e;var u=fn(e);if(u){if(d=ye(e),!t)return le(e,d)}else{var l=mn(e),c=l==qe||l==Ke;if(pn(e))return ne(e,t);if(l==Xe||l==Be||c&&!i){if(h(e))return i?e:{};if(d=ge(c?{}:e),!t)return he(e,B(d,e))}else{if(!bt[l])return i?e:{};d=ve(e,l,$,t)}}s||(s=new A);var _=s.get(e);if(_)return _;if(s.set(e,d),!u)var m=n?me(e):Fe(e);return o(m||e,function(r,i){m&&(i=r,r=e[i]),R(d,i,$(r,t,n,a,i,e,s))}),d}function J(e){return Pe(e)?Jt(e):{}}function U(e,t,n){var a=t(e);return fn(e)?a:s(a,n(e))}function G(e){return Nt.call(e)}function q(e){if(!Pe(e)||ke(e))return!1;var t=He(e)||h(e)?zt:vt;return t.test(we(e))}function K(e){return Ae(e)&&Oe(e.length)&&!!Lt[Nt.call(e)]}function Z(e){if(!Ye(e))return Zt(e);var t=[];for(var n in Object(e))Wt.call(e,n)&&"constructor"!=n&&t.push(n);return t}function Q(e){if(!Pe(e))return De(e);var t=Ye(e),n=[];for(var a in e)("constructor"!=a||!t&&Wt.call(e,a))&&n.push(a);return n}function X(e,t,n,a,r){if(e!==t){if(!fn(t)&&!yn(t))var i=Q(t);o(i||t,function(o,s){if(i&&(s=o,o=t[s]),Pe(o))r||(r=new A),ee(e,t,s,n,X,a,r);else{var d=a?a(e[s],o,s+"",e,t,r):void 0;void 0===d&&(d=o),z(e,s,d)}})}}function ee(e,t,n,a,r,i,o){var s=e[n],d=t[n],u=o.get(d);if(u)return void z(e,n,u);var l=i?i(s,d,n+"",e,t,o):void 0,c=void 0===l;c&&(l=d,fn(d)||yn(d)?fn(s)?l=s:je(s)?l=le(s):(c=!1,l=$(d,!0)):Ce(d)||Te(d)?Te(s)?l=Ee(s):!Pe(s)||a&&He(s)?(c=!1,l=$(d,!0)):l=s:c=!1),c&&(o.set(d,l),r(l,d,a,i,o),o.delete(d)),z(e,n,l)}function te(e,t){return t=Qt(void 0===t?e.length-1:t,0),function(){for(var n=arguments,a=-1,r=Qt(n.length-t,0),o=Array(r);++a<r;)o[a]=n[t+a];a=-1;for(var s=Array(t+1);++a<t;)s[a]=n[a];return s[t]=o,i(e,this,s)}}function ne(e,t){if(t)return e.slice();var n=new e.constructor(e.length);return e.copy(n),n}function ae(e){var t=new e.constructor(e.byteLength);return new Bt(t).set(new Bt(e)),t}function re(e,t){var n=t?ae(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.byteLength)}function ie(e,t,n){var r=t?n(_(e),!0):_(e);return d(r,a,new e.constructor)}function oe(e){var t=new e.constructor(e.source,gt.exec(e));return t.lastIndex=e.lastIndex,t}function se(e,t,n){var a=t?n(f(e),!0):f(e);return d(a,r,new e.constructor)}function de(e){return hn?Object(hn.call(e)):{}}function ue(e,t){var n=t?ae(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.length)}function le(e,t){var n=-1,a=e.length;for(t||(t=Array(a));++n<a;)t[n]=e[n];
+return t}function ce(e,t,n,a){n||(n={});for(var r=-1,i=t.length;++r<i;){var o=t[r],s=a?a(n[o],e[o],o,n,e):void 0;R(n,o,void 0===s?e[o]:s)}return n}function he(e,t){return ce(e,_n(e),t)}function _e(e){return te(function(t,n){var a=-1,r=n.length,i=r>1?n[r-1]:void 0,o=r>2?n[2]:void 0;for(i=e.length>3&&"function"==typeof i?(r--,i):void 0,o&&Le(n[0],n[1],o)&&(i=r<3?void 0:i,r=1),t=Object(t);++a<r;){var s=n[a];s&&e(t,s,a,i)}return t})}function me(e){return U(e,Fe,_n)}function fe(e,t){var n=e.__data__;return be(t)?n["string"==typeof t?"string":"hash"]:n.map}function pe(e,t){var n=c(e,t);return q(n)?n:void 0}function ye(e){var t=e.length,n=e.constructor(t);return t&&"string"==typeof e[0]&&Wt.call(e,"index")&&(n.index=e.index,n.input=e.input),n}function ge(e){return"function"!=typeof e.constructor||Ye(e)?{}:J($t(e))}function ve(e,t,n,a){var r=e.constructor;switch(t){case ot:return ae(e);case Je:case Ue:return new r(+e);case st:return re(e,a);case dt:case ut:case lt:case ct:case ht:case _t:case mt:case ft:case pt:return ue(e,a);case Ze:return ie(e,a,n);case Qe:case at:return new r(e);case tt:return oe(e);case nt:return se(e,a,n);case rt:return de(e)}}function Me(e,t){return t=null==t?Ve:t,!!t&&("number"==typeof e||Mt.test(e))&&e>-1&&e%1==0&&e<t}function Le(e,t,n){if(!Pe(n))return!1;var a=typeof t;return!!("number"==a?Se(n)&&Me(t,n.length):"string"==a&&t in n)&&xe(n[t],e)}function be(e){var t=typeof e;return"string"==t||"number"==t||"symbol"==t||"boolean"==t?"__proto__"!==e:null===e}function ke(e){return!!Et&&Et in e}function Ye(e){var t=e&&e.constructor,n="function"==typeof t&&t.prototype||At;return e===n}function De(e){var t=[];if(null!=e)for(var n in Object(e))t.push(n);return t}function we(e){if(null!=e){try{return Ft.call(e)}catch(e){}try{return e+""}catch(e){}}return""}function xe(e,t){return e===t||e!==e&&t!==t}function Te(e){return je(e)&&Wt.call(e,"callee")&&(!Ut.call(e,"callee")||Nt.call(e)==Be)}function Se(e){return null!=e&&Oe(e.length)&&!He(e)}function je(e){return Ae(e)&&Se(e)}function He(e){var t=Pe(e)?Nt.call(e):"";return t==qe||t==Ke}function Oe(e){return"number"==typeof e&&e>-1&&e%1==0&&e<=Ve}function Pe(e){var t=typeof e;return!!e&&("object"==t||"function"==t)}function Ae(e){return!!e&&"object"==typeof e}function Ce(e){if(!Ae(e)||Nt.call(e)!=Xe||h(e))return!1;var t=$t(e);if(null===t)return!0;var n=Wt.call(t,"constructor")&&t.constructor;return"function"==typeof n&&n instanceof n&&Ft.call(n)==It}function Ee(e){return ce(e,We(e))}function Fe(e){return Se(e)?N(e):Z(e)}function We(e){return Se(e)?N(e,!0):Q(e)}function Ie(){return[]}function Ne(){return!1}var ze=200,Re="__lodash_hash_undefined__",Ve=9007199254740991,Be="[object Arguments]",$e="[object Array]",Je="[object Boolean]",Ue="[object Date]",Ge="[object Error]",qe="[object Function]",Ke="[object GeneratorFunction]",Ze="[object Map]",Qe="[object Number]",Xe="[object Object]",et="[object Promise]",tt="[object RegExp]",nt="[object Set]",at="[object String]",rt="[object Symbol]",it="[object WeakMap]",ot="[object ArrayBuffer]",st="[object DataView]",dt="[object Float32Array]",ut="[object Float64Array]",lt="[object Int8Array]",ct="[object Int16Array]",ht="[object Int32Array]",_t="[object Uint8Array]",mt="[object Uint8ClampedArray]",ft="[object Uint16Array]",pt="[object Uint32Array]",yt=/[\\^$.*+?()[\]{}|]/g,gt=/\w*$/,vt=/^\[object .+?Constructor\]$/,Mt=/^(?:0|[1-9]\d*)$/,Lt={};Lt[dt]=Lt[ut]=Lt[lt]=Lt[ct]=Lt[ht]=Lt[_t]=Lt[mt]=Lt[ft]=Lt[pt]=!0,Lt[Be]=Lt[$e]=Lt[ot]=Lt[Je]=Lt[st]=Lt[Ue]=Lt[Ge]=Lt[qe]=Lt[Ze]=Lt[Qe]=Lt[Xe]=Lt[tt]=Lt[nt]=Lt[at]=Lt[it]=!1;var bt={};bt[Be]=bt[$e]=bt[ot]=bt[st]=bt[Je]=bt[Ue]=bt[dt]=bt[ut]=bt[lt]=bt[ct]=bt[ht]=bt[Ze]=bt[Qe]=bt[Xe]=bt[tt]=bt[nt]=bt[at]=bt[rt]=bt[_t]=bt[mt]=bt[ft]=bt[pt]=!0,bt[Ge]=bt[qe]=bt[it]=!1;var kt="object"==typeof e&&e&&e.Object===Object&&e,Yt="object"==typeof self&&self&&self.Object===Object&&self,Dt=kt||Yt||Function("return this")(),wt="object"==typeof t&&t&&!t.nodeType&&t,xt=wt&&"object"==typeof n&&n&&!n.nodeType&&n,Tt=xt&&xt.exports===wt,St=Tt&&kt.process,jt=function(){try{return St&&St.binding("util")}catch(e){}}(),Ht=jt&&jt.isTypedArray,Ot=Array.prototype,Pt=Function.prototype,At=Object.prototype,Ct=Dt["__core-js_shared__"],Et=function(){var e=/[^.]+$/.exec(Ct&&Ct.keys&&Ct.keys.IE_PROTO||"");return e?"Symbol(src)_1."+e:""}(),Ft=Pt.toString,Wt=At.hasOwnProperty,It=Ft.call(Object),Nt=At.toString,zt=RegExp("^"+Ft.call(Wt).replace(yt,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),Rt=Tt?Dt.Buffer:void 0,Vt=Dt.Symbol,Bt=Dt.Uint8Array,$t=m(Object.getPrototypeOf,Object),Jt=Object.create,Ut=At.propertyIsEnumerable,Gt=Ot.splice,qt=Object.getOwnPropertySymbols,Kt=Rt?Rt.isBuffer:void 0,Zt=m(Object.keys,Object),Qt=Math.max,Xt=pe(Dt,"DataView"),en=pe(Dt,"Map"),tn=pe(Dt,"Promise"),nn=pe(Dt,"Set"),an=pe(Dt,"WeakMap"),rn=pe(Object,"create"),on=we(Xt),sn=we(en),dn=we(tn),un=we(nn),ln=we(an),cn=Vt?Vt.prototype:void 0,hn=cn?cn.valueOf:void 0;p.prototype.clear=y,p.prototype.delete=g,p.prototype.get=v,p.prototype.has=M,p.prototype.set=L,b.prototype.clear=k,b.prototype.delete=Y,b.prototype.get=D,b.prototype.has=w,b.prototype.set=x,T.prototype.clear=S,T.prototype.delete=j,T.prototype.get=H,T.prototype.has=O,T.prototype.set=P,A.prototype.clear=C,A.prototype.delete=E,A.prototype.get=F,A.prototype.has=W,A.prototype.set=I;var _n=qt?m(qt,Object):Ie,mn=G;(Xt&&mn(new Xt(new ArrayBuffer(1)))!=st||en&&mn(new en)!=Ze||tn&&mn(tn.resolve())!=et||nn&&mn(new nn)!=nt||an&&mn(new an)!=it)&&(mn=function(e){var t=Nt.call(e),n=t==Xe?e.constructor:void 0,a=n?we(n):void 0;if(a)switch(a){case on:return st;case sn:return Ze;case dn:return et;case un:return nt;case ln:return it}return t});var fn=Array.isArray,pn=Kt||Ne,yn=Ht?l(Ht):K,gn=_e(function(e,t,n){X(e,t,n)});n.exports=gn}).call(t,function(){return this}(),n(139)(e))},function(e,t,n){function a(e){return n(r(e))}function r(e){return i[e]||function(){throw new Error("Cannot find module '"+e+"'.")}()}var i={"./af":24,"./af.js":24,"./ar":31,"./ar-dz":25,"./ar-dz.js":25,"./ar-kw":26,"./ar-kw.js":26,"./ar-ly":27,"./ar-ly.js":27,"./ar-ma":28,"./ar-ma.js":28,"./ar-sa":29,"./ar-sa.js":29,"./ar-tn":30,"./ar-tn.js":30,"./ar.js":31,"./az":32,"./az.js":32,"./be":33,"./be.js":33,"./bg":34,"./bg.js":34,"./bn":35,"./bn.js":35,"./bo":36,"./bo.js":36,"./br":37,"./br.js":37,"./bs":38,"./bs.js":38,"./ca":39,"./ca.js":39,"./cs":40,"./cs.js":40,"./cv":41,"./cv.js":41,"./cy":42,"./cy.js":42,"./da":43,"./da.js":43,"./de":46,"./de-at":44,"./de-at.js":44,"./de-ch":45,"./de-ch.js":45,"./de.js":46,"./dv":47,"./dv.js":47,"./el":48,"./el.js":48,"./en-au":49,"./en-au.js":49,"./en-ca":50,"./en-ca.js":50,"./en-gb":51,"./en-gb.js":51,"./en-ie":52,"./en-ie.js":52,"./en-nz":53,"./en-nz.js":53,"./eo":54,"./eo.js":54,"./es":56,"./es-do":55,"./es-do.js":55,"./es.js":56,"./et":57,"./et.js":57,"./eu":58,"./eu.js":58,"./fa":59,"./fa.js":59,"./fi":60,"./fi.js":60,"./fo":61,"./fo.js":61,"./fr":64,"./fr-ca":62,"./fr-ca.js":62,"./fr-ch":63,"./fr-ch.js":63,"./fr.js":64,"./fy":65,"./fy.js":65,"./gd":66,"./gd.js":66,"./gl":67,"./gl.js":67,"./gom-latn":68,"./gom-latn.js":68,"./he":69,"./he.js":69,"./hi":70,"./hi.js":70,"./hr":71,"./hr.js":71,"./hu":72,"./hu.js":72,"./hy-am":73,"./hy-am.js":73,"./id":74,"./id.js":74,"./is":75,"./is.js":75,"./it":76,"./it.js":76,"./ja":77,"./ja.js":77,"./jv":78,"./jv.js":78,"./ka":79,"./ka.js":79,"./kk":80,"./kk.js":80,"./km":81,"./km.js":81,"./kn":82,"./kn.js":82,"./ko":83,"./ko.js":83,"./ky":84,"./ky.js":84,"./lb":85,"./lb.js":85,"./lo":86,"./lo.js":86,"./lt":87,"./lt.js":87,"./lv":88,"./lv.js":88,"./me":89,"./me.js":89,"./mi":90,"./mi.js":90,"./mk":91,"./mk.js":91,"./ml":92,"./ml.js":92,"./mr":93,"./mr.js":93,"./ms":95,"./ms-my":94,"./ms-my.js":94,"./ms.js":95,"./my":96,"./my.js":96,"./nb":97,"./nb.js":97,"./ne":98,"./ne.js":98,"./nl":100,"./nl-be":99,"./nl-be.js":99,"./nl.js":100,"./nn":101,"./nn.js":101,"./pa-in":102,"./pa-in.js":102,"./pl":103,"./pl.js":103,"./pt":105,"./pt-br":104,"./pt-br.js":104,"./pt.js":105,"./ro":106,"./ro.js":106,"./ru":107,"./ru.js":107,"./sd":108,"./sd.js":108,"./se":109,"./se.js":109,"./si":110,"./si.js":110,"./sk":111,"./sk.js":111,"./sl":112,"./sl.js":112,"./sq":113,"./sq.js":113,"./sr":115,"./sr-cyrl":114,"./sr-cyrl.js":114,"./sr.js":115,"./ss":116,"./ss.js":116,"./sv":117,"./sv.js":117,"./sw":118,"./sw.js":118,"./ta":119,"./ta.js":119,"./te":120,"./te.js":120,"./tet":121,"./tet.js":121,"./th":122,"./th.js":122,"./tl-ph":123,"./tl-ph.js":123,"./tlh":124,"./tlh.js":124,"./tr":125,"./tr.js":125,"./tzl":126,"./tzl.js":126,"./tzm":128,"./tzm-latn":127,"./tzm-latn.js":127,"./tzm.js":128,"./uk":129,"./uk.js":129,"./ur":130,"./ur.js":130,"./uz":132,"./uz-latn":131,"./uz-latn.js":131,"./uz.js":132,"./vi":133,"./vi.js":133,"./x-pseudo":134,"./x-pseudo.js":134,"./yo":135,"./yo.js":135,"./zh-cn":136,"./zh-cn.js":136,"./zh-hk":137,"./zh-hk.js":137,"./zh-tw":138,"./zh-tw.js":138};a.keys=function(){return Object.keys(i)},a.resolve=r,e.exports=a,a.id=227},function(e,t){function n(){throw new Error("setTimeout has not been defined")}function a(){throw new Error("clearTimeout has not been defined")}function r(e){if(l===setTimeout)return setTimeout(e,0);if((l===n||!l)&&setTimeout)return l=setTimeout,setTimeout(e,0);try{return l(e,0)}catch(t){try{return l.call(null,e,0)}catch(t){return l.call(this,e,0)}}}function i(e){if(c===clearTimeout)return clearTimeout(e);if((c===a||!c)&&clearTimeout)return c=clearTimeout,clearTimeout(e);try{return c(e)}catch(t){try{return c.call(null,e)}catch(t){return c.call(this,e)}}}function o(){f&&_&&(f=!1,_.length?m=_.concat(m):p=-1,m.length&&s())}function s(){if(!f){var e=r(o);f=!0;for(var t=m.length;t;){for(_=m,m=[];++p<t;)_&&_[p].run();p=-1,t=m.length}_=null,f=!1,i(e)}}function d(e,t){this.fun=e,this.array=t}function u(){}var l,c,h=e.exports={};!function(){try{l="function"==typeof setTimeout?setTimeout:n}catch(e){l=n}try{c="function"==typeof clearTimeout?clearTimeout:a}catch(e){c=a}}();var _,m=[],f=!1,p=-1;h.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)t[n-1]=arguments[n];m.push(new d(e,t)),1!==m.length||f||r(s)},d.prototype.run=function(){this.fun.apply(null,this.array)},h.title="browser",h.browser=!0,h.env={},h.argv=[],h.version="",h.versions={},h.on=u,h.addListener=u,h.once=u,h.off=u,h.removeListener=u,h.removeAllListeners=u,h.emit=u,h.binding=function(e){throw new Error("process.binding is not supported")},h.cwd=function(){return"/"},h.chdir=function(e){throw new Error("process.chdir is not supported")},h.umask=function(){return 0}}])});
\ No newline at end of file
diff --git a/dist/vue-chartjs.js b/dist/vue-chartjs.js
new file mode 100644
index 00000000..1370ab2d
--- /dev/null
+++ b/dist/vue-chartjs.js
@@ -0,0 +1,4119 @@
+/*!
+ * vue-chartjs v2.8.7
+ * (c) 2017 Jakub Juszczak <jakub@posteo.de>
+ * http://vue-chartjs.org
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("vue"), require("chart.js"));
+	else if(typeof define === 'function' && define.amd)
+		define("VueChartJs", ["vue", "chart.js"], factory);
+	else if(typeof exports === 'object')
+		exports["VueChartJs"] = factory(require("vue"), require("chart.js"));
+	else
+		root["VueChartJs"] = factory(root["vue"], root["chart.js"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_3__) {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.mixins = exports.Scatter = exports.Bubble = exports.Radar = exports.PolarArea = exports.Pie = exports.Line = exports.Doughnut = exports.HorizontalBar = exports.Bar = exports.VueCharts = undefined;
+
+	var _Bar = __webpack_require__(1);
+
+	var _Bar2 = _interopRequireDefault(_Bar);
+
+	var _HorizontalBar = __webpack_require__(7);
+
+	var _HorizontalBar2 = _interopRequireDefault(_HorizontalBar);
+
+	var _Doughnut = __webpack_require__(8);
+
+	var _Doughnut2 = _interopRequireDefault(_Doughnut);
+
+	var _Line = __webpack_require__(9);
+
+	var _Line2 = _interopRequireDefault(_Line);
+
+	var _Pie = __webpack_require__(10);
+
+	var _Pie2 = _interopRequireDefault(_Pie);
+
+	var _PolarArea = __webpack_require__(11);
+
+	var _PolarArea2 = _interopRequireDefault(_PolarArea);
+
+	var _Radar = __webpack_require__(12);
+
+	var _Radar2 = _interopRequireDefault(_Radar);
+
+	var _Bubble = __webpack_require__(13);
+
+	var _Bubble2 = _interopRequireDefault(_Bubble);
+
+	var _Scatter = __webpack_require__(14);
+
+	var _Scatter2 = _interopRequireDefault(_Scatter);
+
+	var _index = __webpack_require__(15);
+
+	var _index2 = _interopRequireDefault(_index);
+
+	var _package = __webpack_require__(55);
+
+	var _package2 = _interopRequireDefault(_package);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	var VueCharts = {
+	  version: _package2.default.version,
+	  Bar: _Bar2.default,
+	  HorizontalBar: _HorizontalBar2.default,
+	  Doughnut: _Doughnut2.default,
+	  Line: _Line2.default,
+	  Pie: _Pie2.default,
+	  PolarArea: _PolarArea2.default,
+	  Radar: _Radar2.default,
+	  Bubble: _Bubble2.default,
+	  Scatter: _Scatter2.default,
+	  mixins: _index2.default
+	};
+
+	exports.default = VueCharts;
+	exports.VueCharts = VueCharts;
+	exports.Bar = _Bar2.default;
+	exports.HorizontalBar = _HorizontalBar2.default;
+	exports.Doughnut = _Doughnut2.default;
+	exports.Line = _Line2.default;
+	exports.Pie = _Pie2.default;
+	exports.PolarArea = _PolarArea2.default;
+	exports.Radar = _Radar2.default;
+	exports.Bubble = _Bubble2.default;
+	exports.Scatter = _Scatter2.default;
+	exports.mixins = _index2.default;
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+	  props: {
+	    chartId: {
+	      default: 'bar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            },
+	            categoryPercentage: 0.5,
+	            barPercentage: 0.2
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'bar',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 2 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_2__;
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_3__;
+
+/***/ },
+/* 4 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.mergeOptions = mergeOptions;
+
+	var _lodash = __webpack_require__(5);
+
+	var _lodash2 = _interopRequireDefault(_lodash);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function mergeOptions(obj, src) {
+	  return (0, _lodash2.default)(obj, src);
+	}
+
+/***/ },
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(global, module) {/**
+	 * lodash (Custom Build) <https://lodash.com/>
+	 * Build: `lodash modularize exports="npm" -o ./`
+	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	 * Released under MIT license <https://lodash.com/license>
+	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	 */
+
+	/** Used as the size to enable large array optimizations. */
+	var LARGE_ARRAY_SIZE = 200;
+
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER = 9007199254740991;
+
+	/** `Object#toString` result references. */
+	var argsTag = '[object Arguments]',
+	    arrayTag = '[object Array]',
+	    boolTag = '[object Boolean]',
+	    dateTag = '[object Date]',
+	    errorTag = '[object Error]',
+	    funcTag = '[object Function]',
+	    genTag = '[object GeneratorFunction]',
+	    mapTag = '[object Map]',
+	    numberTag = '[object Number]',
+	    objectTag = '[object Object]',
+	    promiseTag = '[object Promise]',
+	    regexpTag = '[object RegExp]',
+	    setTag = '[object Set]',
+	    stringTag = '[object String]',
+	    symbolTag = '[object Symbol]',
+	    weakMapTag = '[object WeakMap]';
+
+	var arrayBufferTag = '[object ArrayBuffer]',
+	    dataViewTag = '[object DataView]',
+	    float32Tag = '[object Float32Array]',
+	    float64Tag = '[object Float64Array]',
+	    int8Tag = '[object Int8Array]',
+	    int16Tag = '[object Int16Array]',
+	    int32Tag = '[object Int32Array]',
+	    uint8Tag = '[object Uint8Array]',
+	    uint8ClampedTag = '[object Uint8ClampedArray]',
+	    uint16Tag = '[object Uint16Array]',
+	    uint32Tag = '[object Uint32Array]';
+
+	/**
+	 * Used to match `RegExp`
+	 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	 */
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+	/** Used to match `RegExp` flags from their coerced string values. */
+	var reFlags = /\w*$/;
+
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+	/** Used to detect unsigned integer values. */
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+	/** Used to identify `toStringTag` values of typed arrays. */
+	var typedArrayTags = {};
+	typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+	typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+	typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+	typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+	typedArrayTags[uint32Tag] = true;
+	typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+	typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+	typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+	typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+	typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+	typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+	typedArrayTags[setTag] = typedArrayTags[stringTag] =
+	typedArrayTags[weakMapTag] = false;
+
+	/** Used to identify `toStringTag` values supported by `_.clone`. */
+	var cloneableTags = {};
+	cloneableTags[argsTag] = cloneableTags[arrayTag] =
+	cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+	cloneableTags[boolTag] = cloneableTags[dateTag] =
+	cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+	cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+	cloneableTags[int32Tag] = cloneableTags[mapTag] =
+	cloneableTags[numberTag] = cloneableTags[objectTag] =
+	cloneableTags[regexpTag] = cloneableTags[setTag] =
+	cloneableTags[stringTag] = cloneableTags[symbolTag] =
+	cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+	cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+	cloneableTags[errorTag] = cloneableTags[funcTag] =
+	cloneableTags[weakMapTag] = false;
+
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function('return this')();
+
+	/** Detect free variable `exports`. */
+	var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+	/** Detect free variable `module`. */
+	var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+	/** Detect the popular CommonJS extension `module.exports`. */
+	var moduleExports = freeModule && freeModule.exports === freeExports;
+
+	/** Detect free variable `process` from Node.js. */
+	var freeProcess = moduleExports && freeGlobal.process;
+
+	/** Used to access faster Node.js helpers. */
+	var nodeUtil = (function() {
+	  try {
+	    return freeProcess && freeProcess.binding('util');
+	  } catch (e) {}
+	}());
+
+	/* Node.js helper references. */
+	var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+	/**
+	 * Adds the key-value `pair` to `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to modify.
+	 * @param {Array} pair The key-value pair to add.
+	 * @returns {Object} Returns `map`.
+	 */
+	function addMapEntry(map, pair) {
+	  // Don't return `map.set` because it's not chainable in IE 11.
+	  map.set(pair[0], pair[1]);
+	  return map;
+	}
+
+	/**
+	 * Adds `value` to `set`.
+	 *
+	 * @private
+	 * @param {Object} set The set to modify.
+	 * @param {*} value The value to add.
+	 * @returns {Object} Returns `set`.
+	 */
+	function addSetEntry(set, value) {
+	  // Don't return `set.add` because it's not chainable in IE 11.
+	  set.add(value);
+	  return set;
+	}
+
+	/**
+	 * A faster alternative to `Function#apply`, this function invokes `func`
+	 * with the `this` binding of `thisArg` and the arguments of `args`.
+	 *
+	 * @private
+	 * @param {Function} func The function to invoke.
+	 * @param {*} thisArg The `this` binding of `func`.
+	 * @param {Array} args The arguments to invoke `func` with.
+	 * @returns {*} Returns the result of `func`.
+	 */
+	function apply(func, thisArg, args) {
+	  switch (args.length) {
+	    case 0: return func.call(thisArg);
+	    case 1: return func.call(thisArg, args[0]);
+	    case 2: return func.call(thisArg, args[0], args[1]);
+	    case 3: return func.call(thisArg, args[0], args[1], args[2]);
+	  }
+	  return func.apply(thisArg, args);
+	}
+
+	/**
+	 * A specialized version of `_.forEach` for arrays without support for
+	 * iteratee shorthands.
+	 *
+	 * @private
+	 * @param {Array} [array] The array to iterate over.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @returns {Array} Returns `array`.
+	 */
+	function arrayEach(array, iteratee) {
+	  var index = -1,
+	      length = array ? array.length : 0;
+
+	  while (++index < length) {
+	    if (iteratee(array[index], index, array) === false) {
+	      break;
+	    }
+	  }
+	  return array;
+	}
+
+	/**
+	 * Appends the elements of `values` to `array`.
+	 *
+	 * @private
+	 * @param {Array} array The array to modify.
+	 * @param {Array} values The values to append.
+	 * @returns {Array} Returns `array`.
+	 */
+	function arrayPush(array, values) {
+	  var index = -1,
+	      length = values.length,
+	      offset = array.length;
+
+	  while (++index < length) {
+	    array[offset + index] = values[index];
+	  }
+	  return array;
+	}
+
+	/**
+	 * A specialized version of `_.reduce` for arrays without support for
+	 * iteratee shorthands.
+	 *
+	 * @private
+	 * @param {Array} [array] The array to iterate over.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @param {*} [accumulator] The initial value.
+	 * @param {boolean} [initAccum] Specify using the first element of `array` as
+	 *  the initial value.
+	 * @returns {*} Returns the accumulated value.
+	 */
+	function arrayReduce(array, iteratee, accumulator, initAccum) {
+	  var index = -1,
+	      length = array ? array.length : 0;
+
+	  if (initAccum && length) {
+	    accumulator = array[++index];
+	  }
+	  while (++index < length) {
+	    accumulator = iteratee(accumulator, array[index], index, array);
+	  }
+	  return accumulator;
+	}
+
+	/**
+	 * The base implementation of `_.times` without support for iteratee shorthands
+	 * or max array length checks.
+	 *
+	 * @private
+	 * @param {number} n The number of times to invoke `iteratee`.
+	 * @param {Function} iteratee The function invoked per iteration.
+	 * @returns {Array} Returns the array of results.
+	 */
+	function baseTimes(n, iteratee) {
+	  var index = -1,
+	      result = Array(n);
+
+	  while (++index < n) {
+	    result[index] = iteratee(index);
+	  }
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.unary` without support for storing metadata.
+	 *
+	 * @private
+	 * @param {Function} func The function to cap arguments for.
+	 * @returns {Function} Returns the new capped function.
+	 */
+	function baseUnary(func) {
+	  return function(value) {
+	    return func(value);
+	  };
+	}
+
+	/**
+	 * Gets the value at `key` of `object`.
+	 *
+	 * @private
+	 * @param {Object} [object] The object to query.
+	 * @param {string} key The key of the property to get.
+	 * @returns {*} Returns the property value.
+	 */
+	function getValue(object, key) {
+	  return object == null ? undefined : object[key];
+	}
+
+	/**
+	 * Checks if `value` is a host object in IE < 9.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+	 */
+	function isHostObject(value) {
+	  // Many host objects are `Object` objects that can coerce to strings
+	  // despite having improperly defined `toString` methods.
+	  var result = false;
+	  if (value != null && typeof value.toString != 'function') {
+	    try {
+	      result = !!(value + '');
+	    } catch (e) {}
+	  }
+	  return result;
+	}
+
+	/**
+	 * Converts `map` to its key-value pairs.
+	 *
+	 * @private
+	 * @param {Object} map The map to convert.
+	 * @returns {Array} Returns the key-value pairs.
+	 */
+	function mapToArray(map) {
+	  var index = -1,
+	      result = Array(map.size);
+
+	  map.forEach(function(value, key) {
+	    result[++index] = [key, value];
+	  });
+	  return result;
+	}
+
+	/**
+	 * Creates a unary function that invokes `func` with its argument transformed.
+	 *
+	 * @private
+	 * @param {Function} func The function to wrap.
+	 * @param {Function} transform The argument transform.
+	 * @returns {Function} Returns the new function.
+	 */
+	function overArg(func, transform) {
+	  return function(arg) {
+	    return func(transform(arg));
+	  };
+	}
+
+	/**
+	 * Converts `set` to an array of its values.
+	 *
+	 * @private
+	 * @param {Object} set The set to convert.
+	 * @returns {Array} Returns the values.
+	 */
+	function setToArray(set) {
+	  var index = -1,
+	      result = Array(set.size);
+
+	  set.forEach(function(value) {
+	    result[++index] = value;
+	  });
+	  return result;
+	}
+
+	/** Used for built-in method references. */
+	var arrayProto = Array.prototype,
+	    funcProto = Function.prototype,
+	    objectProto = Object.prototype;
+
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData = root['__core-js_shared__'];
+
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = (function() {
+	  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+	  return uid ? ('Symbol(src)_1.' + uid) : '';
+	}());
+
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/** Used to infer the `Object` constructor. */
+	var objectCtorString = funcToString.call(Object);
+
+	/**
+	 * Used to resolve the
+	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	 * of values.
+	 */
+	var objectToString = objectProto.toString;
+
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp('^' +
+	  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+	);
+
+	/** Built-in value references. */
+	var Buffer = moduleExports ? root.Buffer : undefined,
+	    Symbol = root.Symbol,
+	    Uint8Array = root.Uint8Array,
+	    getPrototype = overArg(Object.getPrototypeOf, Object),
+	    objectCreate = Object.create,
+	    propertyIsEnumerable = objectProto.propertyIsEnumerable,
+	    splice = arrayProto.splice;
+
+	/* Built-in method references for those with the same name as other `lodash` methods. */
+	var nativeGetSymbols = Object.getOwnPropertySymbols,
+	    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+	    nativeKeys = overArg(Object.keys, Object),
+	    nativeMax = Math.max;
+
+	/* Built-in method references that are verified to be native. */
+	var DataView = getNative(root, 'DataView'),
+	    Map = getNative(root, 'Map'),
+	    Promise = getNative(root, 'Promise'),
+	    Set = getNative(root, 'Set'),
+	    WeakMap = getNative(root, 'WeakMap'),
+	    nativeCreate = getNative(Object, 'create');
+
+	/** Used to detect maps, sets, and weakmaps. */
+	var dataViewCtorString = toSource(DataView),
+	    mapCtorString = toSource(Map),
+	    promiseCtorString = toSource(Promise),
+	    setCtorString = toSource(Set),
+	    weakMapCtorString = toSource(WeakMap);
+
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : undefined,
+	    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+	/**
+	 * Creates a hash object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function Hash(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the hash.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf Hash
+	 */
+	function hashClear() {
+	  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+	}
+
+	/**
+	 * Removes `key` and its value from the hash.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf Hash
+	 * @param {Object} hash The hash to modify.
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function hashDelete(key) {
+	  return this.has(key) && delete this.__data__[key];
+	}
+
+	/**
+	 * Gets the hash value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf Hash
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function hashGet(key) {
+	  var data = this.__data__;
+	  if (nativeCreate) {
+	    var result = data[key];
+	    return result === HASH_UNDEFINED ? undefined : result;
+	  }
+	  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+	}
+
+	/**
+	 * Checks if a hash value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf Hash
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function hashHas(key) {
+	  var data = this.__data__;
+	  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+	}
+
+	/**
+	 * Sets the hash `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf Hash
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the hash instance.
+	 */
+	function hashSet(key, value) {
+	  var data = this.__data__;
+	  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+	  return this;
+	}
+
+	// Add methods to `Hash`.
+	Hash.prototype.clear = hashClear;
+	Hash.prototype['delete'] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+
+	/**
+	 * Creates an list cache object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function ListCache(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the list cache.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf ListCache
+	 */
+	function listCacheClear() {
+	  this.__data__ = [];
+	}
+
+	/**
+	 * Removes `key` and its value from the list cache.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function listCacheDelete(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    return false;
+	  }
+	  var lastIndex = data.length - 1;
+	  if (index == lastIndex) {
+	    data.pop();
+	  } else {
+	    splice.call(data, index, 1);
+	  }
+	  return true;
+	}
+
+	/**
+	 * Gets the list cache value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function listCacheGet(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  return index < 0 ? undefined : data[index][1];
+	}
+
+	/**
+	 * Checks if a list cache value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf ListCache
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function listCacheHas(key) {
+	  return assocIndexOf(this.__data__, key) > -1;
+	}
+
+	/**
+	 * Sets the list cache `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf ListCache
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the list cache instance.
+	 */
+	function listCacheSet(key, value) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    data.push([key, value]);
+	  } else {
+	    data[index][1] = value;
+	  }
+	  return this;
+	}
+
+	// Add methods to `ListCache`.
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype['delete'] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+
+	/**
+	 * Creates a map cache object to store key-value pairs.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function MapCache(entries) {
+	  var index = -1,
+	      length = entries ? entries.length : 0;
+
+	  this.clear();
+	  while (++index < length) {
+	    var entry = entries[index];
+	    this.set(entry[0], entry[1]);
+	  }
+	}
+
+	/**
+	 * Removes all key-value entries from the map.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf MapCache
+	 */
+	function mapCacheClear() {
+	  this.__data__ = {
+	    'hash': new Hash,
+	    'map': new (Map || ListCache),
+	    'string': new Hash
+	  };
+	}
+
+	/**
+	 * Removes `key` and its value from the map.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function mapCacheDelete(key) {
+	  return getMapData(this, key)['delete'](key);
+	}
+
+	/**
+	 * Gets the map value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function mapCacheGet(key) {
+	  return getMapData(this, key).get(key);
+	}
+
+	/**
+	 * Checks if a map value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf MapCache
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function mapCacheHas(key) {
+	  return getMapData(this, key).has(key);
+	}
+
+	/**
+	 * Sets the map `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf MapCache
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the map cache instance.
+	 */
+	function mapCacheSet(key, value) {
+	  getMapData(this, key).set(key, value);
+	  return this;
+	}
+
+	// Add methods to `MapCache`.
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype['delete'] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+
+	/**
+	 * Creates a stack cache object to store key-value pairs.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	function Stack(entries) {
+	  this.__data__ = new ListCache(entries);
+	}
+
+	/**
+	 * Removes all key-value entries from the stack.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf Stack
+	 */
+	function stackClear() {
+	  this.__data__ = new ListCache;
+	}
+
+	/**
+	 * Removes `key` and its value from the stack.
+	 *
+	 * @private
+	 * @name delete
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to remove.
+	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	 */
+	function stackDelete(key) {
+	  return this.__data__['delete'](key);
+	}
+
+	/**
+	 * Gets the stack value for `key`.
+	 *
+	 * @private
+	 * @name get
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to get.
+	 * @returns {*} Returns the entry value.
+	 */
+	function stackGet(key) {
+	  return this.__data__.get(key);
+	}
+
+	/**
+	 * Checks if a stack value for `key` exists.
+	 *
+	 * @private
+	 * @name has
+	 * @memberOf Stack
+	 * @param {string} key The key of the entry to check.
+	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	 */
+	function stackHas(key) {
+	  return this.__data__.has(key);
+	}
+
+	/**
+	 * Sets the stack `key` to `value`.
+	 *
+	 * @private
+	 * @name set
+	 * @memberOf Stack
+	 * @param {string} key The key of the value to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns the stack cache instance.
+	 */
+	function stackSet(key, value) {
+	  var cache = this.__data__;
+	  if (cache instanceof ListCache) {
+	    var pairs = cache.__data__;
+	    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+	      pairs.push([key, value]);
+	      return this;
+	    }
+	    cache = this.__data__ = new MapCache(pairs);
+	  }
+	  cache.set(key, value);
+	  return this;
+	}
+
+	// Add methods to `Stack`.
+	Stack.prototype.clear = stackClear;
+	Stack.prototype['delete'] = stackDelete;
+	Stack.prototype.get = stackGet;
+	Stack.prototype.has = stackHas;
+	Stack.prototype.set = stackSet;
+
+	/**
+	 * Creates an array of the enumerable property names of the array-like `value`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @param {boolean} inherited Specify returning inherited property names.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function arrayLikeKeys(value, inherited) {
+	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+	  // Safari 9 makes `arguments.length` enumerable in strict mode.
+	  var result = (isArray(value) || isArguments(value))
+	    ? baseTimes(value.length, String)
+	    : [];
+
+	  var length = result.length,
+	      skipIndexes = !!length;
+
+	  for (var key in value) {
+	    if ((inherited || hasOwnProperty.call(value, key)) &&
+	        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * This function is like `assignValue` except that it doesn't assign
+	 * `undefined` values.
+	 *
+	 * @private
+	 * @param {Object} object The object to modify.
+	 * @param {string} key The key of the property to assign.
+	 * @param {*} value The value to assign.
+	 */
+	function assignMergeValue(object, key, value) {
+	  if ((value !== undefined && !eq(object[key], value)) ||
+	      (typeof key == 'number' && value === undefined && !(key in object))) {
+	    object[key] = value;
+	  }
+	}
+
+	/**
+	 * Assigns `value` to `key` of `object` if the existing value is not equivalent
+	 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	 * for equality comparisons.
+	 *
+	 * @private
+	 * @param {Object} object The object to modify.
+	 * @param {string} key The key of the property to assign.
+	 * @param {*} value The value to assign.
+	 */
+	function assignValue(object, key, value) {
+	  var objValue = object[key];
+	  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+	      (value === undefined && !(key in object))) {
+	    object[key] = value;
+	  }
+	}
+
+	/**
+	 * Gets the index at which the `key` is found in `array` of key-value pairs.
+	 *
+	 * @private
+	 * @param {Array} array The array to inspect.
+	 * @param {*} key The key to search for.
+	 * @returns {number} Returns the index of the matched value, else `-1`.
+	 */
+	function assocIndexOf(array, key) {
+	  var length = array.length;
+	  while (length--) {
+	    if (eq(array[length][0], key)) {
+	      return length;
+	    }
+	  }
+	  return -1;
+	}
+
+	/**
+	 * The base implementation of `_.assign` without support for multiple sources
+	 * or `customizer` functions.
+	 *
+	 * @private
+	 * @param {Object} object The destination object.
+	 * @param {Object} source The source object.
+	 * @returns {Object} Returns `object`.
+	 */
+	function baseAssign(object, source) {
+	  return object && copyObject(source, keys(source), object);
+	}
+
+	/**
+	 * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+	 * traversed objects.
+	 *
+	 * @private
+	 * @param {*} value The value to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @param {boolean} [isFull] Specify a clone including symbols.
+	 * @param {Function} [customizer] The function to customize cloning.
+	 * @param {string} [key] The key of `value`.
+	 * @param {Object} [object] The parent object of `value`.
+	 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+	 * @returns {*} Returns the cloned value.
+	 */
+	function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
+	  var result;
+	  if (customizer) {
+	    result = object ? customizer(value, key, object, stack) : customizer(value);
+	  }
+	  if (result !== undefined) {
+	    return result;
+	  }
+	  if (!isObject(value)) {
+	    return value;
+	  }
+	  var isArr = isArray(value);
+	  if (isArr) {
+	    result = initCloneArray(value);
+	    if (!isDeep) {
+	      return copyArray(value, result);
+	    }
+	  } else {
+	    var tag = getTag(value),
+	        isFunc = tag == funcTag || tag == genTag;
+
+	    if (isBuffer(value)) {
+	      return cloneBuffer(value, isDeep);
+	    }
+	    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+	      if (isHostObject(value)) {
+	        return object ? value : {};
+	      }
+	      result = initCloneObject(isFunc ? {} : value);
+	      if (!isDeep) {
+	        return copySymbols(value, baseAssign(result, value));
+	      }
+	    } else {
+	      if (!cloneableTags[tag]) {
+	        return object ? value : {};
+	      }
+	      result = initCloneByTag(value, tag, baseClone, isDeep);
+	    }
+	  }
+	  // Check for circular references and return its corresponding clone.
+	  stack || (stack = new Stack);
+	  var stacked = stack.get(value);
+	  if (stacked) {
+	    return stacked;
+	  }
+	  stack.set(value, result);
+
+	  if (!isArr) {
+	    var props = isFull ? getAllKeys(value) : keys(value);
+	  }
+	  arrayEach(props || value, function(subValue, key) {
+	    if (props) {
+	      key = subValue;
+	      subValue = value[key];
+	    }
+	    // Recursively populate clone (susceptible to call stack limits).
+	    assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+	  });
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.create` without support for assigning
+	 * properties to the created object.
+	 *
+	 * @private
+	 * @param {Object} prototype The object to inherit from.
+	 * @returns {Object} Returns the new object.
+	 */
+	function baseCreate(proto) {
+	  return isObject(proto) ? objectCreate(proto) : {};
+	}
+
+	/**
+	 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+	 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+	 * symbols of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {Function} keysFunc The function to get the keys of `object`.
+	 * @param {Function} symbolsFunc The function to get the symbols of `object`.
+	 * @returns {Array} Returns the array of property names and symbols.
+	 */
+	function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+	  var result = keysFunc(object);
+	  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+	}
+
+	/**
+	 * The base implementation of `getTag`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	function baseGetTag(value) {
+	  return objectToString.call(value);
+	}
+
+	/**
+	 * The base implementation of `_.isNative` without bad shim checks.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a native function,
+	 *  else `false`.
+	 */
+	function baseIsNative(value) {
+	  if (!isObject(value) || isMasked(value)) {
+	    return false;
+	  }
+	  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+	  return pattern.test(toSource(value));
+	}
+
+	/**
+	 * The base implementation of `_.isTypedArray` without Node.js optimizations.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	 */
+	function baseIsTypedArray(value) {
+	  return isObjectLike(value) &&
+	    isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+	}
+
+	/**
+	 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function baseKeys(object) {
+	  if (!isPrototype(object)) {
+	    return nativeKeys(object);
+	  }
+	  var result = [];
+	  for (var key in Object(object)) {
+	    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function baseKeysIn(object) {
+	  if (!isObject(object)) {
+	    return nativeKeysIn(object);
+	  }
+	  var isProto = isPrototype(object),
+	      result = [];
+
+	  for (var key in object) {
+	    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * The base implementation of `_.merge` without support for multiple sources.
+	 *
+	 * @private
+	 * @param {Object} object The destination object.
+	 * @param {Object} source The source object.
+	 * @param {number} srcIndex The index of `source`.
+	 * @param {Function} [customizer] The function to customize merged values.
+	 * @param {Object} [stack] Tracks traversed source values and their merged
+	 *  counterparts.
+	 */
+	function baseMerge(object, source, srcIndex, customizer, stack) {
+	  if (object === source) {
+	    return;
+	  }
+	  if (!(isArray(source) || isTypedArray(source))) {
+	    var props = baseKeysIn(source);
+	  }
+	  arrayEach(props || source, function(srcValue, key) {
+	    if (props) {
+	      key = srcValue;
+	      srcValue = source[key];
+	    }
+	    if (isObject(srcValue)) {
+	      stack || (stack = new Stack);
+	      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+	    }
+	    else {
+	      var newValue = customizer
+	        ? customizer(object[key], srcValue, (key + ''), object, source, stack)
+	        : undefined;
+
+	      if (newValue === undefined) {
+	        newValue = srcValue;
+	      }
+	      assignMergeValue(object, key, newValue);
+	    }
+	  });
+	}
+
+	/**
+	 * A specialized version of `baseMerge` for arrays and objects which performs
+	 * deep merges and tracks traversed objects enabling objects with circular
+	 * references to be merged.
+	 *
+	 * @private
+	 * @param {Object} object The destination object.
+	 * @param {Object} source The source object.
+	 * @param {string} key The key of the value to merge.
+	 * @param {number} srcIndex The index of `source`.
+	 * @param {Function} mergeFunc The function to merge values.
+	 * @param {Function} [customizer] The function to customize assigned values.
+	 * @param {Object} [stack] Tracks traversed source values and their merged
+	 *  counterparts.
+	 */
+	function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+	  var objValue = object[key],
+	      srcValue = source[key],
+	      stacked = stack.get(srcValue);
+
+	  if (stacked) {
+	    assignMergeValue(object, key, stacked);
+	    return;
+	  }
+	  var newValue = customizer
+	    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+	    : undefined;
+
+	  var isCommon = newValue === undefined;
+
+	  if (isCommon) {
+	    newValue = srcValue;
+	    if (isArray(srcValue) || isTypedArray(srcValue)) {
+	      if (isArray(objValue)) {
+	        newValue = objValue;
+	      }
+	      else if (isArrayLikeObject(objValue)) {
+	        newValue = copyArray(objValue);
+	      }
+	      else {
+	        isCommon = false;
+	        newValue = baseClone(srcValue, true);
+	      }
+	    }
+	    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+	      if (isArguments(objValue)) {
+	        newValue = toPlainObject(objValue);
+	      }
+	      else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
+	        isCommon = false;
+	        newValue = baseClone(srcValue, true);
+	      }
+	      else {
+	        newValue = objValue;
+	      }
+	    }
+	    else {
+	      isCommon = false;
+	    }
+	  }
+	  if (isCommon) {
+	    // Recursively merge objects and arrays (susceptible to call stack limits).
+	    stack.set(srcValue, newValue);
+	    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+	    stack['delete'](srcValue);
+	  }
+	  assignMergeValue(object, key, newValue);
+	}
+
+	/**
+	 * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+	 *
+	 * @private
+	 * @param {Function} func The function to apply a rest parameter to.
+	 * @param {number} [start=func.length-1] The start position of the rest parameter.
+	 * @returns {Function} Returns the new function.
+	 */
+	function baseRest(func, start) {
+	  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+	  return function() {
+	    var args = arguments,
+	        index = -1,
+	        length = nativeMax(args.length - start, 0),
+	        array = Array(length);
+
+	    while (++index < length) {
+	      array[index] = args[start + index];
+	    }
+	    index = -1;
+	    var otherArgs = Array(start + 1);
+	    while (++index < start) {
+	      otherArgs[index] = args[index];
+	    }
+	    otherArgs[start] = array;
+	    return apply(func, this, otherArgs);
+	  };
+	}
+
+	/**
+	 * Creates a clone of  `buffer`.
+	 *
+	 * @private
+	 * @param {Buffer} buffer The buffer to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Buffer} Returns the cloned buffer.
+	 */
+	function cloneBuffer(buffer, isDeep) {
+	  if (isDeep) {
+	    return buffer.slice();
+	  }
+	  var result = new buffer.constructor(buffer.length);
+	  buffer.copy(result);
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `arrayBuffer`.
+	 *
+	 * @private
+	 * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+	 * @returns {ArrayBuffer} Returns the cloned array buffer.
+	 */
+	function cloneArrayBuffer(arrayBuffer) {
+	  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+	  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `dataView`.
+	 *
+	 * @private
+	 * @param {Object} dataView The data view to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned data view.
+	 */
+	function cloneDataView(dataView, isDeep) {
+	  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+	  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+	}
+
+	/**
+	 * Creates a clone of `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned map.
+	 */
+	function cloneMap(map, isDeep, cloneFunc) {
+	  var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
+	  return arrayReduce(array, addMapEntry, new map.constructor);
+	}
+
+	/**
+	 * Creates a clone of `regexp`.
+	 *
+	 * @private
+	 * @param {Object} regexp The regexp to clone.
+	 * @returns {Object} Returns the cloned regexp.
+	 */
+	function cloneRegExp(regexp) {
+	  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+	  result.lastIndex = regexp.lastIndex;
+	  return result;
+	}
+
+	/**
+	 * Creates a clone of `set`.
+	 *
+	 * @private
+	 * @param {Object} set The set to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned set.
+	 */
+	function cloneSet(set, isDeep, cloneFunc) {
+	  var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
+	  return arrayReduce(array, addSetEntry, new set.constructor);
+	}
+
+	/**
+	 * Creates a clone of the `symbol` object.
+	 *
+	 * @private
+	 * @param {Object} symbol The symbol object to clone.
+	 * @returns {Object} Returns the cloned symbol object.
+	 */
+	function cloneSymbol(symbol) {
+	  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+	}
+
+	/**
+	 * Creates a clone of `typedArray`.
+	 *
+	 * @private
+	 * @param {Object} typedArray The typed array to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the cloned typed array.
+	 */
+	function cloneTypedArray(typedArray, isDeep) {
+	  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+	  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+	}
+
+	/**
+	 * Copies the values of `source` to `array`.
+	 *
+	 * @private
+	 * @param {Array} source The array to copy values from.
+	 * @param {Array} [array=[]] The array to copy values to.
+	 * @returns {Array} Returns `array`.
+	 */
+	function copyArray(source, array) {
+	  var index = -1,
+	      length = source.length;
+
+	  array || (array = Array(length));
+	  while (++index < length) {
+	    array[index] = source[index];
+	  }
+	  return array;
+	}
+
+	/**
+	 * Copies properties of `source` to `object`.
+	 *
+	 * @private
+	 * @param {Object} source The object to copy properties from.
+	 * @param {Array} props The property identifiers to copy.
+	 * @param {Object} [object={}] The object to copy properties to.
+	 * @param {Function} [customizer] The function to customize copied values.
+	 * @returns {Object} Returns `object`.
+	 */
+	function copyObject(source, props, object, customizer) {
+	  object || (object = {});
+
+	  var index = -1,
+	      length = props.length;
+
+	  while (++index < length) {
+	    var key = props[index];
+
+	    var newValue = customizer
+	      ? customizer(object[key], source[key], key, object, source)
+	      : undefined;
+
+	    assignValue(object, key, newValue === undefined ? source[key] : newValue);
+	  }
+	  return object;
+	}
+
+	/**
+	 * Copies own symbol properties of `source` to `object`.
+	 *
+	 * @private
+	 * @param {Object} source The object to copy symbols from.
+	 * @param {Object} [object={}] The object to copy symbols to.
+	 * @returns {Object} Returns `object`.
+	 */
+	function copySymbols(source, object) {
+	  return copyObject(source, getSymbols(source), object);
+	}
+
+	/**
+	 * Creates a function like `_.assign`.
+	 *
+	 * @private
+	 * @param {Function} assigner The function to assign values.
+	 * @returns {Function} Returns the new assigner function.
+	 */
+	function createAssigner(assigner) {
+	  return baseRest(function(object, sources) {
+	    var index = -1,
+	        length = sources.length,
+	        customizer = length > 1 ? sources[length - 1] : undefined,
+	        guard = length > 2 ? sources[2] : undefined;
+
+	    customizer = (assigner.length > 3 && typeof customizer == 'function')
+	      ? (length--, customizer)
+	      : undefined;
+
+	    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+	      customizer = length < 3 ? undefined : customizer;
+	      length = 1;
+	    }
+	    object = Object(object);
+	    while (++index < length) {
+	      var source = sources[index];
+	      if (source) {
+	        assigner(object, source, index, customizer);
+	      }
+	    }
+	    return object;
+	  });
+	}
+
+	/**
+	 * Creates an array of own enumerable property names and symbols of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names and symbols.
+	 */
+	function getAllKeys(object) {
+	  return baseGetAllKeys(object, keys, getSymbols);
+	}
+
+	/**
+	 * Gets the data for `map`.
+	 *
+	 * @private
+	 * @param {Object} map The map to query.
+	 * @param {string} key The reference key.
+	 * @returns {*} Returns the map data.
+	 */
+	function getMapData(map, key) {
+	  var data = map.__data__;
+	  return isKeyable(key)
+	    ? data[typeof key == 'string' ? 'string' : 'hash']
+	    : data.map;
+	}
+
+	/**
+	 * Gets the native function at `key` of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {string} key The key of the method to get.
+	 * @returns {*} Returns the function if it's native, else `undefined`.
+	 */
+	function getNative(object, key) {
+	  var value = getValue(object, key);
+	  return baseIsNative(value) ? value : undefined;
+	}
+
+	/**
+	 * Creates an array of the own enumerable symbol properties of `object`.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of symbols.
+	 */
+	var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
+
+	/**
+	 * Gets the `toStringTag` of `value`.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	var getTag = baseGetTag;
+
+	// Fallback for data views, maps, sets, and weak maps in IE 11,
+	// for data views in Edge < 14, and promises in Node.js.
+	if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+	    (Map && getTag(new Map) != mapTag) ||
+	    (Promise && getTag(Promise.resolve()) != promiseTag) ||
+	    (Set && getTag(new Set) != setTag) ||
+	    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+	  getTag = function(value) {
+	    var result = objectToString.call(value),
+	        Ctor = result == objectTag ? value.constructor : undefined,
+	        ctorString = Ctor ? toSource(Ctor) : undefined;
+
+	    if (ctorString) {
+	      switch (ctorString) {
+	        case dataViewCtorString: return dataViewTag;
+	        case mapCtorString: return mapTag;
+	        case promiseCtorString: return promiseTag;
+	        case setCtorString: return setTag;
+	        case weakMapCtorString: return weakMapTag;
+	      }
+	    }
+	    return result;
+	  };
+	}
+
+	/**
+	 * Initializes an array clone.
+	 *
+	 * @private
+	 * @param {Array} array The array to clone.
+	 * @returns {Array} Returns the initialized clone.
+	 */
+	function initCloneArray(array) {
+	  var length = array.length,
+	      result = array.constructor(length);
+
+	  // Add properties assigned by `RegExp#exec`.
+	  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+	    result.index = array.index;
+	    result.input = array.input;
+	  }
+	  return result;
+	}
+
+	/**
+	 * Initializes an object clone.
+	 *
+	 * @private
+	 * @param {Object} object The object to clone.
+	 * @returns {Object} Returns the initialized clone.
+	 */
+	function initCloneObject(object) {
+	  return (typeof object.constructor == 'function' && !isPrototype(object))
+	    ? baseCreate(getPrototype(object))
+	    : {};
+	}
+
+	/**
+	 * Initializes an object clone based on its `toStringTag`.
+	 *
+	 * **Note:** This function only supports cloning values with tags of
+	 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+	 *
+	 * @private
+	 * @param {Object} object The object to clone.
+	 * @param {string} tag The `toStringTag` of the object to clone.
+	 * @param {Function} cloneFunc The function to clone values.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Object} Returns the initialized clone.
+	 */
+	function initCloneByTag(object, tag, cloneFunc, isDeep) {
+	  var Ctor = object.constructor;
+	  switch (tag) {
+	    case arrayBufferTag:
+	      return cloneArrayBuffer(object);
+
+	    case boolTag:
+	    case dateTag:
+	      return new Ctor(+object);
+
+	    case dataViewTag:
+	      return cloneDataView(object, isDeep);
+
+	    case float32Tag: case float64Tag:
+	    case int8Tag: case int16Tag: case int32Tag:
+	    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+	      return cloneTypedArray(object, isDeep);
+
+	    case mapTag:
+	      return cloneMap(object, isDeep, cloneFunc);
+
+	    case numberTag:
+	    case stringTag:
+	      return new Ctor(object);
+
+	    case regexpTag:
+	      return cloneRegExp(object);
+
+	    case setTag:
+	      return cloneSet(object, isDeep, cloneFunc);
+
+	    case symbolTag:
+	      return cloneSymbol(object);
+	  }
+	}
+
+	/**
+	 * Checks if `value` is a valid array-like index.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+	 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+	 */
+	function isIndex(value, length) {
+	  length = length == null ? MAX_SAFE_INTEGER : length;
+	  return !!length &&
+	    (typeof value == 'number' || reIsUint.test(value)) &&
+	    (value > -1 && value % 1 == 0 && value < length);
+	}
+
+	/**
+	 * Checks if the given arguments are from an iteratee call.
+	 *
+	 * @private
+	 * @param {*} value The potential iteratee value argument.
+	 * @param {*} index The potential iteratee index or key argument.
+	 * @param {*} object The potential iteratee object argument.
+	 * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+	 *  else `false`.
+	 */
+	function isIterateeCall(value, index, object) {
+	  if (!isObject(object)) {
+	    return false;
+	  }
+	  var type = typeof index;
+	  if (type == 'number'
+	        ? (isArrayLike(object) && isIndex(index, object.length))
+	        : (type == 'string' && index in object)
+	      ) {
+	    return eq(object[index], value);
+	  }
+	  return false;
+	}
+
+	/**
+	 * Checks if `value` is suitable for use as unique object key.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	 */
+	function isKeyable(value) {
+	  var type = typeof value;
+	  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+	    ? (value !== '__proto__')
+	    : (value === null);
+	}
+
+	/**
+	 * Checks if `func` has its source masked.
+	 *
+	 * @private
+	 * @param {Function} func The function to check.
+	 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	 */
+	function isMasked(func) {
+	  return !!maskSrcKey && (maskSrcKey in func);
+	}
+
+	/**
+	 * Checks if `value` is likely a prototype object.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+	 */
+	function isPrototype(value) {
+	  var Ctor = value && value.constructor,
+	      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+	  return value === proto;
+	}
+
+	/**
+	 * This function is like
+	 * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+	 * except that it includes inherited enumerable properties.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 */
+	function nativeKeysIn(object) {
+	  var result = [];
+	  if (object != null) {
+	    for (var key in Object(object)) {
+	      result.push(key);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * Converts `func` to its source code.
+	 *
+	 * @private
+	 * @param {Function} func The function to process.
+	 * @returns {string} Returns the source code.
+	 */
+	function toSource(func) {
+	  if (func != null) {
+	    try {
+	      return funcToString.call(func);
+	    } catch (e) {}
+	    try {
+	      return (func + '');
+	    } catch (e) {}
+	  }
+	  return '';
+	}
+
+	/**
+	 * Performs a
+	 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	 * comparison between two values to determine if they are equivalent.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to compare.
+	 * @param {*} other The other value to compare.
+	 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	 * @example
+	 *
+	 * var object = { 'a': 1 };
+	 * var other = { 'a': 1 };
+	 *
+	 * _.eq(object, object);
+	 * // => true
+	 *
+	 * _.eq(object, other);
+	 * // => false
+	 *
+	 * _.eq('a', 'a');
+	 * // => true
+	 *
+	 * _.eq('a', Object('a'));
+	 * // => false
+	 *
+	 * _.eq(NaN, NaN);
+	 * // => true
+	 */
+	function eq(value, other) {
+	  return value === other || (value !== value && other !== other);
+	}
+
+	/**
+	 * Checks if `value` is likely an `arguments` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	 *  else `false`.
+	 * @example
+	 *
+	 * _.isArguments(function() { return arguments; }());
+	 * // => true
+	 *
+	 * _.isArguments([1, 2, 3]);
+	 * // => false
+	 */
+	function isArguments(value) {
+	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+	  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+	    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+	}
+
+	/**
+	 * Checks if `value` is classified as an `Array` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	 * @example
+	 *
+	 * _.isArray([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArray(document.body.children);
+	 * // => false
+	 *
+	 * _.isArray('abc');
+	 * // => false
+	 *
+	 * _.isArray(_.noop);
+	 * // => false
+	 */
+	var isArray = Array.isArray;
+
+	/**
+	 * Checks if `value` is array-like. A value is considered array-like if it's
+	 * not a function and has a `value.length` that's an integer greater than or
+	 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	 * @example
+	 *
+	 * _.isArrayLike([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArrayLike(document.body.children);
+	 * // => true
+	 *
+	 * _.isArrayLike('abc');
+	 * // => true
+	 *
+	 * _.isArrayLike(_.noop);
+	 * // => false
+	 */
+	function isArrayLike(value) {
+	  return value != null && isLength(value.length) && !isFunction(value);
+	}
+
+	/**
+	 * This method is like `_.isArrayLike` except that it also checks if `value`
+	 * is an object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an array-like object,
+	 *  else `false`.
+	 * @example
+	 *
+	 * _.isArrayLikeObject([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isArrayLikeObject(document.body.children);
+	 * // => true
+	 *
+	 * _.isArrayLikeObject('abc');
+	 * // => false
+	 *
+	 * _.isArrayLikeObject(_.noop);
+	 * // => false
+	 */
+	function isArrayLikeObject(value) {
+	  return isObjectLike(value) && isArrayLike(value);
+	}
+
+	/**
+	 * Checks if `value` is a buffer.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.3.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+	 * @example
+	 *
+	 * _.isBuffer(new Buffer(2));
+	 * // => true
+	 *
+	 * _.isBuffer(new Uint8Array(2));
+	 * // => false
+	 */
+	var isBuffer = nativeIsBuffer || stubFalse;
+
+	/**
+	 * Checks if `value` is classified as a `Function` object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	 * @example
+	 *
+	 * _.isFunction(_);
+	 * // => true
+	 *
+	 * _.isFunction(/abc/);
+	 * // => false
+	 */
+	function isFunction(value) {
+	  // The use of `Object#toString` avoids issues with the `typeof` operator
+	  // in Safari 8-9 which returns 'object' for typed array and other constructors.
+	  var tag = isObject(value) ? objectToString.call(value) : '';
+	  return tag == funcTag || tag == genTag;
+	}
+
+	/**
+	 * Checks if `value` is a valid array-like length.
+	 *
+	 * **Note:** This method is loosely based on
+	 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	 * @example
+	 *
+	 * _.isLength(3);
+	 * // => true
+	 *
+	 * _.isLength(Number.MIN_VALUE);
+	 * // => false
+	 *
+	 * _.isLength(Infinity);
+	 * // => false
+	 *
+	 * _.isLength('3');
+	 * // => false
+	 */
+	function isLength(value) {
+	  return typeof value == 'number' &&
+	    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+
+	/**
+	 * Checks if `value` is the
+	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	 * @example
+	 *
+	 * _.isObject({});
+	 * // => true
+	 *
+	 * _.isObject([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isObject(_.noop);
+	 * // => true
+	 *
+	 * _.isObject(null);
+	 * // => false
+	 */
+	function isObject(value) {
+	  var type = typeof value;
+	  return !!value && (type == 'object' || type == 'function');
+	}
+
+	/**
+	 * Checks if `value` is object-like. A value is object-like if it's not `null`
+	 * and has a `typeof` result of "object".
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	 * @example
+	 *
+	 * _.isObjectLike({});
+	 * // => true
+	 *
+	 * _.isObjectLike([1, 2, 3]);
+	 * // => true
+	 *
+	 * _.isObjectLike(_.noop);
+	 * // => false
+	 *
+	 * _.isObjectLike(null);
+	 * // => false
+	 */
+	function isObjectLike(value) {
+	  return !!value && typeof value == 'object';
+	}
+
+	/**
+	 * Checks if `value` is a plain object, that is, an object created by the
+	 * `Object` constructor or one with a `[[Prototype]]` of `null`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.8.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1;
+	 * }
+	 *
+	 * _.isPlainObject(new Foo);
+	 * // => false
+	 *
+	 * _.isPlainObject([1, 2, 3]);
+	 * // => false
+	 *
+	 * _.isPlainObject({ 'x': 0, 'y': 0 });
+	 * // => true
+	 *
+	 * _.isPlainObject(Object.create(null));
+	 * // => true
+	 */
+	function isPlainObject(value) {
+	  if (!isObjectLike(value) ||
+	      objectToString.call(value) != objectTag || isHostObject(value)) {
+	    return false;
+	  }
+	  var proto = getPrototype(value);
+	  if (proto === null) {
+	    return true;
+	  }
+	  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+	  return (typeof Ctor == 'function' &&
+	    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
+	}
+
+	/**
+	 * Checks if `value` is classified as a typed array.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	 * @example
+	 *
+	 * _.isTypedArray(new Uint8Array);
+	 * // => true
+	 *
+	 * _.isTypedArray([]);
+	 * // => false
+	 */
+	var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+	/**
+	 * Converts `value` to a plain object flattening inherited enumerable string
+	 * keyed properties of `value` to own properties of the plain object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.0.0
+	 * @category Lang
+	 * @param {*} value The value to convert.
+	 * @returns {Object} Returns the converted plain object.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.b = 2;
+	 * }
+	 *
+	 * Foo.prototype.c = 3;
+	 *
+	 * _.assign({ 'a': 1 }, new Foo);
+	 * // => { 'a': 1, 'b': 2 }
+	 *
+	 * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+	 * // => { 'a': 1, 'b': 2, 'c': 3 }
+	 */
+	function toPlainObject(value) {
+	  return copyObject(value, keysIn(value));
+	}
+
+	/**
+	 * Creates an array of the own enumerable property names of `object`.
+	 *
+	 * **Note:** Non-object values are coerced to objects. See the
+	 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+	 * for more details.
+	 *
+	 * @static
+	 * @since 0.1.0
+	 * @memberOf _
+	 * @category Object
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1;
+	 *   this.b = 2;
+	 * }
+	 *
+	 * Foo.prototype.c = 3;
+	 *
+	 * _.keys(new Foo);
+	 * // => ['a', 'b'] (iteration order is not guaranteed)
+	 *
+	 * _.keys('hi');
+	 * // => ['0', '1']
+	 */
+	function keys(object) {
+	  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+	}
+
+	/**
+	 * Creates an array of the own and inherited enumerable property names of `object`.
+	 *
+	 * **Note:** Non-object values are coerced to objects.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.0.0
+	 * @category Object
+	 * @param {Object} object The object to query.
+	 * @returns {Array} Returns the array of property names.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1;
+	 *   this.b = 2;
+	 * }
+	 *
+	 * Foo.prototype.c = 3;
+	 *
+	 * _.keysIn(new Foo);
+	 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+	 */
+	function keysIn(object) {
+	  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+	}
+
+	/**
+	 * This method is like `_.assign` except that it recursively merges own and
+	 * inherited enumerable string keyed properties of source objects into the
+	 * destination object. Source properties that resolve to `undefined` are
+	 * skipped if a destination value exists. Array and plain object properties
+	 * are merged recursively. Other objects and value types are overridden by
+	 * assignment. Source objects are applied from left to right. Subsequent
+	 * sources overwrite property assignments of previous sources.
+	 *
+	 * **Note:** This method mutates `object`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.5.0
+	 * @category Object
+	 * @param {Object} object The destination object.
+	 * @param {...Object} [sources] The source objects.
+	 * @returns {Object} Returns `object`.
+	 * @example
+	 *
+	 * var object = {
+	 *   'a': [{ 'b': 2 }, { 'd': 4 }]
+	 * };
+	 *
+	 * var other = {
+	 *   'a': [{ 'c': 3 }, { 'e': 5 }]
+	 * };
+	 *
+	 * _.merge(object, other);
+	 * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+	 */
+	var merge = createAssigner(function(object, source, srcIndex) {
+	  baseMerge(object, source, srcIndex);
+	});
+
+	/**
+	 * This method returns a new empty array.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.13.0
+	 * @category Util
+	 * @returns {Array} Returns the new empty array.
+	 * @example
+	 *
+	 * var arrays = _.times(2, _.stubArray);
+	 *
+	 * console.log(arrays);
+	 * // => [[], []]
+	 *
+	 * console.log(arrays[0] === arrays[1]);
+	 * // => false
+	 */
+	function stubArray() {
+	  return [];
+	}
+
+	/**
+	 * This method returns `false`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.13.0
+	 * @category Util
+	 * @returns {boolean} Returns `false`.
+	 * @example
+	 *
+	 * _.times(2, _.stubFalse);
+	 * // => [false, false]
+	 */
+	function stubFalse() {
+	  return false;
+	}
+
+	module.exports = merge;
+
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(6)(module)))
+
+/***/ },
+/* 6 */
+/***/ function(module, exports) {
+
+	module.exports = function(module) {
+		if(!module.webpackPolyfill) {
+			module.deprecate = function() {};
+			module.paths = [];
+			// module.parent = undefined by default
+			module.children = [];
+			module.webpackPolyfill = 1;
+		}
+		return module;
+	}
+
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'horizontalbar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            },
+	            categoryPercentage: 0.5,
+	            barPercentage: 0.2
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options, type) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'horizontalBar',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'doughnut-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'doughnut',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'line-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            }
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'line',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'pie-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'pie',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'polar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'polarArea',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'radar-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {},
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'radar',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'bubble-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          yAxes: [{
+	            ticks: {
+	              beginAtZero: true
+	            },
+	            gridLines: {
+	              display: false
+	            }
+	          }],
+	          xAxes: [{
+	            gridLines: {
+	              display: false
+	            },
+	            categoryPercentage: 0.5,
+	            barPercentage: 0.2
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'bubble',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _vue = __webpack_require__(2);
+
+	var _vue2 = _interopRequireDefault(_vue);
+
+	var _chart = __webpack_require__(3);
+
+	var _chart2 = _interopRequireDefault(_chart);
+
+	var _options = __webpack_require__(4);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = _vue2.default.extend({
+	  render: function render(createElement) {
+	    return createElement('div', {
+	      style: this.styles,
+	      class: this.cssClasses
+	    }, [createElement('canvas', {
+	      attrs: {
+	        id: this.chartId,
+	        width: this.width,
+	        height: this.height
+	      },
+	      ref: 'canvas'
+	    })]);
+	  },
+
+	  props: {
+	    chartId: {
+	      default: 'scatter-chart',
+	      type: String
+	    },
+	    width: {
+	      default: 400,
+	      type: Number
+	    },
+	    height: {
+	      default: 400,
+	      type: Number
+	    },
+	    cssClasses: {
+	      type: String,
+	      default: ''
+	    },
+	    styles: {
+	      type: Object
+	    }
+	  },
+
+	  data: function data() {
+	    return {
+	      defaultOptions: {
+	        scales: {
+	          xAxes: [{
+	            type: 'linear',
+	            position: 'bottom'
+	          }]
+	        }
+	      },
+	      plugins: []
+	    };
+	  },
+
+
+	  methods: {
+	    addPlugin: function addPlugin(plugin) {
+	      this.plugins.push(plugin);
+	    },
+	    renderChart: function renderChart(data, options) {
+	      var chartOptions = (0, _options.mergeOptions)(this.defaultOptions, options);
+
+	      this._chart = new _chart2.default(this.$refs.canvas.getContext('2d'), {
+	        type: 'scatter',
+	        data: data,
+	        options: chartOptions,
+	        plugins: this.plugins
+	      });
+	    }
+	  },
+	  beforeDestroy: function beforeDestroy() {
+	    if (this._chart) {
+	      this._chart.destroy();
+	    }
+	  }
+	});
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _reactiveData = __webpack_require__(16);
+
+	var _reactiveData2 = _interopRequireDefault(_reactiveData);
+
+	var _reactiveProp = __webpack_require__(54);
+
+	var _reactiveProp2 = _interopRequireDefault(_reactiveProp);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	exports.default = {
+	  reactiveData: _reactiveData2.default,
+	  reactiveProp: _reactiveProp2.default
+	};
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _keys = __webpack_require__(17);
+
+	var _keys2 = _interopRequireDefault(_keys);
+
+	var _stringify = __webpack_require__(52);
+
+	var _stringify2 = _interopRequireDefault(_stringify);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	module.exports = {
+	  data: function data() {
+	    return {
+	      chartData: null
+	    };
+	  },
+
+	  watch: {
+	    'chartData': {
+	      handler: function handler(newData, oldData) {
+	        if (oldData) {
+	          var chart = this._chart;
+
+	          var newDatasetLabels = newData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldDatasetLabels = oldData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldLabels = (0, _stringify2.default)(oldDatasetLabels);
+	          var newLabels = (0, _stringify2.default)(newDatasetLabels);
+
+	          if (newLabels === oldLabels && oldData.datasets.length === newData.datasets.length) {
+	            newData.datasets.forEach(function (dataset, i) {
+	              var oldDatasetKeys = (0, _keys2.default)(oldData.datasets[i]);
+	              var newDatasetKeys = (0, _keys2.default)(dataset);
+
+	              var deletionKeys = oldDatasetKeys.filter(function (key) {
+	                return key !== '_meta' && newDatasetKeys.indexOf(key) === -1;
+	              });
+
+	              deletionKeys.forEach(function (deletionKey) {
+	                delete chart.data.datasets[i][deletionKey];
+	              });
+
+	              for (var attribute in dataset) {
+	                if (dataset.hasOwnProperty(attribute)) {
+	                  chart.data.datasets[i][attribute] = dataset[attribute];
+	                }
+	              }
+	            });
+
+	            if (newData.hasOwnProperty('labels')) {
+	              chart.data.labels = newData.labels;
+	            }
+	            if (newData.hasOwnProperty('xLabels')) {
+	              chart.data.xLabels = newData.xLabels;
+	            }
+	            if (newData.hasOwnProperty('yLabels')) {
+	              chart.data.yLabels = newData.yLabels;
+	            }
+	            chart.update();
+	          } else {
+	            chart.destroy();
+	            this.renderChart(this.chartData, this.options);
+	          }
+	        } else {
+	          this.renderChart(this.chartData, this.options);
+	        }
+	      }
+	    }
+	  }
+	};
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = { "default": __webpack_require__(18), __esModule: true };
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	__webpack_require__(19);
+	module.exports = __webpack_require__(39).Object.keys;
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 19.1.2.14 Object.keys(O)
+	var toObject = __webpack_require__(20)
+	  , $keys    = __webpack_require__(22);
+
+	__webpack_require__(37)('keys', function(){
+	  return function keys(it){
+	    return $keys(toObject(it));
+	  };
+	});
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 7.1.13 ToObject(argument)
+	var defined = __webpack_require__(21);
+	module.exports = function(it){
+	  return Object(defined(it));
+	};
+
+/***/ },
+/* 21 */
+/***/ function(module, exports) {
+
+	// 7.2.1 RequireObjectCoercible(argument)
+	module.exports = function(it){
+	  if(it == undefined)throw TypeError("Can't call method on  " + it);
+	  return it;
+	};
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+	var $keys       = __webpack_require__(23)
+	  , enumBugKeys = __webpack_require__(36);
+
+	module.exports = Object.keys || function keys(O){
+	  return $keys(O, enumBugKeys);
+	};
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var has          = __webpack_require__(24)
+	  , toIObject    = __webpack_require__(25)
+	  , arrayIndexOf = __webpack_require__(28)(false)
+	  , IE_PROTO     = __webpack_require__(32)('IE_PROTO');
+
+	module.exports = function(object, names){
+	  var O      = toIObject(object)
+	    , i      = 0
+	    , result = []
+	    , key;
+	  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
+	  // Don't enum bug & hidden keys
+	  while(names.length > i)if(has(O, key = names[i++])){
+	    ~arrayIndexOf(result, key) || result.push(key);
+	  }
+	  return result;
+	};
+
+/***/ },
+/* 24 */
+/***/ function(module, exports) {
+
+	var hasOwnProperty = {}.hasOwnProperty;
+	module.exports = function(it, key){
+	  return hasOwnProperty.call(it, key);
+	};
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// to indexed object, toObject with fallback for non-array-like ES3 strings
+	var IObject = __webpack_require__(26)
+	  , defined = __webpack_require__(21);
+	module.exports = function(it){
+	  return IObject(defined(it));
+	};
+
+/***/ },
+/* 26 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// fallback for non-array-like ES3 and non-enumerable old V8 strings
+	var cof = __webpack_require__(27);
+	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
+	  return cof(it) == 'String' ? it.split('') : Object(it);
+	};
+
+/***/ },
+/* 27 */
+/***/ function(module, exports) {
+
+	var toString = {}.toString;
+
+	module.exports = function(it){
+	  return toString.call(it).slice(8, -1);
+	};
+
+/***/ },
+/* 28 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// false -> Array#indexOf
+	// true  -> Array#includes
+	var toIObject = __webpack_require__(25)
+	  , toLength  = __webpack_require__(29)
+	  , toIndex   = __webpack_require__(31);
+	module.exports = function(IS_INCLUDES){
+	  return function($this, el, fromIndex){
+	    var O      = toIObject($this)
+	      , length = toLength(O.length)
+	      , index  = toIndex(fromIndex, length)
+	      , value;
+	    // Array#includes uses SameValueZero equality algorithm
+	    if(IS_INCLUDES && el != el)while(length > index){
+	      value = O[index++];
+	      if(value != value)return true;
+	    // Array#toIndex ignores holes, Array#includes - not
+	    } else for(;length > index; index++)if(IS_INCLUDES || index in O){
+	      if(O[index] === el)return IS_INCLUDES || index || 0;
+	    } return !IS_INCLUDES && -1;
+	  };
+	};
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 7.1.15 ToLength
+	var toInteger = __webpack_require__(30)
+	  , min       = Math.min;
+	module.exports = function(it){
+	  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+	};
+
+/***/ },
+/* 30 */
+/***/ function(module, exports) {
+
+	// 7.1.4 ToInteger
+	var ceil  = Math.ceil
+	  , floor = Math.floor;
+	module.exports = function(it){
+	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+	};
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var toInteger = __webpack_require__(30)
+	  , max       = Math.max
+	  , min       = Math.min;
+	module.exports = function(index, length){
+	  index = toInteger(index);
+	  return index < 0 ? max(index + length, 0) : min(index, length);
+	};
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var shared = __webpack_require__(33)('keys')
+	  , uid    = __webpack_require__(35);
+	module.exports = function(key){
+	  return shared[key] || (shared[key] = uid(key));
+	};
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var global = __webpack_require__(34)
+	  , SHARED = '__core-js_shared__'
+	  , store  = global[SHARED] || (global[SHARED] = {});
+	module.exports = function(key){
+	  return store[key] || (store[key] = {});
+	};
+
+/***/ },
+/* 34 */
+/***/ function(module, exports) {
+
+	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+	var global = module.exports = typeof window != 'undefined' && window.Math == Math
+	  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
+	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
+
+/***/ },
+/* 35 */
+/***/ function(module, exports) {
+
+	var id = 0
+	  , px = Math.random();
+	module.exports = function(key){
+	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+	};
+
+/***/ },
+/* 36 */
+/***/ function(module, exports) {
+
+	// IE 8- don't enum bug keys
+	module.exports = (
+	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+	).split(',');
+
+/***/ },
+/* 37 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// most Object methods by ES6 should accept primitives
+	var $export = __webpack_require__(38)
+	  , core    = __webpack_require__(39)
+	  , fails   = __webpack_require__(48);
+	module.exports = function(KEY, exec){
+	  var fn  = (core.Object || {})[KEY] || Object[KEY]
+	    , exp = {};
+	  exp[KEY] = exec(fn);
+	  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
+	};
+
+/***/ },
+/* 38 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var global    = __webpack_require__(34)
+	  , core      = __webpack_require__(39)
+	  , ctx       = __webpack_require__(40)
+	  , hide      = __webpack_require__(42)
+	  , PROTOTYPE = 'prototype';
+
+	var $export = function(type, name, source){
+	  var IS_FORCED = type & $export.F
+	    , IS_GLOBAL = type & $export.G
+	    , IS_STATIC = type & $export.S
+	    , IS_PROTO  = type & $export.P
+	    , IS_BIND   = type & $export.B
+	    , IS_WRAP   = type & $export.W
+	    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
+	    , expProto  = exports[PROTOTYPE]
+	    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
+	    , key, own, out;
+	  if(IS_GLOBAL)source = name;
+	  for(key in source){
+	    // contains in native
+	    own = !IS_FORCED && target && target[key] !== undefined;
+	    if(own && key in exports)continue;
+	    // export native or passed
+	    out = own ? target[key] : source[key];
+	    // prevent global pollution for namespaces
+	    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
+	    // bind timers to global for call from export context
+	    : IS_BIND && own ? ctx(out, global)
+	    // wrap global constructors for prevent change them in library
+	    : IS_WRAP && target[key] == out ? (function(C){
+	      var F = function(a, b, c){
+	        if(this instanceof C){
+	          switch(arguments.length){
+	            case 0: return new C;
+	            case 1: return new C(a);
+	            case 2: return new C(a, b);
+	          } return new C(a, b, c);
+	        } return C.apply(this, arguments);
+	      };
+	      F[PROTOTYPE] = C[PROTOTYPE];
+	      return F;
+	    // make static versions for prototype methods
+	    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+	    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
+	    if(IS_PROTO){
+	      (exports.virtual || (exports.virtual = {}))[key] = out;
+	      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
+	      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);
+	    }
+	  }
+	};
+	// type bitmap
+	$export.F = 1;   // forced
+	$export.G = 2;   // global
+	$export.S = 4;   // static
+	$export.P = 8;   // proto
+	$export.B = 16;  // bind
+	$export.W = 32;  // wrap
+	$export.U = 64;  // safe
+	$export.R = 128; // real proto method for `library` 
+	module.exports = $export;
+
+/***/ },
+/* 39 */
+/***/ function(module, exports) {
+
+	var core = module.exports = {version: '2.4.0'};
+	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
+
+/***/ },
+/* 40 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// optional / simple context binding
+	var aFunction = __webpack_require__(41);
+	module.exports = function(fn, that, length){
+	  aFunction(fn);
+	  if(that === undefined)return fn;
+	  switch(length){
+	    case 1: return function(a){
+	      return fn.call(that, a);
+	    };
+	    case 2: return function(a, b){
+	      return fn.call(that, a, b);
+	    };
+	    case 3: return function(a, b, c){
+	      return fn.call(that, a, b, c);
+	    };
+	  }
+	  return function(/* ...args */){
+	    return fn.apply(that, arguments);
+	  };
+	};
+
+/***/ },
+/* 41 */
+/***/ function(module, exports) {
+
+	module.exports = function(it){
+	  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
+	  return it;
+	};
+
+/***/ },
+/* 42 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var dP         = __webpack_require__(43)
+	  , createDesc = __webpack_require__(51);
+	module.exports = __webpack_require__(47) ? function(object, key, value){
+	  return dP.f(object, key, createDesc(1, value));
+	} : function(object, key, value){
+	  object[key] = value;
+	  return object;
+	};
+
+/***/ },
+/* 43 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var anObject       = __webpack_require__(44)
+	  , IE8_DOM_DEFINE = __webpack_require__(46)
+	  , toPrimitive    = __webpack_require__(50)
+	  , dP             = Object.defineProperty;
+
+	exports.f = __webpack_require__(47) ? Object.defineProperty : function defineProperty(O, P, Attributes){
+	  anObject(O);
+	  P = toPrimitive(P, true);
+	  anObject(Attributes);
+	  if(IE8_DOM_DEFINE)try {
+	    return dP(O, P, Attributes);
+	  } catch(e){ /* empty */ }
+	  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
+	  if('value' in Attributes)O[P] = Attributes.value;
+	  return O;
+	};
+
+/***/ },
+/* 44 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var isObject = __webpack_require__(45);
+	module.exports = function(it){
+	  if(!isObject(it))throw TypeError(it + ' is not an object!');
+	  return it;
+	};
+
+/***/ },
+/* 45 */
+/***/ function(module, exports) {
+
+	module.exports = function(it){
+	  return typeof it === 'object' ? it !== null : typeof it === 'function';
+	};
+
+/***/ },
+/* 46 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = !__webpack_require__(47) && !__webpack_require__(48)(function(){
+	  return Object.defineProperty(__webpack_require__(49)('div'), 'a', {get: function(){ return 7; }}).a != 7;
+	});
+
+/***/ },
+/* 47 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Thank's IE8 for his funny defineProperty
+	module.exports = !__webpack_require__(48)(function(){
+	  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
+	});
+
+/***/ },
+/* 48 */
+/***/ function(module, exports) {
+
+	module.exports = function(exec){
+	  try {
+	    return !!exec();
+	  } catch(e){
+	    return true;
+	  }
+	};
+
+/***/ },
+/* 49 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var isObject = __webpack_require__(45)
+	  , document = __webpack_require__(34).document
+	  // in old IE typeof document.createElement is 'object'
+	  , is = isObject(document) && isObject(document.createElement);
+	module.exports = function(it){
+	  return is ? document.createElement(it) : {};
+	};
+
+/***/ },
+/* 50 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 7.1.1 ToPrimitive(input [, PreferredType])
+	var isObject = __webpack_require__(45);
+	// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+	// and the second argument - flag - preferred type is a string
+	module.exports = function(it, S){
+	  if(!isObject(it))return it;
+	  var fn, val;
+	  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+	  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
+	  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+	  throw TypeError("Can't convert object to primitive value");
+	};
+
+/***/ },
+/* 51 */
+/***/ function(module, exports) {
+
+	module.exports = function(bitmap, value){
+	  return {
+	    enumerable  : !(bitmap & 1),
+	    configurable: !(bitmap & 2),
+	    writable    : !(bitmap & 4),
+	    value       : value
+	  };
+	};
+
+/***/ },
+/* 52 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = { "default": __webpack_require__(53), __esModule: true };
+
+/***/ },
+/* 53 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var core  = __webpack_require__(39)
+	  , $JSON = core.JSON || (core.JSON = {stringify: JSON.stringify});
+	module.exports = function stringify(it){ // eslint-disable-line no-unused-vars
+	  return $JSON.stringify.apply($JSON, arguments);
+	};
+
+/***/ },
+/* 54 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _keys = __webpack_require__(17);
+
+	var _keys2 = _interopRequireDefault(_keys);
+
+	var _stringify = __webpack_require__(52);
+
+	var _stringify2 = _interopRequireDefault(_stringify);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	module.exports = {
+	  props: {
+	    chartData: {
+	      required: true
+	    }
+	  },
+	  watch: {
+	    'chartData': {
+	      handler: function handler(newData, oldData) {
+	        if (oldData) {
+	          var chart = this._chart;
+
+	          var newDatasetLabels = newData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldDatasetLabels = oldData.datasets.map(function (dataset) {
+	            return dataset.label;
+	          });
+
+	          var oldLabels = (0, _stringify2.default)(oldDatasetLabels);
+	          var newLabels = (0, _stringify2.default)(newDatasetLabels);
+
+	          if (newLabels === oldLabels && oldData.datasets.length === newData.datasets.length) {
+	            newData.datasets.forEach(function (dataset, i) {
+	              var oldDatasetKeys = (0, _keys2.default)(oldData.datasets[i]);
+	              var newDatasetKeys = (0, _keys2.default)(dataset);
+
+	              var deletionKeys = oldDatasetKeys.filter(function (key) {
+	                return key !== '_meta' && newDatasetKeys.indexOf(key) === -1;
+	              });
+
+	              deletionKeys.forEach(function (deletionKey) {
+	                delete chart.data.datasets[i][deletionKey];
+	              });
+
+	              for (var attribute in dataset) {
+	                if (dataset.hasOwnProperty(attribute)) {
+	                  chart.data.datasets[i][attribute] = dataset[attribute];
+	                }
+	              }
+	            });
+
+	            if (newData.hasOwnProperty('labels')) {
+	              chart.data.labels = newData.labels;
+	            }
+	            if (newData.hasOwnProperty('xLabels')) {
+	              chart.data.xLabels = newData.xLabels;
+	            }
+	            if (newData.hasOwnProperty('yLabels')) {
+	              chart.data.yLabels = newData.yLabels;
+	            }
+	            chart.update();
+	          } else {
+	            chart.destroy();
+	            this.renderChart(this.chartData, this.options);
+	          }
+	        } else {
+	          this.renderChart(this.chartData, this.options);
+	        }
+	      }
+	    }
+	  }
+	};
+
+/***/ },
+/* 55 */
+/***/ function(module, exports) {
+
+	module.exports = {
+		"name": "vue-chartjs",
+		"version": "2.8.7",
+		"description": "Vue.js wrapper for chart.js for creating beautiful charts.",
+		"author": "Jakub Juszczak <jakub@posteo.de>",
+		"homepage": "http://vue-chartjs.org",
+		"license": "MIT",
+		"contributors": [
+			{
+				"name": "Thorsten Lünborg",
+				"web": "https://github.com/LinusBorg"
+			},
+			{
+				"name": "Juan Carlos Alonso",
+				"web": "https://github.com/jcalonso"
+			}
+		],
+		"maintainers": [
+			{
+				"name": "Jakub Juszczak",
+				"email": "jakub@posteo.de",
+				"web": "http://www.jakubjuszczak.de"
+			}
+		],
+		"repository": {
+			"type": "git",
+			"url": "git+ssh://git@github.com:apertureless/vue-chartjs.git"
+		},
+		"bugs": {
+			"url": "https://github.com/apertureless/vue-chartjs/issues"
+		},
+		"keywords": [
+			"ChartJs",
+			"Vue",
+			"Visualisation",
+			"Wrapper",
+			"Charts"
+		],
+		"main": "dist/vue-chartjs.js",
+		"unpkg": "dist/vue-chartjs.full.min.js",
+		"module": "es/index.js",
+		"jsnext:main": "es/index.js",
+		"files": [
+			"src",
+			"dist",
+			"es"
+		],
+		"scripts": {
+			"dev": "node build/dev-server.js",
+			"build": "yarn run release && yarn run build:es",
+			"build:es": "cross-env BABEL_ENV=es babel src --out-dir es",
+			"unit": "karma start test/unit/karma.conf.js --single-run",
+			"e2e": "node test/e2e/runner.js",
+			"test": "npm run unit",
+			"lint": "eslint --ext .js,.vue src test/unit/specs test/e2e/specs",
+			"release": "webpack --progress --hide-modules --config  ./build/webpack.release.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.min.js && webpack --progress --hide-modules --config  ./build/webpack.release.full.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.full.min.js",
+			"prepublish": "yarn run lint && yarn run test && yarn run build"
+		},
+		"dependencies": {
+			"lodash.merge": "^4.6.0"
+		},
+		"peerDependencies": {
+			"chart.js": "^2.7.0",
+			"vue": "^2.4.4"
+		},
+		"devDependencies": {
+			"babel-cli": "^6.24.1",
+			"babel-core": "^6.25.0",
+			"babel-loader": "^7.0.0",
+			"babel-plugin-transform-object-assign": "^6.22.0",
+			"babel-plugin-transform-runtime": "^6.23.0",
+			"babel-preset-es2015": "^6.24.1",
+			"babel-preset-stage-2": "^6.24.1",
+			"babel-runtime": "^6.23.0",
+			"chai": "^3.5.0",
+			"chart.js": "^2.7.0",
+			"chromedriver": "^2.28.0",
+			"connect-history-api-fallback": "^1.1.0",
+			"cross-env": "^3.2.4",
+			"cross-spawn": "^5.1.0",
+			"css-loader": "^0.28.0",
+			"eslint": "^3.19.0",
+			"eslint-config-standard": "^10.2.1",
+			"eslint-friendly-formatter": "^2.0.7",
+			"eslint-loader": "^1.7.1",
+			"eslint-plugin-html": "^2.0.1",
+			"eslint-plugin-import": "^2.2.0",
+			"eslint-plugin-node": "^4.2.2",
+			"eslint-plugin-promise": "^3.5.0",
+			"eslint-plugin-standard": "^3.0.1",
+			"eventsource-polyfill": "^0.9.6",
+			"express": "^4.15.2",
+			"extract-text-webpack-plugin": "^1.0.1",
+			"file-loader": "^0.10.1",
+			"function-bind": "^1.0.2",
+			"html-webpack-plugin": "^2.28.0",
+			"http-proxy-middleware": "^0.17.4",
+			"inject-loader": "^3.0.0",
+			"isparta-loader": "^2.0.0",
+			"jasmine-core": "^2.5.2",
+			"json-loader": "^0.5.4",
+			"karma": "^1.5.0",
+			"karma-coverage": "^1.1.1",
+			"karma-jasmine": "^1.0.2",
+			"karma-mocha": "^1.2.0",
+			"karma-phantomjs-launcher": "^1.0.4",
+			"karma-sinon-chai": "^1.2.0",
+			"karma-sourcemap-loader": "^0.3.7",
+			"karma-spec-reporter": "0.0.30",
+			"karma-webpack": "1.8.1",
+			"lolex": "^1.6.0",
+			"mocha": "^3.1.0",
+			"nightwatch": "^0.9.14",
+			"ora": "^1.2.0",
+			"phantomjs-prebuilt": "^2.1.13",
+			"selenium-server": "^3.3.1",
+			"shelljs": "^0.7.7",
+			"sinon": "^2.1.0",
+			"sinon-chai": "^2.9.0",
+			"url-loader": "^0.5.8",
+			"vue": "^2.4.4",
+			"vue-hot-reload-api": "^2.1.0",
+			"vue-html-loader": "^1.2.4",
+			"vue-loader": "^12.2.2",
+			"vue-style-loader": "^3.0.1",
+			"vue-template-compiler": "^2.4.2",
+			"webpack": "^1.13.2",
+			"webpack-dev-middleware": "^1.10.1",
+			"webpack-hot-middleware": "^2.17.1",
+			"webpack-merge": "1.1.1"
+		},
+		"engines": {
+			"node": ">=6.9.0"
+		},
+		"babel": {
+			"presets": [
+				"es2015"
+			]
+		},
+		"browserify": {
+			"transform": [
+				"babelify"
+			]
+		},
+		"greenkeeper": {
+			"ignore": [
+				"extract-text-webpack-plugin",
+				"karma-webpack",
+				"webpack",
+				"webpack-merge"
+			]
+		}
+	};
+
+/***/ }
+/******/ ])
+});
+;
\ No newline at end of file
diff --git a/dist/vue-chartjs.min.js b/dist/vue-chartjs.min.js
new file mode 100644
index 00000000..e85a170c
--- /dev/null
+++ b/dist/vue-chartjs.min.js
@@ -0,0 +1,2 @@
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e(require("chart.js"),require("vue")):"function"==typeof define&&define.amd?define("VueChartJs",["chart.js","vue"],e):"object"==typeof exports?exports.VueChartJs=e(require("chart.js"),require("vue")):t.VueChartJs=e(t["chart.js"],t.vue)}(this,function(t,e){return function(t){function e(n){if(r[n])return r[n].exports;var a=r[n]={exports:{},id:n,loaded:!1};return t[n].call(a.exports,a,a.exports,e),a.loaded=!0,a.exports}var r={};return e.m=t,e.c=r,e.p="",e(0)}([function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0}),e.mixins=e.Scatter=e.Bubble=e.Radar=e.PolarArea=e.Pie=e.Line=e.Doughnut=e.HorizontalBar=e.Bar=e.VueCharts=void 0;var a=r(14),i=n(a),s=r(17),u=n(s),o=r(16),c=n(o),l=r(18),f=n(l),d=r(19),h=n(d),p=r(20),y=n(p),b=r(21),v=n(b),g=r(15),_=n(g),m=r(22),j=n(m),w=r(23),x=n(w),O=r(53),P=n(O),k={version:P.default.version,Bar:i.default,HorizontalBar:u.default,Doughnut:c.default,Line:f.default,Pie:h.default,PolarArea:y.default,Radar:v.default,Bubble:_.default,Scatter:j.default,mixins:x.default};e.default=k,e.VueCharts=k,e.Bar=i.default,e.HorizontalBar=u.default,e.Doughnut=c.default,e.Line=f.default,e.Pie=h.default,e.PolarArea=y.default,e.Radar=v.default,e.Bubble=_.default,e.Scatter=j.default,e.mixins=x.default},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}function a(t,e){return(0,s.default)(t,e)}Object.defineProperty(e,"__esModule",{value:!0}),e.mergeOptions=a;var i=r(54),s=n(i)},function(e,r){e.exports=t},function(t,r){t.exports=e},function(t,e){var r=t.exports={version:"2.4.0"};"number"==typeof __e&&(__e=r)},function(t,e,r){t.exports=!r(6)(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a})},function(t,e){t.exports=function(t){try{return!!t()}catch(t){return!0}}},function(t,e){var r=t.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=r)},function(t,e){t.exports=function(t){return"object"==typeof t?null!==t:"function"==typeof t}},function(t,e,r){t.exports={default:r(26),__esModule:!0}},function(t,e,r){t.exports={default:r(27),__esModule:!0}},function(t,e){t.exports=function(t){if(void 0==t)throw TypeError("Can't call method on  "+t);return t}},function(t,e){var r=Math.ceil,n=Math.floor;t.exports=function(t){return isNaN(t=+t)?0:(t>0?n:r)(t)}},function(t,e,r){var n=r(39),a=r(11);t.exports=function(t){return n(a(t))}},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"bar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1},categoryPercentage:.5,barPercentage:.2}]}},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"bar",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"bubble-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1},categoryPercentage:.5,barPercentage:.2}]}},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"bubble",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"doughnut-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"doughnut",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"horizontalbar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1},categoryPercentage:.5,barPercentage:.2}]}},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e,r){var n=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"horizontalBar",data:t,options:n,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"line-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{yAxes:[{ticks:{beginAtZero:!0},gridLines:{display:!1}}],xAxes:[{gridLines:{display:!1}}]}},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"line",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"pie-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"pie",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"polar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"polarArea",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"radar-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"radar",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(3),i=n(a),s=r(2),u=n(s),o=r(1);e.default=i.default.extend({render:function(t){return t("div",{style:this.styles,class:this.cssClasses},[t("canvas",{attrs:{id:this.chartId,width:this.width,height:this.height},ref:"canvas"})])},props:{chartId:{default:"scatter-chart",type:String},width:{default:400,type:Number},height:{default:400,type:Number},cssClasses:{type:String,default:""},styles:{type:Object}},data:function(){return{defaultOptions:{scales:{xAxes:[{type:"linear",position:"bottom"}]}},plugins:[]}},methods:{addPlugin:function(t){this.plugins.push(t)},renderChart:function(t,e){var r=(0,o.mergeOptions)(this.defaultOptions,e);this._chart=new u.default(this.$refs.canvas.getContext("2d"),{type:"scatter",data:t,options:r,plugins:this.plugins})}},beforeDestroy:function(){this._chart&&this._chart.destroy()}})},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}Object.defineProperty(e,"__esModule",{value:!0});var a=r(24),i=n(a),s=r(25),u=n(s);e.default={reactiveData:i.default,reactiveProp:u.default}},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}var a=r(10),i=n(a),s=r(9),u=n(s);t.exports={data:function(){return{chartData:null}},watch:{chartData:{handler:function(t,e){if(e){var r=this._chart,n=t.datasets.map(function(t){return t.label}),a=e.datasets.map(function(t){return t.label}),s=(0,u.default)(a),o=(0,u.default)(n);o===s&&e.datasets.length===t.datasets.length?(t.datasets.forEach(function(t,n){var a=(0,i.default)(e.datasets[n]),s=(0,i.default)(t),u=a.filter(function(t){return"_meta"!==t&&s.indexOf(t)===-1});u.forEach(function(t){delete r.data.datasets[n][t]});for(var o in t)t.hasOwnProperty(o)&&(r.data.datasets[n][o]=t[o])}),t.hasOwnProperty("labels")&&(r.data.labels=t.labels),t.hasOwnProperty("xLabels")&&(r.data.xLabels=t.xLabels),t.hasOwnProperty("yLabels")&&(r.data.yLabels=t.yLabels),r.update()):(r.destroy(),this.renderChart(this.chartData,this.options))}else this.renderChart(this.chartData,this.options)}}}}},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{default:t}}var a=r(10),i=n(a),s=r(9),u=n(s);t.exports={props:{chartData:{required:!0}},watch:{chartData:{handler:function(t,e){if(e){var r=this._chart,n=t.datasets.map(function(t){return t.label}),a=e.datasets.map(function(t){return t.label}),s=(0,u.default)(a),o=(0,u.default)(n);o===s&&e.datasets.length===t.datasets.length?(t.datasets.forEach(function(t,n){var a=(0,i.default)(e.datasets[n]),s=(0,i.default)(t),u=a.filter(function(t){return"_meta"!==t&&s.indexOf(t)===-1});u.forEach(function(t){delete r.data.datasets[n][t]});for(var o in t)t.hasOwnProperty(o)&&(r.data.datasets[n][o]=t[o])}),t.hasOwnProperty("labels")&&(r.data.labels=t.labels),t.hasOwnProperty("xLabels")&&(r.data.xLabels=t.xLabels),t.hasOwnProperty("yLabels")&&(r.data.yLabels=t.yLabels),r.update()):(r.destroy(),this.renderChart(this.chartData,this.options))}else this.renderChart(this.chartData,this.options)}}}}},function(t,e,r){var n=r(4),a=n.JSON||(n.JSON={stringify:JSON.stringify});t.exports=function(t){return a.stringify.apply(a,arguments)}},function(t,e,r){r(52),t.exports=r(4).Object.keys},function(t,e){t.exports=function(t){if("function"!=typeof t)throw TypeError(t+" is not a function!");return t}},function(t,e,r){var n=r(8);t.exports=function(t){if(!n(t))throw TypeError(t+" is not an object!");return t}},function(t,e,r){var n=r(13),a=r(48),i=r(47);t.exports=function(t){return function(e,r,s){var u,o=n(e),c=a(o.length),l=i(s,c);if(t&&r!=r){for(;c>l;)if(u=o[l++],u!=u)return!0}else for(;c>l;l++)if((t||l in o)&&o[l]===r)return t||l||0;return!t&&-1}}},function(t,e){var r={}.toString;t.exports=function(t){return r.call(t).slice(8,-1)}},function(t,e,r){var n=r(28);t.exports=function(t,e,r){if(n(t),void 0===e)return t;switch(r){case 1:return function(r){return t.call(e,r)};case 2:return function(r,n){return t.call(e,r,n)};case 3:return function(r,n,a){return t.call(e,r,n,a)}}return function(){return t.apply(e,arguments)}}},function(t,e,r){var n=r(8),a=r(7).document,i=n(a)&&n(a.createElement);t.exports=function(t){return i?a.createElement(t):{}}},function(t,e){t.exports="constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(",")},function(t,e,r){var n=r(7),a=r(4),i=r(32),s=r(37),u="prototype",o=function(t,e,r){var c,l,f,d=t&o.F,h=t&o.G,p=t&o.S,y=t&o.P,b=t&o.B,v=t&o.W,g=h?a:a[e]||(a[e]={}),_=g[u],m=h?n:p?n[e]:(n[e]||{})[u];h&&(r=e);for(c in r)l=!d&&m&&void 0!==m[c],l&&c in g||(f=l?m[c]:r[c],g[c]=h&&"function"!=typeof m[c]?r[c]:b&&l?i(f,n):v&&m[c]==f?function(t){var e=function(e,r,n){if(this instanceof t){switch(arguments.length){case 0:return new t;case 1:return new t(e);case 2:return new t(e,r)}return new t(e,r,n)}return t.apply(this,arguments)};return e[u]=t[u],e}(f):y&&"function"==typeof f?i(Function.call,f):f,y&&((g.virtual||(g.virtual={}))[c]=f,t&o.R&&_&&!_[c]&&s(_,c,f)))};o.F=1,o.G=2,o.S=4,o.P=8,o.B=16,o.W=32,o.U=64,o.R=128,t.exports=o},function(t,e){var r={}.hasOwnProperty;t.exports=function(t,e){return r.call(t,e)}},function(t,e,r){var n=r(40),a=r(44);t.exports=r(5)?function(t,e,r){return n.f(t,e,a(1,r))}:function(t,e,r){return t[e]=r,t}},function(t,e,r){t.exports=!r(5)&&!r(6)(function(){return 7!=Object.defineProperty(r(33)("div"),"a",{get:function(){return 7}}).a})},function(t,e,r){var n=r(31);t.exports=Object("z").propertyIsEnumerable(0)?Object:function(t){return"String"==n(t)?t.split(""):Object(t)}},function(t,e,r){var n=r(29),a=r(38),i=r(50),s=Object.defineProperty;e.f=r(5)?Object.defineProperty:function(t,e,r){if(n(t),e=i(e,!0),n(r),a)try{return s(t,e,r)}catch(t){}if("get"in r||"set"in r)throw TypeError("Accessors not supported!");return"value"in r&&(t[e]=r.value),t}},function(t,e,r){var n=r(36),a=r(13),i=r(30)(!1),s=r(45)("IE_PROTO");t.exports=function(t,e){var r,u=a(t),o=0,c=[];for(r in u)r!=s&&n(u,r)&&c.push(r);for(;e.length>o;)n(u,r=e[o++])&&(~i(c,r)||c.push(r));return c}},function(t,e,r){var n=r(41),a=r(34);t.exports=Object.keys||function(t){return n(t,a)}},function(t,e,r){var n=r(35),a=r(4),i=r(6);t.exports=function(t,e){var r=(a.Object||{})[t]||Object[t],s={};s[t]=e(r),n(n.S+n.F*i(function(){r(1)}),"Object",s)}},function(t,e){t.exports=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}}},function(t,e,r){var n=r(46)("keys"),a=r(51);t.exports=function(t){return n[t]||(n[t]=a(t))}},function(t,e,r){var n=r(7),a="__core-js_shared__",i=n[a]||(n[a]={});t.exports=function(t){return i[t]||(i[t]={})}},function(t,e,r){var n=r(12),a=Math.max,i=Math.min;t.exports=function(t,e){return t=n(t),t<0?a(t+e,0):i(t,e)}},function(t,e,r){var n=r(12),a=Math.min;t.exports=function(t){return t>0?a(n(t),9007199254740991):0}},function(t,e,r){var n=r(11);t.exports=function(t){return Object(n(t))}},function(t,e,r){var n=r(8);t.exports=function(t,e){if(!n(t))return t;var r,a;if(e&&"function"==typeof(r=t.toString)&&!n(a=r.call(t)))return a;if("function"==typeof(r=t.valueOf)&&!n(a=r.call(t)))return a;if(!e&&"function"==typeof(r=t.toString)&&!n(a=r.call(t)))return a;throw TypeError("Can't convert object to primitive value")}},function(t,e){var r=0,n=Math.random();t.exports=function(t){return"Symbol(".concat(void 0===t?"":t,")_",(++r+n).toString(36))}},function(t,e,r){var n=r(49),a=r(42);r(43)("keys",function(){return function(t){return a(n(t))}})},function(t,e){t.exports={name:"vue-chartjs",version:"2.8.7",description:"Vue.js wrapper for chart.js for creating beautiful charts.",author:"Jakub Juszczak <jakub@posteo.de>",homepage:"http://vue-chartjs.org",license:"MIT",contributors:[{name:"Thorsten Lünborg",web:"https://github.com/LinusBorg"},{name:"Juan Carlos Alonso",web:"https://github.com/jcalonso"}],maintainers:[{name:"Jakub Juszczak",email:"jakub@posteo.de",web:"http://www.jakubjuszczak.de"}],repository:{type:"git",url:"git+ssh://git@github.com:apertureless/vue-chartjs.git"},bugs:{url:"https://github.com/apertureless/vue-chartjs/issues"},keywords:["ChartJs","Vue","Visualisation","Wrapper","Charts"],main:"dist/vue-chartjs.js",unpkg:"dist/vue-chartjs.full.min.js",module:"es/index.js","jsnext:main":"es/index.js",files:["src","dist","es"],scripts:{dev:"node build/dev-server.js",build:"yarn run release && yarn run build:es","build:es":"cross-env BABEL_ENV=es babel src --out-dir es",unit:"karma start test/unit/karma.conf.js --single-run",e2e:"node test/e2e/runner.js",test:"npm run unit",lint:"eslint --ext .js,.vue src test/unit/specs test/e2e/specs",release:"webpack --progress --hide-modules --config  ./build/webpack.release.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.min.js && webpack --progress --hide-modules --config  ./build/webpack.release.full.js && NODE_ENV=production webpack --progress --hide-modules --config  ./build/webpack.release.full.min.js",prepublish:"yarn run lint && yarn run test && yarn run build"},dependencies:{"lodash.merge":"^4.6.0"},peerDependencies:{"chart.js":"^2.7.0",vue:"^2.4.4"},devDependencies:{"babel-cli":"^6.24.1","babel-core":"^6.25.0","babel-loader":"^7.0.0","babel-plugin-transform-object-assign":"^6.22.0","babel-plugin-transform-runtime":"^6.23.0","babel-preset-es2015":"^6.24.1","babel-preset-stage-2":"^6.24.1","babel-runtime":"^6.23.0",chai:"^3.5.0","chart.js":"^2.7.0",chromedriver:"^2.28.0","connect-history-api-fallback":"^1.1.0","cross-env":"^3.2.4","cross-spawn":"^5.1.0","css-loader":"^0.28.0",eslint:"^3.19.0","eslint-config-standard":"^10.2.1","eslint-friendly-formatter":"^2.0.7","eslint-loader":"^1.7.1","eslint-plugin-html":"^2.0.1","eslint-plugin-import":"^2.2.0","eslint-plugin-node":"^4.2.2","eslint-plugin-promise":"^3.5.0","eslint-plugin-standard":"^3.0.1","eventsource-polyfill":"^0.9.6",express:"^4.15.2","extract-text-webpack-plugin":"^1.0.1","file-loader":"^0.10.1","function-bind":"^1.0.2","html-webpack-plugin":"^2.28.0","http-proxy-middleware":"^0.17.4","inject-loader":"^3.0.0","isparta-loader":"^2.0.0","jasmine-core":"^2.5.2","json-loader":"^0.5.4",karma:"^1.5.0","karma-coverage":"^1.1.1","karma-jasmine":"^1.0.2","karma-mocha":"^1.2.0","karma-phantomjs-launcher":"^1.0.4","karma-sinon-chai":"^1.2.0","karma-sourcemap-loader":"^0.3.7","karma-spec-reporter":"0.0.30","karma-webpack":"1.8.1",lolex:"^1.6.0",mocha:"^3.1.0",nightwatch:"^0.9.14",ora:"^1.2.0","phantomjs-prebuilt":"^2.1.13","selenium-server":"^3.3.1",shelljs:"^0.7.7",sinon:"^2.1.0","sinon-chai":"^2.9.0","url-loader":"^0.5.8",vue:"^2.4.4","vue-hot-reload-api":"^2.1.0","vue-html-loader":"^1.2.4","vue-loader":"^12.2.2","vue-style-loader":"^3.0.1","vue-template-compiler":"^2.4.2",webpack:"^1.13.2","webpack-dev-middleware":"^1.10.1","webpack-hot-middleware":"^2.17.1","webpack-merge":"1.1.1"},engines:{node:">=6.9.0"},babel:{presets:["es2015"]},browserify:{transform:["babelify"]},greenkeeper:{ignore:["extract-text-webpack-plugin","karma-webpack","webpack","webpack-merge"]}}},function(t,e,r){(function(t,r){function n(t,e){return t.set(e[0],e[1]),t}function a(t,e){return t.add(e),t}function i(t,e,r){switch(r.length){case 0:return t.call(e);case 1:return t.call(e,r[0]);case 2:return t.call(e,r[0],r[1]);case 3:return t.call(e,r[0],r[1],r[2])}return t.apply(e,r)}function s(t,e){for(var r=-1,n=t?t.length:0;++r<n&&e(t[r],r,t)!==!1;);return t}function u(t,e){for(var r=-1,n=e.length,a=t.length;++r<n;)t[a+r]=e[r];return t}function o(t,e,r,n){var a=-1,i=t?t.length:0;for(n&&i&&(r=t[++a]);++a<i;)r=e(r,t[a],a,t);return r}function c(t,e){for(var r=-1,n=Array(t);++r<t;)n[r]=e(r);return n}function l(t){return function(e){return t(e)}}function f(t,e){return null==t?void 0:t[e]}function d(t){var e=!1;if(null!=t&&"function"!=typeof t.toString)try{e=!!(t+"")}catch(t){}return e}function h(t){var e=-1,r=Array(t.size);return t.forEach(function(t,n){r[++e]=[n,t]}),r}function p(t,e){return function(r){return t(e(r))}}function y(t){var e=-1,r=Array(t.size);return t.forEach(function(t){r[++e]=t}),r}function b(t){var e=-1,r=t?t.length:0;for(this.clear();++e<r;){var n=t[e];this.set(n[0],n[1])}}function v(){this.__data__=ar?ar(null):{}}function g(t){return this.has(t)&&delete this.__data__[t]}function _(t){var e=this.__data__;if(ar){var r=e[t];return r===Ft?void 0:r}return ze.call(e,t)?e[t]:void 0}function m(t){var e=this.__data__;return ar?void 0!==e[t]:ze.call(e,t)}function j(t,e){var r=this.__data__;return r[t]=ar&&void 0===e?Ft:e,this}function w(t){var e=-1,r=t?t.length:0;for(this.clear();++e<r;){var n=t[e];this.set(n[0],n[1])}}function x(){this.__data__=[]}function O(t){var e=this.__data__,r=R(e,t);if(r<0)return!1;var n=e.length-1;return r==n?e.pop():Ge.call(e,r,1),!0}function P(t){var e=this.__data__,r=R(e,t);return r<0?void 0:e[r][1]}function k(t){return R(this.__data__,t)>-1}function C(t,e){var r=this.__data__,n=R(r,t);return n<0?r.push([t,e]):r[n][1]=e,this}function S(t){var e=-1,r=t?t.length:0;for(this.clear();++e<r;){var n=t[e];this.set(n[0],n[1])}}function A(){this.__data__={hash:new b,map:new(tr||w),string:new b}}function M(t){return yt(this,t).delete(t)}function I(t){return yt(this,t).get(t)}function L(t){return yt(this,t).has(t)}function N(t,e){return yt(this,t).set(t,e),this}function D(t){this.__data__=new w(t)}function E(){this.__data__=new w}function B(t){return this.__data__.delete(t)}function $(t){return this.__data__.get(t)}function z(t){return this.__data__.has(t)}function V(t,e){var r=this.__data__;if(r instanceof w){var n=r.__data__;if(!tr||n.length<Tt-1)return n.push([t,e]),this;r=this.__data__=new S(n)}return r.set(t,e),this}function J(t,e){var r=pr(t)||St(t)?c(t.length,String):[],n=r.length,a=!!n;for(var i in t)!e&&!ze.call(t,i)||a&&("length"==i||mt(i,n))||r.push(i);return r}function T(t,e,r){(void 0===r||Ct(t[e],r))&&("number"!=typeof e||void 0!==r||e in t)||(t[e]=r)}function F(t,e,r){var n=t[e];ze.call(t,e)&&Ct(n,r)&&(void 0!==r||e in t)||(t[e]=r)}function R(t,e){for(var r=t.length;r--;)if(Ct(t[r][0],e))return r;return-1}function U(t,e){return t&&ft(e,$t(e),t)}function q(t,e,r,n,a,i,u){var o;if(n&&(o=i?n(t,a,i,u):n(t)),void 0!==o)return o;if(!Nt(t))return t;var c=pr(t);if(c){if(o=vt(t),!e)return lt(t,o)}else{var l=hr(t),f=l==Ht||l==Kt;if(yr(t))return rt(t,e);if(l==Yt||l==Ut||f&&!i){if(d(t))return i?t:{};if(o=gt(f?{}:t),!e)return dt(t,U(o,t))}else{if(!we[l])return i?t:{};o=_t(t,l,q,e)}}u||(u=new D);var h=u.get(t);if(h)return h;if(u.set(t,o),!c)var p=r?pt(t):$t(t);return s(p||t,function(a,i){p&&(i=a,a=t[i]),F(o,i,q(a,e,r,n,i,t,u))}),o}function W(t){return Nt(t)?We(t):{}}function Z(t,e,r){var n=e(t);return pr(t)?n:u(n,r(t))}function G(t){return Je.call(t)}function H(t){if(!Nt(t)||xt(t))return!1;var e=It(t)||d(t)?Te:_e;return e.test(kt(t))}function K(t){return Dt(t)&&Lt(t.length)&&!!je[Je.call(t)]}function Q(t){if(!Ot(t))return Qe(t);var e=[];for(var r in Object(t))ze.call(t,r)&&"constructor"!=r&&e.push(r);return e}function X(t){if(!Nt(t))return Pt(t);var e=Ot(t),r=[];for(var n in t)("constructor"!=n||!e&&ze.call(t,n))&&r.push(n);return r}function Y(t,e,r,n,a){if(t!==e){if(!pr(e)&&!br(e))var i=X(e);s(i||e,function(s,u){if(i&&(u=s,s=e[u]),Nt(s))a||(a=new D),tt(t,e,u,r,Y,n,a);else{var o=n?n(t[u],s,u+"",t,e,a):void 0;void 0===o&&(o=s),T(t,u,o)}})}}function tt(t,e,r,n,a,i,s){var u=t[r],o=e[r],c=s.get(o);if(c)return void T(t,r,c);var l=i?i(u,o,r+"",t,e,s):void 0,f=void 0===l;f&&(l=o,pr(o)||br(o)?pr(u)?l=u:Mt(u)?l=lt(u):(f=!1,l=q(o,!0)):Et(o)||St(o)?St(u)?l=Bt(u):!Nt(u)||n&&It(u)?(f=!1,l=q(o,!0)):l=u:f=!1),f&&(s.set(o,l),a(l,o,n,i,s),s.delete(o)),T(t,r,l)}function et(t,e){return e=Xe(void 0===e?t.length-1:e,0),function(){for(var r=arguments,n=-1,a=Xe(r.length-e,0),s=Array(a);++n<a;)s[n]=r[e+n];n=-1;for(var u=Array(e+1);++n<e;)u[n]=r[n];return u[e]=s,i(t,this,u)}}function rt(t,e){if(e)return t.slice();var r=new t.constructor(t.length);return t.copy(r),r}function nt(t){var e=new t.constructor(t.byteLength);return new Ue(e).set(new Ue(t)),e}function at(t,e){var r=e?nt(t.buffer):t.buffer;return new t.constructor(r,t.byteOffset,t.byteLength)}function it(t,e,r){var a=e?r(h(t),!0):h(t);return o(a,n,new t.constructor)}function st(t){var e=new t.constructor(t.source,ge.exec(t));return e.lastIndex=t.lastIndex,e}function ut(t,e,r){var n=e?r(y(t),!0):y(t);return o(n,a,new t.constructor)}function ot(t){return fr?Object(fr.call(t)):{}}function ct(t,e){var r=e?nt(t.buffer):t.buffer;return new t.constructor(r,t.byteOffset,t.length)}function lt(t,e){var r=-1,n=t.length;for(e||(e=Array(n));++r<n;)e[r]=t[r];return e}function ft(t,e,r,n){r||(r={});for(var a=-1,i=e.length;++a<i;){var s=e[a],u=n?n(r[s],t[s],s,r,t):void 0;F(r,s,void 0===u?t[s]:u)}return r}function dt(t,e){return ft(t,dr(t),e)}function ht(t){return et(function(e,r){var n=-1,a=r.length,i=a>1?r[a-1]:void 0,s=a>2?r[2]:void 0;for(i=t.length>3&&"function"==typeof i?(a--,i):void 0,s&&jt(r[0],r[1],s)&&(i=a<3?void 0:i,a=1),e=Object(e);++n<a;){var u=r[n];u&&t(e,u,n,i)}return e})}function pt(t){return Z(t,$t,dr)}function yt(t,e){var r=t.__data__;return wt(e)?r["string"==typeof e?"string":"hash"]:r.map}function bt(t,e){var r=f(t,e);return H(r)?r:void 0}function vt(t){var e=t.length,r=t.constructor(e);return e&&"string"==typeof t[0]&&ze.call(t,"index")&&(r.index=t.index,r.input=t.input),r}function gt(t){return"function"!=typeof t.constructor||Ot(t)?{}:W(qe(t))}function _t(t,e,r,n){var a=t.constructor;switch(e){case se:return nt(t);case Wt:case Zt:return new a(+t);case ue:return at(t,n);case oe:case ce:case le:case fe:case de:case he:case pe:case ye:case be:return ct(t,n);case Qt:return it(t,n,r);case Xt:case ne:return new a(t);case ee:return st(t);case re:return ut(t,n,r);case ae:return ot(t)}}function mt(t,e){return e=null==e?Rt:e,!!e&&("number"==typeof t||me.test(t))&&t>-1&&t%1==0&&t<e}function jt(t,e,r){if(!Nt(r))return!1;var n=typeof e;return!!("number"==n?At(r)&&mt(e,r.length):"string"==n&&e in r)&&Ct(r[e],t)}function wt(t){var e=typeof t;return"string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t}function xt(t){return!!Be&&Be in t}function Ot(t){var e=t&&t.constructor,r="function"==typeof e&&e.prototype||De;return t===r}function Pt(t){var e=[];if(null!=t)for(var r in Object(t))e.push(r);return e}function kt(t){if(null!=t){try{return $e.call(t)}catch(t){}try{return t+""}catch(t){}}return""}function Ct(t,e){return t===e||t!==t&&e!==e}function St(t){return Mt(t)&&ze.call(t,"callee")&&(!Ze.call(t,"callee")||Je.call(t)==Ut)}function At(t){return null!=t&&Lt(t.length)&&!It(t)}function Mt(t){return Dt(t)&&At(t)}function It(t){var e=Nt(t)?Je.call(t):"";return e==Ht||e==Kt}function Lt(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=Rt}function Nt(t){var e=typeof t;return!!t&&("object"==e||"function"==e)}function Dt(t){return!!t&&"object"==typeof t}function Et(t){if(!Dt(t)||Je.call(t)!=Yt||d(t))return!1;var e=qe(t);if(null===e)return!0;var r=ze.call(e,"constructor")&&e.constructor;return"function"==typeof r&&r instanceof r&&$e.call(r)==Ve}function Bt(t){return ft(t,zt(t))}function $t(t){return At(t)?J(t):Q(t)}function zt(t){return At(t)?J(t,!0):X(t)}function Vt(){return[]}function Jt(){return!1}var Tt=200,Ft="__lodash_hash_undefined__",Rt=9007199254740991,Ut="[object Arguments]",qt="[object Array]",Wt="[object Boolean]",Zt="[object Date]",Gt="[object Error]",Ht="[object Function]",Kt="[object GeneratorFunction]",Qt="[object Map]",Xt="[object Number]",Yt="[object Object]",te="[object Promise]",ee="[object RegExp]",re="[object Set]",ne="[object String]",ae="[object Symbol]",ie="[object WeakMap]",se="[object ArrayBuffer]",ue="[object DataView]",oe="[object Float32Array]",ce="[object Float64Array]",le="[object Int8Array]",fe="[object Int16Array]",de="[object Int32Array]",he="[object Uint8Array]",pe="[object Uint8ClampedArray]",ye="[object Uint16Array]",be="[object Uint32Array]",ve=/[\\^$.*+?()[\]{}|]/g,ge=/\w*$/,_e=/^\[object .+?Constructor\]$/,me=/^(?:0|[1-9]\d*)$/,je={};je[oe]=je[ce]=je[le]=je[fe]=je[de]=je[he]=je[pe]=je[ye]=je[be]=!0,je[Ut]=je[qt]=je[se]=je[Wt]=je[ue]=je[Zt]=je[Gt]=je[Ht]=je[Qt]=je[Xt]=je[Yt]=je[ee]=je[re]=je[ne]=je[ie]=!1;var we={};we[Ut]=we[qt]=we[se]=we[ue]=we[Wt]=we[Zt]=we[oe]=we[ce]=we[le]=we[fe]=we[de]=we[Qt]=we[Xt]=we[Yt]=we[ee]=we[re]=we[ne]=we[ae]=we[he]=we[pe]=we[ye]=we[be]=!0,we[Gt]=we[Ht]=we[ie]=!1;var xe="object"==typeof t&&t&&t.Object===Object&&t,Oe="object"==typeof self&&self&&self.Object===Object&&self,Pe=xe||Oe||Function("return this")(),ke="object"==typeof e&&e&&!e.nodeType&&e,Ce=ke&&"object"==typeof r&&r&&!r.nodeType&&r,Se=Ce&&Ce.exports===ke,Ae=Se&&xe.process,Me=function(){try{return Ae&&Ae.binding("util")}catch(t){}}(),Ie=Me&&Me.isTypedArray,Le=Array.prototype,Ne=Function.prototype,De=Object.prototype,Ee=Pe["__core-js_shared__"],Be=function(){var t=/[^.]+$/.exec(Ee&&Ee.keys&&Ee.keys.IE_PROTO||"");return t?"Symbol(src)_1."+t:""}(),$e=Ne.toString,ze=De.hasOwnProperty,Ve=$e.call(Object),Je=De.toString,Te=RegExp("^"+$e.call(ze).replace(ve,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),Fe=Se?Pe.Buffer:void 0,Re=Pe.Symbol,Ue=Pe.Uint8Array,qe=p(Object.getPrototypeOf,Object),We=Object.create,Ze=De.propertyIsEnumerable,Ge=Le.splice,He=Object.getOwnPropertySymbols,Ke=Fe?Fe.isBuffer:void 0,Qe=p(Object.keys,Object),Xe=Math.max,Ye=bt(Pe,"DataView"),tr=bt(Pe,"Map"),er=bt(Pe,"Promise"),rr=bt(Pe,"Set"),nr=bt(Pe,"WeakMap"),ar=bt(Object,"create"),ir=kt(Ye),sr=kt(tr),ur=kt(er),or=kt(rr),cr=kt(nr),lr=Re?Re.prototype:void 0,fr=lr?lr.valueOf:void 0;b.prototype.clear=v,b.prototype.delete=g,b.prototype.get=_,b.prototype.has=m,b.prototype.set=j,w.prototype.clear=x,w.prototype.delete=O,w.prototype.get=P,w.prototype.has=k,w.prototype.set=C,S.prototype.clear=A,S.prototype.delete=M,
+S.prototype.get=I,S.prototype.has=L,S.prototype.set=N,D.prototype.clear=E,D.prototype.delete=B,D.prototype.get=$,D.prototype.has=z,D.prototype.set=V;var dr=He?p(He,Object):Vt,hr=G;(Ye&&hr(new Ye(new ArrayBuffer(1)))!=ue||tr&&hr(new tr)!=Qt||er&&hr(er.resolve())!=te||rr&&hr(new rr)!=re||nr&&hr(new nr)!=ie)&&(hr=function(t){var e=Je.call(t),r=e==Yt?t.constructor:void 0,n=r?kt(r):void 0;if(n)switch(n){case ir:return ue;case sr:return Qt;case ur:return te;case or:return re;case cr:return ie}return e});var pr=Array.isArray,yr=Ke||Jt,br=Ie?l(Ie):K,vr=ht(function(t,e,r){Y(t,e,r)});r.exports=vr}).call(e,function(){return this}(),r(55)(t))},function(t,e){t.exports=function(t){return t.webpackPolyfill||(t.deprecate=function(){},t.paths=[],t.children=[],t.webpackPolyfill=1),t}}])});
\ No newline at end of file