From 67cf954ad1ef4cc9a7220a4224ddd9bc11922a53 Mon Sep 17 00:00:00 2001
From: Alex de Mulder <alexdemulder@gmail.com>
Date: Wed, 13 May 2015 14:34:27 +0200
Subject: [PATCH] enabled bar style in legend

---
 dist/vis.js                          | 11847 ++++++++++++-------------
 lib/timeline/component/GraphGroup.js |     4 +-
 2 files changed, 5925 insertions(+), 5926 deletions(-)

diff --git a/dist/vis.js b/dist/vis.js
index b89c1f8b..45606dba 100644
--- a/dist/vis.js
+++ b/dist/vis.js
@@ -3140,7 +3140,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
   'use strict';
 
-  var Emitter = __webpack_require__(69);
+  var Emitter = __webpack_require__(43);
   var DataSet = __webpack_require__(3);
   var DataView = __webpack_require__(4);
   var util = __webpack_require__(1);
@@ -6303,21 +6303,21 @@ return /******/ (function(modules) { // webpackBootstrap
 
   'use strict';
 
-  var Emitter = __webpack_require__(69);
+  var Emitter = __webpack_require__(43);
   var Hammer = __webpack_require__(41);
   var util = __webpack_require__(1);
   var DataSet = __webpack_require__(3);
   var DataView = __webpack_require__(4);
   var Range = __webpack_require__(17);
-  var Core = __webpack_require__(43);
+  var Core = __webpack_require__(44);
   var TimeAxis = __webpack_require__(35);
   var CurrentTime = __webpack_require__(26);
   var CustomTime = __webpack_require__(27);
   var ItemSet = __webpack_require__(32);
 
-  var ConfigurationSystem = __webpack_require__(44);
-  var Validator = __webpack_require__(45)['default'];
-  var printStyle = __webpack_require__(45).printStyle;
+  var ConfigurationSystem = __webpack_require__(45);
+  var Validator = __webpack_require__(46)['default'];
+  var printStyle = __webpack_require__(46).printStyle;
   var allOptions = __webpack_require__(47).allOptions;
   var configureOptions = __webpack_require__(47).configureOptions;
 
@@ -6742,23 +6742,23 @@ return /******/ (function(modules) { // webpackBootstrap
 
   'use strict';
 
-  var Emitter = __webpack_require__(69);
+  var Emitter = __webpack_require__(43);
   var Hammer = __webpack_require__(41);
   var util = __webpack_require__(1);
   var DataSet = __webpack_require__(3);
   var DataView = __webpack_require__(4);
   var Range = __webpack_require__(17);
-  var Core = __webpack_require__(43);
+  var Core = __webpack_require__(44);
   var TimeAxis = __webpack_require__(35);
   var CurrentTime = __webpack_require__(26);
   var CustomTime = __webpack_require__(27);
   var LineGraph = __webpack_require__(34);
 
-  var ConfigurationSystem = __webpack_require__(44);
-  var Validator = __webpack_require__(45)['default'];
-  var printStyle = __webpack_require__(45).printStyle;
-  var allOptions = __webpack_require__(46).allOptions;
-  var configureOptions = __webpack_require__(46).configureOptions;
+  var ConfigurationSystem = __webpack_require__(45);
+  var Validator = __webpack_require__(46)['default'];
+  var printStyle = __webpack_require__(46).printStyle;
+  var allOptions = __webpack_require__(48).allOptions;
+  var configureOptions = __webpack_require__(48).configureOptions;
 
   /**
    * Create a timeline visualization
@@ -7752,7 +7752,7 @@ return /******/ (function(modules) { // webpackBootstrap
   'use strict';
 
   var util = __webpack_require__(1);
-  var hammerUtil = __webpack_require__(48);
+  var hammerUtil = __webpack_require__(49);
   var moment = __webpack_require__(40);
   var Component = __webpack_require__(25);
   var DateUtil = __webpack_require__(15);
@@ -10500,7 +10500,7 @@ return /******/ (function(modules) { // webpackBootstrap
   var util = __webpack_require__(1);
   var Component = __webpack_require__(25);
   var moment = __webpack_require__(40);
-  var locales = __webpack_require__(49);
+  var locales = __webpack_require__(50);
 
   /**
    * A current time bar
@@ -10677,7 +10677,7 @@ return /******/ (function(modules) { // webpackBootstrap
   var util = __webpack_require__(1);
   var Component = __webpack_require__(25);
   var moment = __webpack_require__(40);
-  var locales = __webpack_require__(49);
+  var locales = __webpack_require__(50);
 
   /**
    * A custom time bar
@@ -11519,8 +11519,8 @@ return /******/ (function(modules) { // webpackBootstrap
   var util = __webpack_require__(1);
   var DOMutil = __webpack_require__(2);
   var Line = __webpack_require__(51);
-  var Bar = __webpack_require__(50);
-  var Points = __webpack_require__(52);
+  var Bar = __webpack_require__(52);
+  var Points = __webpack_require__(53);
 
   /**
    * /**
@@ -11672,8 +11672,8 @@ return /******/ (function(modules) { // webpackBootstrap
 
       var offset = Math.round((iconWidth - 2 * barWidth) / 3);
 
-      DOMutil.drawBar(x + 0.5 * barWidth + offset, y + fillHeight - bar1Height - 1, barWidth, bar1Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer);
-      DOMutil.drawBar(x + 1.5 * barWidth + offset + 2, y + fillHeight - bar2Height - 1, barWidth, bar2Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer);
+      DOMutil.drawBar(x + 0.5 * barWidth + offset, y + fillHeight - bar1Height - 1, barWidth, bar1Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer, this.style);
+      DOMutil.drawBar(x + 1.5 * barWidth + offset + 2, y + fillHeight - bar2Height - 1, barWidth, bar2Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer, this.style);
     }
   };
 
@@ -14185,7 +14185,7 @@ return /******/ (function(modules) { // webpackBootstrap
   var DataAxis = __webpack_require__(28);
   var GraphGroup = __webpack_require__(29);
   var Legend = __webpack_require__(33);
-  var BarFunctions = __webpack_require__(50);
+  var BarFunctions = __webpack_require__(52);
   var LineFunctions = __webpack_require__(51);
 
   var UNGROUPED = '__ungrouped__'; // reserved group id for ungrouped items
@@ -15595,68 +15595,68 @@ return /******/ (function(modules) { // webpackBootstrap
 
   function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 
-  var _modulesGroups = __webpack_require__(53);
+  var _modulesGroups = __webpack_require__(54);
 
   var _modulesGroups2 = _interopRequireDefault(_modulesGroups);
 
-  var _modulesNodesHandler = __webpack_require__(54);
+  var _modulesNodesHandler = __webpack_require__(55);
 
   var _modulesNodesHandler2 = _interopRequireDefault(_modulesNodesHandler);
 
-  var _modulesEdgesHandler = __webpack_require__(55);
+  var _modulesEdgesHandler = __webpack_require__(56);
 
   var _modulesEdgesHandler2 = _interopRequireDefault(_modulesEdgesHandler);
 
-  var _modulesPhysicsEngine = __webpack_require__(56);
+  var _modulesPhysicsEngine = __webpack_require__(57);
 
   var _modulesPhysicsEngine2 = _interopRequireDefault(_modulesPhysicsEngine);
 
-  var _modulesClustering = __webpack_require__(57);
+  var _modulesClustering = __webpack_require__(58);
 
   var _modulesClustering2 = _interopRequireDefault(_modulesClustering);
 
-  var _modulesCanvasRenderer = __webpack_require__(58);
+  var _modulesCanvasRenderer = __webpack_require__(59);
 
   var _modulesCanvasRenderer2 = _interopRequireDefault(_modulesCanvasRenderer);
 
-  var _modulesCanvas = __webpack_require__(59);
+  var _modulesCanvas = __webpack_require__(60);
 
   var _modulesCanvas2 = _interopRequireDefault(_modulesCanvas);
 
-  var _modulesView = __webpack_require__(60);
+  var _modulesView = __webpack_require__(61);
 
   var _modulesView2 = _interopRequireDefault(_modulesView);
 
-  var _modulesInteractionHandler = __webpack_require__(61);
+  var _modulesInteractionHandler = __webpack_require__(62);
 
   var _modulesInteractionHandler2 = _interopRequireDefault(_modulesInteractionHandler);
 
-  var _modulesSelectionHandler = __webpack_require__(62);
+  var _modulesSelectionHandler = __webpack_require__(63);
 
   var _modulesSelectionHandler2 = _interopRequireDefault(_modulesSelectionHandler);
 
-  var _modulesLayoutEngine = __webpack_require__(63);
+  var _modulesLayoutEngine = __webpack_require__(64);
 
   var _modulesLayoutEngine2 = _interopRequireDefault(_modulesLayoutEngine);
 
-  var _modulesManipulationSystem = __webpack_require__(64);
+  var _modulesManipulationSystem = __webpack_require__(65);
 
   var _modulesManipulationSystem2 = _interopRequireDefault(_modulesManipulationSystem);
 
-  var _sharedConfigurationSystem = __webpack_require__(44);
+  var _sharedConfigurationSystem = __webpack_require__(45);
 
   var _sharedConfigurationSystem2 = _interopRequireDefault(_sharedConfigurationSystem);
 
-  var _sharedValidator = __webpack_require__(45);
+  var _sharedValidator = __webpack_require__(46);
 
   var _sharedValidator2 = _interopRequireDefault(_sharedValidator);
 
-  var _optionsJs = __webpack_require__(65);
+  var _optionsJs = __webpack_require__(66);
 
   // Load custom shapes into CanvasRenderingContext2D
-  __webpack_require__(66);
+  __webpack_require__(67);
 
-  var Emitter = __webpack_require__(69);
+  var Emitter = __webpack_require__(43);
   var Hammer = __webpack_require__(41);
   var util = __webpack_require__(1);
   var DataSet = __webpack_require__(3);
@@ -15664,8 +15664,8 @@ return /******/ (function(modules) { // webpackBootstrap
   var dotparser = __webpack_require__(38);
   var gephiParser = __webpack_require__(39);
   var Images = __webpack_require__(37);
-  var Activator = __webpack_require__(67);
-  var locales = __webpack_require__(68);
+  var Activator = __webpack_require__(68);
+  var locales = __webpack_require__(69);
 
   /**
    * @constructor Network
@@ -17145,7 +17145,7 @@ return /******/ (function(modules) { // webpackBootstrap
   // use this instance. Else, load via commonjs.
   'use strict';
 
-  module.exports = typeof window !== 'undefined' && window['moment'] || __webpack_require__(71);
+  module.exports = typeof window !== 'undefined' && window['moment'] || __webpack_require__(70);
 
 /***/ },
 /* 41 */
@@ -17156,8 +17156,8 @@ return /******/ (function(modules) { // webpackBootstrap
   'use strict';
 
   if (typeof window !== 'undefined') {
-    var propagating = __webpack_require__(72);
-    var Hammer = window['Hammer'] || __webpack_require__(70);
+    var propagating = __webpack_require__(71);
+    var Hammer = window['Hammer'] || __webpack_require__(72);
     module.exports = propagating(Hammer, {
       preventDefault: 'mouse'
     });
@@ -17387,18 +17387,188 @@ return /******/ (function(modules) { // webpackBootstrap
 /* 43 */
 /***/ function(module, exports, __webpack_require__) {
 
+  
+  /**
+   * Expose `Emitter`.
+   */
+
+  module.exports = Emitter;
+
+  /**
+   * Initialize a new `Emitter`.
+   *
+   * @api public
+   */
+
+  function Emitter(obj) {
+    if (obj) return mixin(obj);
+  };
+
+  /**
+   * Mixin the emitter properties.
+   *
+   * @param {Object} obj
+   * @return {Object}
+   * @api private
+   */
+
+  function mixin(obj) {
+    for (var key in Emitter.prototype) {
+      obj[key] = Emitter.prototype[key];
+    }
+    return obj;
+  }
+
+  /**
+   * Listen on the given `event` with `fn`.
+   *
+   * @param {String} event
+   * @param {Function} fn
+   * @return {Emitter}
+   * @api public
+   */
+
+  Emitter.prototype.on =
+  Emitter.prototype.addEventListener = function(event, fn){
+    this._callbacks = this._callbacks || {};
+    (this._callbacks[event] = this._callbacks[event] || [])
+      .push(fn);
+    return this;
+  };
+
+  /**
+   * Adds an `event` listener that will be invoked a single
+   * time then automatically removed.
+   *
+   * @param {String} event
+   * @param {Function} fn
+   * @return {Emitter}
+   * @api public
+   */
+
+  Emitter.prototype.once = function(event, fn){
+    var self = this;
+    this._callbacks = this._callbacks || {};
+
+    function on() {
+      self.off(event, on);
+      fn.apply(this, arguments);
+    }
+
+    on.fn = fn;
+    this.on(event, on);
+    return this;
+  };
+
+  /**
+   * Remove the given callback for `event` or all
+   * registered callbacks.
+   *
+   * @param {String} event
+   * @param {Function} fn
+   * @return {Emitter}
+   * @api public
+   */
+
+  Emitter.prototype.off =
+  Emitter.prototype.removeListener =
+  Emitter.prototype.removeAllListeners =
+  Emitter.prototype.removeEventListener = function(event, fn){
+    this._callbacks = this._callbacks || {};
+
+    // all
+    if (0 == arguments.length) {
+      this._callbacks = {};
+      return this;
+    }
+
+    // specific event
+    var callbacks = this._callbacks[event];
+    if (!callbacks) return this;
+
+    // remove all handlers
+    if (1 == arguments.length) {
+      delete this._callbacks[event];
+      return this;
+    }
+
+    // remove specific handler
+    var cb;
+    for (var i = 0; i < callbacks.length; i++) {
+      cb = callbacks[i];
+      if (cb === fn || cb.fn === fn) {
+        callbacks.splice(i, 1);
+        break;
+      }
+    }
+    return this;
+  };
+
+  /**
+   * Emit `event` with the given args.
+   *
+   * @param {String} event
+   * @param {Mixed} ...
+   * @return {Emitter}
+   */
+
+  Emitter.prototype.emit = function(event){
+    this._callbacks = this._callbacks || {};
+    var args = [].slice.call(arguments, 1)
+      , callbacks = this._callbacks[event];
+
+    if (callbacks) {
+      callbacks = callbacks.slice(0);
+      for (var i = 0, len = callbacks.length; i < len; ++i) {
+        callbacks[i].apply(this, args);
+      }
+    }
+
+    return this;
+  };
+
+  /**
+   * Return array of callbacks for `event`.
+   *
+   * @param {String} event
+   * @return {Array}
+   * @api public
+   */
+
+  Emitter.prototype.listeners = function(event){
+    this._callbacks = this._callbacks || {};
+    return this._callbacks[event] || [];
+  };
+
+  /**
+   * Check if this emitter has `event` handlers.
+   *
+   * @param {String} event
+   * @return {Boolean}
+   * @api public
+   */
+
+  Emitter.prototype.hasListeners = function(event){
+    return !! this.listeners(event).length;
+  };
+
+
+/***/ },
+/* 44 */
+/***/ function(module, exports, __webpack_require__) {
+
   'use strict';
 
-  var Emitter = __webpack_require__(69);
+  var Emitter = __webpack_require__(43);
   var Hammer = __webpack_require__(41);
-  var hammerUtil = __webpack_require__(48);
+  var hammerUtil = __webpack_require__(49);
   var util = __webpack_require__(1);
   var DataSet = __webpack_require__(3);
   var DataView = __webpack_require__(4);
   var Range = __webpack_require__(17);
   var ItemSet = __webpack_require__(32);
   var TimeAxis = __webpack_require__(35);
-  var Activator = __webpack_require__(67);
+  var Activator = __webpack_require__(68);
   var DateUtil = __webpack_require__(15);
   var CustomTime = __webpack_require__(27);
 
@@ -18351,7 +18521,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = Core;
 
 /***/ },
-/* 44 */
+/* 45 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -19008,7 +19178,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 45 */
+/* 46 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -19321,7 +19491,7 @@ return /******/ (function(modules) { // webpackBootstrap
   // item is a function, which is allowed
 
 /***/ },
-/* 46 */
+/* 47 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -19358,79 +19528,17 @@ return /******/ (function(modules) { // webpackBootstrap
     },
 
     //globals :
-    yAxisOrientation: { string: ['left', 'right'] },
-    defaultGroup: { string: string },
-    sort: { boolean: boolean },
-    sampling: { boolean: boolean },
-    stack: { boolean: boolean },
-    graphHeight: { string: string, number: number },
-    shaded: {
-      enabled: { boolean: boolean },
-      orientation: { string: ['bottom', 'top'] }, // top, bottom
-      __type__: { boolean: boolean, object: object }
-    },
-    style: { string: ['line', 'bar', 'points'] }, // line, bar
-    barChart: {
-      width: { number: number },
-      sideBySide: { boolean: boolean },
-      align: { string: ['left', 'center', 'right'] },
-      __type__: { object: object }
-    },
-    interpolation: {
-      enabled: { boolean: boolean },
-      parametrization: { string: ['centripetal', 'chordal', 'uniform'] }, // uniform (alpha = 0.0), chordal (alpha = 1.0), centripetal (alpha = 0.5)
-      alpha: { number: number },
-      __type__: { object: object, boolean: boolean }
-    },
-    drawPoints: {
-      enabled: { boolean: boolean },
-      size: { number: number },
-      style: { string: ['square', 'circle'] }, // square, circle
-      __type__: { object: object, boolean: boolean }
-    },
-    dataAxis: {
-      showMinorLabels: { boolean: boolean },
-      showMajorLabels: { boolean: boolean },
-      icons: { boolean: boolean },
-      width: { string: string, number: number },
-      visible: { boolean: boolean },
-      alignZeros: { boolean: boolean },
-      left: {
-        range: { min: { number: number }, max: { number: number }, __type__: { object: object } },
-        format: { fn: fn },
-        title: { text: { string: string, number: number }, style: { string: string }, __type__: { object: object } },
-        __type__: { object: object }
-      },
-      right: {
-        range: { min: { number: number }, max: { number: number }, __type__: { object: object } },
-        format: { fn: fn },
-        title: { text: { string: string, number: number }, style: { string: string }, __type__: { object: object } },
-        __type__: { object: object }
-      },
-      __type__: { object: object }
-    },
-    legend: {
-      enabled: { boolean: boolean },
-      icons: { boolean: boolean },
-      left: {
-        visible: { boolean: boolean },
-        position: { string: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] },
-        __type__: { object: object }
-      },
-      right: {
-        visible: { boolean: boolean },
-        position: { string: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] },
-        __type__: { object: object }
-      },
-      __type__: { object: object, boolean: boolean }
-    },
-    groups: {
-      visibility: { any: any },
-      __type__: { object: object }
-    },
-
+    align: { string: string },
     autoResize: { boolean: boolean },
     clickToUse: { boolean: boolean },
+    dataAttributes: { string: string, array: array },
+    editable: {
+      add: { boolean: boolean, undef: undef },
+      remove: { boolean: boolean, undef: undef },
+      updateGroup: { boolean: boolean, undef: undef },
+      updateTime: { boolean: boolean, undef: undef },
+      __type__: { boolean: boolean, object: object }
+    },
     end: { number: number, date: date, string: string, moment: moment },
     format: {
       minorLabels: {
@@ -19457,6 +19565,7 @@ return /******/ (function(modules) { // webpackBootstrap
       },
       __type__: { object: object }
     },
+    groupOrder: { string: string, fn: fn },
     height: { string: string, number: number },
     hiddenDates: { object: object, array: array },
     locale: { string: string },
@@ -19464,87 +19573,66 @@ return /******/ (function(modules) { // webpackBootstrap
       __any__: { object: object },
       __type__: { object: object }
     },
+    margin: {
+      axis: { number: number },
+      item: {
+        horizontal: { number: number, undef: undef },
+        vertical: { number: number, undef: undef },
+        __type__: { object: object, number: number }
+      },
+      __type__: { object: object, number: number }
+    },
     max: { date: date, number: number, string: string, moment: moment },
     maxHeight: { number: number, string: string },
     min: { date: date, number: number, string: string, moment: moment },
     minHeight: { number: number, string: string },
     moveable: { boolean: boolean },
     multiselect: { boolean: boolean },
-    orientation: { string: string },
+    onAdd: { fn: fn },
+    onUpdate: { fn: fn },
+    onMove: { fn: fn },
+    onMoving: { fn: fn },
+    onRemove: { fn: fn },
+    order: { fn: fn },
+    orientation: {
+      axis: { string: string, undef: undef },
+      item: { string: string, undef: undef },
+      __type__: { string: string, object: object }
+    },
+    selectable: { boolean: boolean },
     showCurrentTime: { boolean: boolean },
     showMajorLabels: { boolean: boolean },
     showMinorLabels: { boolean: boolean },
+    stack: { boolean: boolean },
+    snap: { fn: fn, nada: nada },
     start: { date: date, number: number, string: string, moment: moment },
+    template: { fn: fn },
     timeAxis: {
       scale: { string: string, undef: undef },
       step: { number: number, undef: undef },
       __type__: { object: object }
     },
+    type: { string: string },
     width: { string: string, number: number },
     zoomable: { boolean: boolean },
     zoomMax: { number: number },
     zoomMin: { number: number },
+
     __type__: { object: object }
   };
 
   var configureOptions = {
     global: {
-      yAxisOrientation: ['left', 'right'],
-      sort: true,
-      sampling: true,
-      stack: false,
-      shaded: {
-        enabled: false,
-        orientation: ['top', 'bottom'] // top, bottom
-      },
-      style: ['line', 'bar', 'points'], // line, bar
-      barChart: {
-        width: [50, 5, 100, 5],
-        sideBySide: false,
-        align: ['left', 'center', 'right'] // left, center, right
-      },
-      interpolation: {
-        enabled: true,
-        parametrization: ['centripetal', 'chordal', 'uniform'] // uniform (alpha = 0.0), chordal (alpha = 1.0), centripetal (alpha = 0.5)
-      },
-      drawPoints: {
-        enabled: true,
-        size: [6, 2, 30, 1],
-        style: 'square' // square, circle
-      },
-      dataAxis: {
-        showMinorLabels: true,
-        showMajorLabels: true,
-        icons: false,
-        width: [40, 0, 200, 1],
-        visible: true,
-        alignZeros: true,
-        left: {
-          //range: {min:undefined,max:undefined},
-          //format: function (value) {return value;},
-          title: { text: '', style: '' }
-        },
-        right: {
-          //range: {min:undefined,max:undefined},
-          //format: function (value) {return value;},
-          title: { text: '', style: '' }
-        }
-      },
-      legend: {
-        enabled: false,
-        icons: true,
-        left: {
-          visible: true,
-          position: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] // top/bottom - left,right
-        },
-        right: {
-          visible: true,
-          position: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] // top/bottom - left,right
-        }
-      },
-
+      align: ['center', 'left', 'right'],
       autoResize: true,
       clickToUse: false,
+      // dataAttributes: ['all'], // FIXME: can be 'all' or string[]
+      editable: {
+        add: false,
+        remove: false,
+        updateGroup: false,
+        updateTime: false
+      },
       end: '',
       format: {
         minorLabels: {
@@ -19569,18 +19657,46 @@ return /******/ (function(modules) { // webpackBootstrap
         }
       },
 
+      //groupOrder: {string, fn},
       height: '',
+      //hiddenDates: {object, array},
       locale: '',
+      margin: {
+        axis: [20, 0, 100, 1],
+        item: {
+          horizontal: [10, 0, 100, 1],
+          vertical: [10, 0, 100, 1]
+        }
+      },
       max: '',
       maxHeight: '',
       min: '',
       minHeight: '',
-      movable: true,
-      orientation: ['both', 'bottom', 'top'],
+      moveable: false,
+      multiselect: false,
+      //onAdd: {fn},
+      //onUpdate: {fn},
+      //onMove: {fn},
+      //onMoving: {fn},
+      //onRename: {fn},
+      //order: {fn},
+      orientation: {
+        axis: ['both', 'bottom', 'top'],
+        item: ['bottom', 'top']
+      },
+      selectable: true,
       showCurrentTime: false,
       showMajorLabels: true,
       showMinorLabels: true,
+      stack: true,
+      //snap: {fn, nada},
       start: '',
+      //template: {fn},
+      //timeAxis: {
+      //  scale: ['millisecond', 'second', 'minute', 'hour', 'weekday', 'day', 'month', 'year'],
+      //  step: [1, 1, 10, 1]
+      //},
+      type: ['box', 'point', 'range', 'background'],
       width: '100%',
       zoomable: true,
       zoomMax: [315360000000000, 10, 315360000000000, 1],
@@ -19592,7 +19708,7 @@ return /******/ (function(modules) { // webpackBootstrap
   exports.configureOptions = configureOptions;
 
 /***/ },
-/* 47 */
+/* 48 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -19629,17 +19745,79 @@ return /******/ (function(modules) { // webpackBootstrap
     },
 
     //globals :
-    align: { string: string },
-    autoResize: { boolean: boolean },
-    clickToUse: { boolean: boolean },
-    dataAttributes: { string: string, array: array },
-    editable: {
-      add: { boolean: boolean, undef: undef },
-      remove: { boolean: boolean, undef: undef },
-      updateGroup: { boolean: boolean, undef: undef },
-      updateTime: { boolean: boolean, undef: undef },
+    yAxisOrientation: { string: ['left', 'right'] },
+    defaultGroup: { string: string },
+    sort: { boolean: boolean },
+    sampling: { boolean: boolean },
+    stack: { boolean: boolean },
+    graphHeight: { string: string, number: number },
+    shaded: {
+      enabled: { boolean: boolean },
+      orientation: { string: ['bottom', 'top'] }, // top, bottom
       __type__: { boolean: boolean, object: object }
     },
+    style: { string: ['line', 'bar', 'points'] }, // line, bar
+    barChart: {
+      width: { number: number },
+      sideBySide: { boolean: boolean },
+      align: { string: ['left', 'center', 'right'] },
+      __type__: { object: object }
+    },
+    interpolation: {
+      enabled: { boolean: boolean },
+      parametrization: { string: ['centripetal', 'chordal', 'uniform'] }, // uniform (alpha = 0.0), chordal (alpha = 1.0), centripetal (alpha = 0.5)
+      alpha: { number: number },
+      __type__: { object: object, boolean: boolean }
+    },
+    drawPoints: {
+      enabled: { boolean: boolean },
+      size: { number: number },
+      style: { string: ['square', 'circle'] }, // square, circle
+      __type__: { object: object, boolean: boolean }
+    },
+    dataAxis: {
+      showMinorLabels: { boolean: boolean },
+      showMajorLabels: { boolean: boolean },
+      icons: { boolean: boolean },
+      width: { string: string, number: number },
+      visible: { boolean: boolean },
+      alignZeros: { boolean: boolean },
+      left: {
+        range: { min: { number: number }, max: { number: number }, __type__: { object: object } },
+        format: { fn: fn },
+        title: { text: { string: string, number: number }, style: { string: string }, __type__: { object: object } },
+        __type__: { object: object }
+      },
+      right: {
+        range: { min: { number: number }, max: { number: number }, __type__: { object: object } },
+        format: { fn: fn },
+        title: { text: { string: string, number: number }, style: { string: string }, __type__: { object: object } },
+        __type__: { object: object }
+      },
+      __type__: { object: object }
+    },
+    legend: {
+      enabled: { boolean: boolean },
+      icons: { boolean: boolean },
+      left: {
+        visible: { boolean: boolean },
+        position: { string: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] },
+        __type__: { object: object }
+      },
+      right: {
+        visible: { boolean: boolean },
+        position: { string: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] },
+        __type__: { object: object }
+      },
+      __type__: { object: object, boolean: boolean }
+    },
+    groups: {
+      visibility: { any: any },
+      __type__: { object: object }
+    },
+
+    autoResize: { boolean: boolean },
+    clickToUse: { boolean: boolean },
     end: { number: number, date: date, string: string, moment: moment },
     format: {
       minorLabels: {
@@ -19666,7 +19844,6 @@ return /******/ (function(modules) { // webpackBootstrap
       },
       __type__: { object: object }
     },
-    groupOrder: { string: string, fn: fn },
     height: { string: string, number: number },
     hiddenDates: { object: object, array: array },
     locale: { string: string },
@@ -19674,66 +19851,87 @@ return /******/ (function(modules) { // webpackBootstrap
       __any__: { object: object },
       __type__: { object: object }
     },
-    margin: {
-      axis: { number: number },
-      item: {
-        horizontal: { number: number, undef: undef },
-        vertical: { number: number, undef: undef },
-        __type__: { object: object, number: number }
-      },
-      __type__: { object: object, number: number }
-    },
     max: { date: date, number: number, string: string, moment: moment },
     maxHeight: { number: number, string: string },
     min: { date: date, number: number, string: string, moment: moment },
     minHeight: { number: number, string: string },
     moveable: { boolean: boolean },
     multiselect: { boolean: boolean },
-    onAdd: { fn: fn },
-    onUpdate: { fn: fn },
-    onMove: { fn: fn },
-    onMoving: { fn: fn },
-    onRemove: { fn: fn },
-    order: { fn: fn },
-    orientation: {
-      axis: { string: string, undef: undef },
-      item: { string: string, undef: undef },
-      __type__: { string: string, object: object }
-    },
-    selectable: { boolean: boolean },
+    orientation: { string: string },
     showCurrentTime: { boolean: boolean },
     showMajorLabels: { boolean: boolean },
     showMinorLabels: { boolean: boolean },
-    stack: { boolean: boolean },
-    snap: { fn: fn, nada: nada },
     start: { date: date, number: number, string: string, moment: moment },
-    template: { fn: fn },
     timeAxis: {
       scale: { string: string, undef: undef },
       step: { number: number, undef: undef },
       __type__: { object: object }
     },
-    type: { string: string },
     width: { string: string, number: number },
     zoomable: { boolean: boolean },
     zoomMax: { number: number },
     zoomMin: { number: number },
-
     __type__: { object: object }
   };
 
   var configureOptions = {
     global: {
-      align: ['center', 'left', 'right'],
+      yAxisOrientation: ['left', 'right'],
+      sort: true,
+      sampling: true,
+      stack: false,
+      shaded: {
+        enabled: false,
+        orientation: ['top', 'bottom'] // top, bottom
+      },
+      style: ['line', 'bar', 'points'], // line, bar
+      barChart: {
+        width: [50, 5, 100, 5],
+        sideBySide: false,
+        align: ['left', 'center', 'right'] // left, center, right
+      },
+      interpolation: {
+        enabled: true,
+        parametrization: ['centripetal', 'chordal', 'uniform'] // uniform (alpha = 0.0), chordal (alpha = 1.0), centripetal (alpha = 0.5)
+      },
+      drawPoints: {
+        enabled: true,
+        size: [6, 2, 30, 1],
+        style: 'square' // square, circle
+      },
+      dataAxis: {
+        showMinorLabels: true,
+        showMajorLabels: true,
+        icons: false,
+        width: [40, 0, 200, 1],
+        visible: true,
+        alignZeros: true,
+        left: {
+          //range: {min:undefined,max:undefined},
+          //format: function (value) {return value;},
+          title: { text: '', style: '' }
+        },
+        right: {
+          //range: {min:undefined,max:undefined},
+          //format: function (value) {return value;},
+          title: { text: '', style: '' }
+        }
+      },
+      legend: {
+        enabled: false,
+        icons: true,
+        left: {
+          visible: true,
+          position: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] // top/bottom - left,right
+        },
+        right: {
+          visible: true,
+          position: ['top-right', 'bottom-right', 'top-left', 'bottom-left'] // top/bottom - left,right
+        }
+      },
+
       autoResize: true,
       clickToUse: false,
-      // dataAttributes: ['all'], // FIXME: can be 'all' or string[]
-      editable: {
-        add: false,
-        remove: false,
-        updateGroup: false,
-        updateTime: false
-      },
       end: '',
       format: {
         minorLabels: {
@@ -19758,46 +19956,18 @@ return /******/ (function(modules) { // webpackBootstrap
         }
       },
 
-      //groupOrder: {string, fn},
       height: '',
-      //hiddenDates: {object, array},
       locale: '',
-      margin: {
-        axis: [20, 0, 100, 1],
-        item: {
-          horizontal: [10, 0, 100, 1],
-          vertical: [10, 0, 100, 1]
-        }
-      },
       max: '',
       maxHeight: '',
       min: '',
       minHeight: '',
-      moveable: false,
-      multiselect: false,
-      //onAdd: {fn},
-      //onUpdate: {fn},
-      //onMove: {fn},
-      //onMoving: {fn},
-      //onRename: {fn},
-      //order: {fn},
-      orientation: {
-        axis: ['both', 'bottom', 'top'],
-        item: ['bottom', 'top']
-      },
-      selectable: true,
+      movable: true,
+      orientation: ['both', 'bottom', 'top'],
       showCurrentTime: false,
       showMajorLabels: true,
       showMinorLabels: true,
-      stack: true,
-      //snap: {fn, nada},
       start: '',
-      //template: {fn},
-      //timeAxis: {
-      //  scale: ['millisecond', 'second', 'minute', 'hour', 'weekday', 'day', 'month', 'year'],
-      //  step: [1, 1, 10, 1]
-      //},
-      type: ['box', 'point', 'range', 'background'],
       width: '100%',
       zoomable: true,
       zoomMax: [315360000000000, 10, 315360000000000, 1],
@@ -19809,7 +19979,7 @@ return /******/ (function(modules) { // webpackBootstrap
   exports.configureOptions = configureOptions;
 
 /***/ },
-/* 48 */
+/* 49 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -19881,7 +20051,7 @@ return /******/ (function(modules) { // webpackBootstrap
   exports.offRelease = exports.offTouch;
 
 /***/ },
-/* 49 */
+/* 50 */
 /***/ function(module, exports, __webpack_require__) {
 
   // English
@@ -19902,255 +20072,6 @@ return /******/ (function(modules) { // webpackBootstrap
   exports['nl_NL'] = exports['nl'];
   exports['nl_BE'] = exports['nl'];
 
-/***/ },
-/* 50 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
-
-  var DOMutil = __webpack_require__(2);
-  var Points = __webpack_require__(52);
-
-  function Bargraph(groupId, options) {
-    this.groupId = groupId;
-    this.options = options;
-  }
-
-  Bargraph.prototype.getYRange = function (groupData) {
-    var yMin = groupData[0].y;
-    var yMax = groupData[0].y;
-    for (var j = 0; j < groupData.length; j++) {
-      yMin = yMin > groupData[j].y ? groupData[j].y : yMin;
-      yMax = yMax < groupData[j].y ? groupData[j].y : yMax;
-    }
-    return { min: yMin, max: yMax, yAxisOrientation: this.options.yAxisOrientation };
-  };
-
-  Bargraph.prototype.getData = function (groupData) {
-    var combinedData = [];
-    for (var j = 0; j < groupData.length; j++) {
-      combinedData.push({
-        x: groupData[j].x,
-        y: groupData[j].y,
-        groupId: this.groupId
-      });
-    }
-    return combinedData;
-  };
-
-  /**
-   * draw a bar graph
-   *
-   * @param groupIds
-   * @param processedGroupData
-   */
-  Bargraph.draw = function (groupIds, processedGroupData, framework) {
-    var combinedData = [];
-    var intersections = {};
-    var coreDistance;
-    var key, drawData;
-    var group;
-    var i, j;
-    var barPoints = 0;
-
-    // combine all barchart data
-    for (i = 0; i < groupIds.length; i++) {
-      group = framework.groups[groupIds[i]];
-      if (group.options.style === 'bar') {
-        if (group.visible === true && (framework.options.groups.visibility[groupIds[i]] === undefined || framework.options.groups.visibility[groupIds[i]] === true)) {
-          for (j = 0; j < processedGroupData[groupIds[i]].length; j++) {
-            combinedData.push({
-              x: processedGroupData[groupIds[i]][j].x,
-              y: processedGroupData[groupIds[i]][j].y,
-              groupId: groupIds[i],
-              label: processedGroupData[groupIds[i]][j].label
-            });
-            barPoints += 1;
-          }
-        }
-      }
-    }
-
-    if (barPoints === 0) {
-      return;
-    }
-
-    // sort by time and by group
-    combinedData.sort(function (a, b) {
-      if (a.x === b.x) {
-        return a.groupId < b.groupId ? -1 : 1;
-      } else {
-        return a.x - b.x;
-      }
-    });
-
-    // get intersections
-    Bargraph._getDataIntersections(intersections, combinedData);
-
-    // plot barchart
-    for (i = 0; i < combinedData.length; i++) {
-      group = framework.groups[combinedData[i].groupId];
-      var minWidth = 0.1 * group.options.barChart.width;
-
-      key = combinedData[i].x;
-      var heightOffset = 0;
-      if (intersections[key] === undefined) {
-        if (i + 1 < combinedData.length) {
-          coreDistance = Math.abs(combinedData[i + 1].x - key);
-        }
-        if (i > 0) {
-          coreDistance = Math.min(coreDistance, Math.abs(combinedData[i - 1].x - key));
-        }
-        drawData = Bargraph._getSafeDrawData(coreDistance, group, minWidth);
-      } else {
-        var nextKey = i + (intersections[key].amount - intersections[key].resolved);
-        var prevKey = i - (intersections[key].resolved + 1);
-        if (nextKey < combinedData.length) {
-          coreDistance = Math.abs(combinedData[nextKey].x - key);
-        }
-        if (prevKey > 0) {
-          coreDistance = Math.min(coreDistance, Math.abs(combinedData[prevKey].x - key));
-        }
-        drawData = Bargraph._getSafeDrawData(coreDistance, group, minWidth);
-        intersections[key].resolved += 1;
-
-        if (group.options.stack === true) {
-          if (combinedData[i].y < group.zeroPosition) {
-            heightOffset = intersections[key].accumulatedNegative;
-            intersections[key].accumulatedNegative += group.zeroPosition - combinedData[i].y;
-          } else {
-            heightOffset = intersections[key].accumulatedPositive;
-            intersections[key].accumulatedPositive += group.zeroPosition - combinedData[i].y;
-          }
-        } else if (group.options.barChart.sideBySide === true) {
-          drawData.width = drawData.width / intersections[key].amount;
-          drawData.offset += intersections[key].resolved * drawData.width - 0.5 * drawData.width * (intersections[key].amount + 1);
-          if (group.options.barChart.align === 'left') {
-            drawData.offset -= 0.5 * drawData.width;
-          } else if (group.options.barChart.align === 'right') {
-            drawData.offset += 0.5 * drawData.width;
-          }
-        }
-      }
-      console.log(group);
-      DOMutil.drawBar(combinedData[i].x + drawData.offset, combinedData[i].y - heightOffset, drawData.width, group.zeroPosition - combinedData[i].y, group.className + ' vis-bar', framework.svgElements, framework.svg, group.style);
-      // draw points
-      if (group.options.drawPoints.enabled === true) {
-        Points.draw([combinedData[i]], group, framework, drawData.offset);
-        //DOMutil.drawPoint(combinedData[i].x + drawData.offset, combinedData[i].y, group, framework.svgElements, framework.svg);
-      }
-    }
-  };
-
-  /**
-   * Fill the intersections object with counters of how many datapoints share the same x coordinates
-   * @param intersections
-   * @param combinedData
-   * @private
-   */
-  Bargraph._getDataIntersections = function (intersections, combinedData) {
-    // get intersections
-    var coreDistance;
-    for (var i = 0; i < combinedData.length; i++) {
-      if (i + 1 < combinedData.length) {
-        coreDistance = Math.abs(combinedData[i + 1].x - combinedData[i].x);
-      }
-      if (i > 0) {
-        coreDistance = Math.min(coreDistance, Math.abs(combinedData[i - 1].x - combinedData[i].x));
-      }
-      if (coreDistance === 0) {
-        if (intersections[combinedData[i].x] === undefined) {
-          intersections[combinedData[i].x] = { amount: 0, resolved: 0, accumulatedPositive: 0, accumulatedNegative: 0 };
-        }
-        intersections[combinedData[i].x].amount += 1;
-      }
-    }
-  };
-
-  /**
-   * Get the width and offset for bargraphs based on the coredistance between datapoints
-   *
-   * @param coreDistance
-   * @param group
-   * @param minWidth
-   * @returns {{width: Number, offset: Number}}
-   * @private
-   */
-  Bargraph._getSafeDrawData = function (coreDistance, group, minWidth) {
-    var width, offset;
-    if (coreDistance < group.options.barChart.width && coreDistance > 0) {
-      width = coreDistance < minWidth ? minWidth : coreDistance;
-
-      offset = 0; // recalculate offset with the new width;
-      if (group.options.barChart.align === 'left') {
-        offset -= 0.5 * coreDistance;
-      } else if (group.options.barChart.align === 'right') {
-        offset += 0.5 * coreDistance;
-      }
-    } else {
-      // default settings
-      width = group.options.barChart.width;
-      offset = 0;
-      if (group.options.barChart.align === 'left') {
-        offset -= 0.5 * group.options.barChart.width;
-      } else if (group.options.barChart.align === 'right') {
-        offset += 0.5 * group.options.barChart.width;
-      }
-    }
-
-    return { width: width, offset: offset };
-  };
-
-  Bargraph.getStackedYRange = function (combinedData, groupRanges, groupIds, groupLabel, orientation) {
-    if (combinedData.length > 0) {
-      // sort by time and by group
-      combinedData.sort(function (a, b) {
-        if (a.x === b.x) {
-          return a.groupId < b.groupId ? -1 : 1;
-        } else {
-          return a.x - b.x;
-        }
-      });
-      var intersections = {};
-
-      Bargraph._getDataIntersections(intersections, combinedData);
-      groupRanges[groupLabel] = Bargraph._getStackedYRange(intersections, combinedData);
-      groupRanges[groupLabel].yAxisOrientation = orientation;
-      groupIds.push(groupLabel);
-    }
-  };
-
-  Bargraph._getStackedYRange = function (intersections, combinedData) {
-    var key;
-    var yMin = combinedData[0].y;
-    var yMax = combinedData[0].y;
-    for (var i = 0; i < combinedData.length; i++) {
-      key = combinedData[i].x;
-      if (intersections[key] === undefined) {
-        yMin = yMin > combinedData[i].y ? combinedData[i].y : yMin;
-        yMax = yMax < combinedData[i].y ? combinedData[i].y : yMax;
-      } else {
-        if (combinedData[i].y < 0) {
-          intersections[key].accumulatedNegative += combinedData[i].y;
-        } else {
-          intersections[key].accumulatedPositive += combinedData[i].y;
-        }
-      }
-    }
-    for (var xpos in intersections) {
-      if (intersections.hasOwnProperty(xpos)) {
-        yMin = yMin > intersections[xpos].accumulatedNegative ? intersections[xpos].accumulatedNegative : yMin;
-        yMin = yMin > intersections[xpos].accumulatedPositive ? intersections[xpos].accumulatedPositive : yMin;
-        yMax = yMax < intersections[xpos].accumulatedNegative ? intersections[xpos].accumulatedNegative : yMax;
-        yMax = yMax < intersections[xpos].accumulatedPositive ? intersections[xpos].accumulatedPositive : yMax;
-      }
-    }
-
-    return { min: yMin, max: yMax };
-  };
-
-  module.exports = Bargraph;
-
 /***/ },
 /* 51 */
 /***/ function(module, exports, __webpack_require__) {
@@ -20158,7 +20079,7 @@ return /******/ (function(modules) { // webpackBootstrap
   'use strict';
 
   var DOMutil = __webpack_require__(2);
-  var Points = __webpack_require__(52);
+  var Points = __webpack_require__(53);
 
   function Line(groupId, options) {
     this.groupId = groupId;
@@ -20453,13 +20374,14 @@ return /******/ (function(modules) { // webpackBootstrap
   'use strict';
 
   var DOMutil = __webpack_require__(2);
+  var Points = __webpack_require__(53);
 
-  function Points(groupId, options) {
+  function Bargraph(groupId, options) {
     this.groupId = groupId;
     this.options = options;
   }
 
-  Points.prototype.getYRange = function (groupData) {
+  Bargraph.prototype.getYRange = function (groupData) {
     var yMin = groupData[0].y;
     var yMax = groupData[0].y;
     for (var j = 0; j < groupData.length; j++) {
@@ -20469,18 +20391,265 @@ return /******/ (function(modules) { // webpackBootstrap
     return { min: yMin, max: yMax, yAxisOrientation: this.options.yAxisOrientation };
   };
 
-  Points.prototype.draw = function (dataset, group, framework, offset) {
-    Points.draw(dataset, group, framework, offset);
+  Bargraph.prototype.getData = function (groupData) {
+    var combinedData = [];
+    for (var j = 0; j < groupData.length; j++) {
+      combinedData.push({
+        x: groupData[j].x,
+        y: groupData[j].y,
+        groupId: this.groupId
+      });
+    }
+    return combinedData;
   };
 
   /**
-   * draw the data points
+   * draw a bar graph
    *
-   * @param {Array} dataset
-   * @param {Object} JSONcontainer
-   * @param {Object} svg            | SVG DOM element
-   * @param {GraphGroup} group
-   * @param {Number} [offset]
+   * @param groupIds
+   * @param processedGroupData
+   */
+  Bargraph.draw = function (groupIds, processedGroupData, framework) {
+    var combinedData = [];
+    var intersections = {};
+    var coreDistance;
+    var key, drawData;
+    var group;
+    var i, j;
+    var barPoints = 0;
+
+    // combine all barchart data
+    for (i = 0; i < groupIds.length; i++) {
+      group = framework.groups[groupIds[i]];
+      if (group.options.style === 'bar') {
+        if (group.visible === true && (framework.options.groups.visibility[groupIds[i]] === undefined || framework.options.groups.visibility[groupIds[i]] === true)) {
+          for (j = 0; j < processedGroupData[groupIds[i]].length; j++) {
+            combinedData.push({
+              x: processedGroupData[groupIds[i]][j].x,
+              y: processedGroupData[groupIds[i]][j].y,
+              groupId: groupIds[i],
+              label: processedGroupData[groupIds[i]][j].label
+            });
+            barPoints += 1;
+          }
+        }
+      }
+    }
+
+    if (barPoints === 0) {
+      return;
+    }
+
+    // sort by time and by group
+    combinedData.sort(function (a, b) {
+      if (a.x === b.x) {
+        return a.groupId < b.groupId ? -1 : 1;
+      } else {
+        return a.x - b.x;
+      }
+    });
+
+    // get intersections
+    Bargraph._getDataIntersections(intersections, combinedData);
+
+    // plot barchart
+    for (i = 0; i < combinedData.length; i++) {
+      group = framework.groups[combinedData[i].groupId];
+      var minWidth = 0.1 * group.options.barChart.width;
+
+      key = combinedData[i].x;
+      var heightOffset = 0;
+      if (intersections[key] === undefined) {
+        if (i + 1 < combinedData.length) {
+          coreDistance = Math.abs(combinedData[i + 1].x - key);
+        }
+        if (i > 0) {
+          coreDistance = Math.min(coreDistance, Math.abs(combinedData[i - 1].x - key));
+        }
+        drawData = Bargraph._getSafeDrawData(coreDistance, group, minWidth);
+      } else {
+        var nextKey = i + (intersections[key].amount - intersections[key].resolved);
+        var prevKey = i - (intersections[key].resolved + 1);
+        if (nextKey < combinedData.length) {
+          coreDistance = Math.abs(combinedData[nextKey].x - key);
+        }
+        if (prevKey > 0) {
+          coreDistance = Math.min(coreDistance, Math.abs(combinedData[prevKey].x - key));
+        }
+        drawData = Bargraph._getSafeDrawData(coreDistance, group, minWidth);
+        intersections[key].resolved += 1;
+
+        if (group.options.stack === true) {
+          if (combinedData[i].y < group.zeroPosition) {
+            heightOffset = intersections[key].accumulatedNegative;
+            intersections[key].accumulatedNegative += group.zeroPosition - combinedData[i].y;
+          } else {
+            heightOffset = intersections[key].accumulatedPositive;
+            intersections[key].accumulatedPositive += group.zeroPosition - combinedData[i].y;
+          }
+        } else if (group.options.barChart.sideBySide === true) {
+          drawData.width = drawData.width / intersections[key].amount;
+          drawData.offset += intersections[key].resolved * drawData.width - 0.5 * drawData.width * (intersections[key].amount + 1);
+          if (group.options.barChart.align === 'left') {
+            drawData.offset -= 0.5 * drawData.width;
+          } else if (group.options.barChart.align === 'right') {
+            drawData.offset += 0.5 * drawData.width;
+          }
+        }
+      }
+      DOMutil.drawBar(combinedData[i].x + drawData.offset, combinedData[i].y - heightOffset, drawData.width, group.zeroPosition - combinedData[i].y, group.className + ' vis-bar', framework.svgElements, framework.svg, group.style);
+      // draw points
+      if (group.options.drawPoints.enabled === true) {
+        Points.draw([combinedData[i]], group, framework, drawData.offset);
+        //DOMutil.drawPoint(combinedData[i].x + drawData.offset, combinedData[i].y, group, framework.svgElements, framework.svg);
+      }
+    }
+  };
+
+  /**
+   * Fill the intersections object with counters of how many datapoints share the same x coordinates
+   * @param intersections
+   * @param combinedData
+   * @private
+   */
+  Bargraph._getDataIntersections = function (intersections, combinedData) {
+    // get intersections
+    var coreDistance;
+    for (var i = 0; i < combinedData.length; i++) {
+      if (i + 1 < combinedData.length) {
+        coreDistance = Math.abs(combinedData[i + 1].x - combinedData[i].x);
+      }
+      if (i > 0) {
+        coreDistance = Math.min(coreDistance, Math.abs(combinedData[i - 1].x - combinedData[i].x));
+      }
+      if (coreDistance === 0) {
+        if (intersections[combinedData[i].x] === undefined) {
+          intersections[combinedData[i].x] = { amount: 0, resolved: 0, accumulatedPositive: 0, accumulatedNegative: 0 };
+        }
+        intersections[combinedData[i].x].amount += 1;
+      }
+    }
+  };
+
+  /**
+   * Get the width and offset for bargraphs based on the coredistance between datapoints
+   *
+   * @param coreDistance
+   * @param group
+   * @param minWidth
+   * @returns {{width: Number, offset: Number}}
+   * @private
+   */
+  Bargraph._getSafeDrawData = function (coreDistance, group, minWidth) {
+    var width, offset;
+    if (coreDistance < group.options.barChart.width && coreDistance > 0) {
+      width = coreDistance < minWidth ? minWidth : coreDistance;
+
+      offset = 0; // recalculate offset with the new width;
+      if (group.options.barChart.align === 'left') {
+        offset -= 0.5 * coreDistance;
+      } else if (group.options.barChart.align === 'right') {
+        offset += 0.5 * coreDistance;
+      }
+    } else {
+      // default settings
+      width = group.options.barChart.width;
+      offset = 0;
+      if (group.options.barChart.align === 'left') {
+        offset -= 0.5 * group.options.barChart.width;
+      } else if (group.options.barChart.align === 'right') {
+        offset += 0.5 * group.options.barChart.width;
+      }
+    }
+
+    return { width: width, offset: offset };
+  };
+
+  Bargraph.getStackedYRange = function (combinedData, groupRanges, groupIds, groupLabel, orientation) {
+    if (combinedData.length > 0) {
+      // sort by time and by group
+      combinedData.sort(function (a, b) {
+        if (a.x === b.x) {
+          return a.groupId < b.groupId ? -1 : 1;
+        } else {
+          return a.x - b.x;
+        }
+      });
+      var intersections = {};
+
+      Bargraph._getDataIntersections(intersections, combinedData);
+      groupRanges[groupLabel] = Bargraph._getStackedYRange(intersections, combinedData);
+      groupRanges[groupLabel].yAxisOrientation = orientation;
+      groupIds.push(groupLabel);
+    }
+  };
+
+  Bargraph._getStackedYRange = function (intersections, combinedData) {
+    var key;
+    var yMin = combinedData[0].y;
+    var yMax = combinedData[0].y;
+    for (var i = 0; i < combinedData.length; i++) {
+      key = combinedData[i].x;
+      if (intersections[key] === undefined) {
+        yMin = yMin > combinedData[i].y ? combinedData[i].y : yMin;
+        yMax = yMax < combinedData[i].y ? combinedData[i].y : yMax;
+      } else {
+        if (combinedData[i].y < 0) {
+          intersections[key].accumulatedNegative += combinedData[i].y;
+        } else {
+          intersections[key].accumulatedPositive += combinedData[i].y;
+        }
+      }
+    }
+    for (var xpos in intersections) {
+      if (intersections.hasOwnProperty(xpos)) {
+        yMin = yMin > intersections[xpos].accumulatedNegative ? intersections[xpos].accumulatedNegative : yMin;
+        yMin = yMin > intersections[xpos].accumulatedPositive ? intersections[xpos].accumulatedPositive : yMin;
+        yMax = yMax < intersections[xpos].accumulatedNegative ? intersections[xpos].accumulatedNegative : yMax;
+        yMax = yMax < intersections[xpos].accumulatedPositive ? intersections[xpos].accumulatedPositive : yMax;
+      }
+    }
+
+    return { min: yMin, max: yMax };
+  };
+
+  module.exports = Bargraph;
+
+/***/ },
+/* 53 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var DOMutil = __webpack_require__(2);
+
+  function Points(groupId, options) {
+    this.groupId = groupId;
+    this.options = options;
+  }
+
+  Points.prototype.getYRange = function (groupData) {
+    var yMin = groupData[0].y;
+    var yMax = groupData[0].y;
+    for (var j = 0; j < groupData.length; j++) {
+      yMin = yMin > groupData[j].y ? groupData[j].y : yMin;
+      yMax = yMax < groupData[j].y ? groupData[j].y : yMax;
+    }
+    return { min: yMin, max: yMax, yAxisOrientation: this.options.yAxisOrientation };
+  };
+
+  Points.prototype.draw = function (dataset, group, framework, offset) {
+    Points.draw(dataset, group, framework, offset);
+  };
+
+  /**
+   * draw the data points
+   *
+   * @param {Array} dataset
+   * @param {Object} JSONcontainer
+   * @param {Object} svg            | SVG DOM element
+   * @param {GraphGroup} group
+   * @param {Number} [offset]
    */
   Points.draw = function (dataset, group, framework, offset) {
     if (offset === undefined) {
@@ -20494,7 +20663,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = Points;
 
 /***/ },
-/* 53 */
+/* 54 */
 /***/ function(module, exports, __webpack_require__) {
 
   "use strict";
@@ -20636,7 +20805,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports["default"];
 
 /***/ },
-/* 54 */
+/* 55 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -21109,7 +21278,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 55 */
+/* 56 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -21529,7 +21698,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 56 */
+/* 57 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -22135,7 +22304,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 57 */
+/* 58 */
 /***/ function(module, exports, __webpack_require__) {
 
   "use strict";
@@ -22787,7 +22956,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports["default"];
 
 /***/ },
-/* 58 */
+/* 59 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -23127,7 +23296,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 59 */
+/* 60 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -23141,7 +23310,7 @@ return /******/ (function(modules) { // webpackBootstrap
   function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
 
   var Hammer = __webpack_require__(41);
-  var hammerUtil = __webpack_require__(48);
+  var hammerUtil = __webpack_require__(49);
 
   var util = __webpack_require__(1);
 
@@ -23495,7 +23664,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 60 */
+/* 61 */
 /***/ function(module, exports, __webpack_require__) {
 
   "use strict";
@@ -23897,7 +24066,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports["default"];
 
 /***/ },
-/* 61 */
+/* 62 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -24625,7 +24794,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 62 */
+/* 63 */
 /***/ function(module, exports, __webpack_require__) {
 
   "use strict";
@@ -25313,7 +25482,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports["default"];
 
 /***/ },
-/* 63 */
+/* 64 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -25810,7 +25979,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 64 */
+/* 65 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -25825,7 +25994,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
   var util = __webpack_require__(1);
   var Hammer = __webpack_require__(41);
-  var hammerUtil = __webpack_require__(48);
+  var hammerUtil = __webpack_require__(49);
 
   /**
    * clears the toolbar div element of children
@@ -26999,7 +27168,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 65 */
+/* 66 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -27473,7 +27642,7 @@ return /******/ (function(modules) { // webpackBootstrap
   exports.configureOptions = configureOptions;
 
 /***/ },
-/* 66 */
+/* 67 */
 /***/ function(module, exports, __webpack_require__) {
 
   /**
@@ -27757,13 +27926,13 @@ return /******/ (function(modules) { // webpackBootstrap
   }
 
 /***/ },
-/* 67 */
+/* 68 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
 
-  var keycharm = __webpack_require__(89);
-  var Emitter = __webpack_require__(69);
+  var keycharm = __webpack_require__(88);
+  var Emitter = __webpack_require__(43);
   var Hammer = __webpack_require__(41);
   var util = __webpack_require__(1);
 
@@ -27910,7 +28079,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = Activator;
 
 /***/ },
-/* 68 */
+/* 69 */
 /***/ function(module, exports, __webpack_require__) {
 
   // English
@@ -27954,5959 +28123,5789 @@ return /******/ (function(modules) { // webpackBootstrap
   exports['nl_BE'] = exports['nl'];
 
 /***/ },
-/* 69 */
+/* 70 */
 /***/ function(module, exports, __webpack_require__) {
 
-  
-  /**
-   * Expose `Emitter`.
-   */
-
-  module.exports = Emitter;
+  /* WEBPACK VAR INJECTION */(function(module) {//! moment.js
+  //! version : 2.10.2
+  //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
+  //! license : MIT
+  //! momentjs.com
 
-  /**
-   * Initialize a new `Emitter`.
-   *
-   * @api public
-   */
+  (function (global, factory) {
+      true ? module.exports = factory() :
+      typeof define === 'function' && define.amd ? define(factory) :
+      global.moment = factory()
+  }(this, function () { 'use strict';
 
-  function Emitter(obj) {
-    if (obj) return mixin(obj);
-  };
+      var hookCallback;
 
-  /**
-   * Mixin the emitter properties.
-   *
-   * @param {Object} obj
-   * @return {Object}
-   * @api private
-   */
+      function utils_hooks__hooks () {
+          return hookCallback.apply(null, arguments);
+      }
 
-  function mixin(obj) {
-    for (var key in Emitter.prototype) {
-      obj[key] = Emitter.prototype[key];
-    }
-    return obj;
-  }
+      // This is done to register the method called with moment()
+      // without creating circular dependencies.
+      function setHookCallback (callback) {
+          hookCallback = callback;
+      }
 
-  /**
-   * Listen on the given `event` with `fn`.
-   *
-   * @param {String} event
-   * @param {Function} fn
-   * @return {Emitter}
-   * @api public
-   */
+      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
+          };
+      }
 
-  Emitter.prototype.on =
-  Emitter.prototype.addEventListener = function(event, fn){
-    this._callbacks = this._callbacks || {};
-    (this._callbacks[event] = this._callbacks[event] || [])
-      .push(fn);
-    return this;
-  };
+      function isArray(input) {
+          return Object.prototype.toString.call(input) === '[object Array]';
+      }
 
-  /**
-   * Adds an `event` listener that will be invoked a single
-   * time then automatically removed.
-   *
-   * @param {String} event
-   * @param {Function} fn
-   * @return {Emitter}
-   * @api public
-   */
+      function isDate(input) {
+          return Object.prototype.toString.call(input) === '[object Date]' || input instanceof Date;
+      }
 
-  Emitter.prototype.once = function(event, fn){
-    var self = this;
-    this._callbacks = this._callbacks || {};
+      function map(arr, fn) {
+          var res = [], i;
+          for (i = 0; i < arr.length; ++i) {
+              res.push(fn(arr[i], i));
+          }
+          return res;
+      }
 
-    function on() {
-      self.off(event, on);
-      fn.apply(this, arguments);
-    }
+      function hasOwnProp(a, b) {
+          return Object.prototype.hasOwnProperty.call(a, b);
+      }
 
-    on.fn = fn;
-    this.on(event, on);
-    return this;
-  };
+      function extend(a, b) {
+          for (var i in b) {
+              if (hasOwnProp(b, i)) {
+                  a[i] = b[i];
+              }
+          }
 
-  /**
-   * Remove the given callback for `event` or all
-   * registered callbacks.
-   *
-   * @param {String} event
-   * @param {Function} fn
-   * @return {Emitter}
-   * @api public
-   */
+          if (hasOwnProp(b, 'toString')) {
+              a.toString = b.toString;
+          }
 
-  Emitter.prototype.off =
-  Emitter.prototype.removeListener =
-  Emitter.prototype.removeAllListeners =
-  Emitter.prototype.removeEventListener = function(event, fn){
-    this._callbacks = this._callbacks || {};
+          if (hasOwnProp(b, 'valueOf')) {
+              a.valueOf = b.valueOf;
+          }
 
-    // all
-    if (0 == arguments.length) {
-      this._callbacks = {};
-      return this;
-    }
+          return a;
+      }
 
-    // specific event
-    var callbacks = this._callbacks[event];
-    if (!callbacks) return this;
+      function create_utc__createUTC (input, format, locale, strict) {
+          return createLocalOrUTC(input, format, locale, strict, true).utc();
+      }
 
-    // remove all handlers
-    if (1 == arguments.length) {
-      delete this._callbacks[event];
-      return this;
-    }
+      function valid__isValid(m) {
+          if (m._isValid == null) {
+              m._isValid = !isNaN(m._d.getTime()) &&
+                  m._pf.overflow < 0 &&
+                  !m._pf.empty &&
+                  !m._pf.invalidMonth &&
+                  !m._pf.nullInput &&
+                  !m._pf.invalidFormat &&
+                  !m._pf.userInvalidated;
 
-    // remove specific handler
-    var cb;
-    for (var i = 0; i < callbacks.length; i++) {
-      cb = callbacks[i];
-      if (cb === fn || cb.fn === fn) {
-        callbacks.splice(i, 1);
-        break;
+              if (m._strict) {
+                  m._isValid = m._isValid &&
+                      m._pf.charsLeftOver === 0 &&
+                      m._pf.unusedTokens.length === 0 &&
+                      m._pf.bigHour === undefined;
+              }
+          }
+          return m._isValid;
       }
-    }
-    return this;
-  };
-
-  /**
-   * Emit `event` with the given args.
-   *
-   * @param {String} event
-   * @param {Mixed} ...
-   * @return {Emitter}
-   */
 
-  Emitter.prototype.emit = function(event){
-    this._callbacks = this._callbacks || {};
-    var args = [].slice.call(arguments, 1)
-      , callbacks = this._callbacks[event];
+      function valid__createInvalid (flags) {
+          var m = create_utc__createUTC(NaN);
+          if (flags != null) {
+              extend(m._pf, flags);
+          }
+          else {
+              m._pf.userInvalidated = true;
+          }
 
-    if (callbacks) {
-      callbacks = callbacks.slice(0);
-      for (var i = 0, len = callbacks.length; i < len; ++i) {
-        callbacks[i].apply(this, args);
+          return m;
       }
-    }
 
-    return this;
-  };
+      var momentProperties = utils_hooks__hooks.momentProperties = [];
 
-  /**
-   * Return array of callbacks for `event`.
-   *
-   * @param {String} event
-   * @return {Array}
-   * @api public
-   */
+      function copyConfig(to, from) {
+          var i, prop, val;
 
-  Emitter.prototype.listeners = function(event){
-    this._callbacks = this._callbacks || {};
-    return this._callbacks[event] || [];
-  };
+          if (typeof from._isAMomentObject !== 'undefined') {
+              to._isAMomentObject = from._isAMomentObject;
+          }
+          if (typeof from._i !== 'undefined') {
+              to._i = from._i;
+          }
+          if (typeof from._f !== 'undefined') {
+              to._f = from._f;
+          }
+          if (typeof from._l !== 'undefined') {
+              to._l = from._l;
+          }
+          if (typeof from._strict !== 'undefined') {
+              to._strict = from._strict;
+          }
+          if (typeof from._tzm !== 'undefined') {
+              to._tzm = from._tzm;
+          }
+          if (typeof from._isUTC !== 'undefined') {
+              to._isUTC = from._isUTC;
+          }
+          if (typeof from._offset !== 'undefined') {
+              to._offset = from._offset;
+          }
+          if (typeof from._pf !== 'undefined') {
+              to._pf = from._pf;
+          }
+          if (typeof from._locale !== 'undefined') {
+              to._locale = from._locale;
+          }
 
-  /**
-   * Check if this emitter has `event` handlers.
-   *
-   * @param {String} event
-   * @return {Boolean}
-   * @api public
-   */
+          if (momentProperties.length > 0) {
+              for (i in momentProperties) {
+                  prop = momentProperties[i];
+                  val = from[prop];
+                  if (typeof val !== 'undefined') {
+                      to[prop] = val;
+                  }
+              }
+          }
 
-  Emitter.prototype.hasListeners = function(event){
-    return !! this.listeners(event).length;
-  };
+          return to;
+      }
 
+      var updateInProgress = false;
 
-/***/ },
-/* 70 */
-/***/ function(module, exports, __webpack_require__) {
+      // Moment prototype object
+      function Moment(config) {
+          copyConfig(this, config);
+          this._d = new Date(+config._d);
+          // Prevent infinite loop in case updateOffset creates new moment
+          // objects.
+          if (updateInProgress === false) {
+              updateInProgress = true;
+              utils_hooks__hooks.updateOffset(this);
+              updateInProgress = false;
+          }
+      }
 
-  var __WEBPACK_AMD_DEFINE_RESULT__;/*! Hammer.JS - v2.0.4 - 2014-09-28
-   * http://hammerjs.github.io/
-   *
-   * Copyright (c) 2014 Jorik Tangelder;
-   * Licensed under the MIT license */
-  (function(window, document, exportName, undefined) {
-    'use strict';
+      function isMoment (obj) {
+          return obj instanceof Moment || (obj != null && hasOwnProp(obj, '_isAMomentObject'));
+      }
 
-  var VENDOR_PREFIXES = ['', 'webkit', 'moz', 'MS', 'ms', 'o'];
-  var TEST_ELEMENT = document.createElement('div');
+      function toInt(argumentForCoercion) {
+          var coercedNumber = +argumentForCoercion,
+              value = 0;
 
-  var TYPE_FUNCTION = 'function';
+          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+              if (coercedNumber >= 0) {
+                  value = Math.floor(coercedNumber);
+              } else {
+                  value = Math.ceil(coercedNumber);
+              }
+          }
 
-  var round = Math.round;
-  var abs = Math.abs;
-  var now = Date.now;
+          return value;
+      }
 
-  /**
-   * set a timeout with a given scope
-   * @param {Function} fn
-   * @param {Number} timeout
-   * @param {Object} context
-   * @returns {number}
-   */
-  function setTimeoutContext(fn, timeout, context) {
-      return setTimeout(bindFn(fn, context), timeout);
-  }
+      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;
+      }
 
-  /**
-   * if the argument is an array, we want to execute the fn on each entry
-   * if it aint an array we don't want to do a thing.
-   * this is used by all the methods that accept a single and array argument.
-   * @param {*|Array} arg
-   * @param {String} fn
-   * @param {Object} [context]
-   * @returns {Boolean}
-   */
-  function invokeArrayArg(arg, fn, context) {
-      if (Array.isArray(arg)) {
-          each(arg, context[fn], context);
-          return true;
+      function Locale() {
       }
-      return false;
-  }
 
-  /**
-   * walk objects and arrays
-   * @param {Object} obj
-   * @param {Function} iterator
-   * @param {Object} context
-   */
-  function each(obj, iterator, context) {
-      var i;
+      var locales = {};
+      var globalLocale;
 
-      if (!obj) {
-          return;
+      function normalizeLocale(key) {
+          return key ? key.toLowerCase().replace('_', '-') : key;
       }
 
-      if (obj.forEach) {
-          obj.forEach(iterator, context);
-      } else if (obj.length !== undefined) {
-          i = 0;
-          while (i < obj.length) {
-              iterator.call(context, obj[i], i, obj);
+      // 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++;
           }
-      } else {
-          for (i in obj) {
-              obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
-          }
+          return null;
       }
-  }
 
-  /**
-   * extend object.
-   * means that properties in dest will be overwritten by the ones in src.
-   * @param {Object} dest
-   * @param {Object} src
-   * @param {Boolean} [merge]
-   * @returns {Object} dest
-   */
-  function extend(dest, src, merge) {
-      var keys = Object.keys(src);
-      var i = 0;
-      while (i < keys.length) {
-          if (!merge || (merge && dest[keys[i]] === undefined)) {
-              dest[keys[i]] = src[keys[i]];
+      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;
+                  !(function webpackMissingModule() { var e = new Error("Cannot find module \"./locale\""); e.code = 'MODULE_NOT_FOUND'; throw e; }());
+                  // because defineLocale currently also sets the global locale, we
+                  // want to undo that for lazy loaded locales
+                  locale_locales__getSetGlobalLocale(oldLocale);
+              } catch (e) { }
           }
-          i++;
+          return locales[name];
       }
-      return dest;
-  }
-
-  /**
-   * merge the values from src in the dest.
-   * means that properties that exist in dest will not be overwritten by src
-   * @param {Object} dest
-   * @param {Object} src
-   * @returns {Object} dest
-   */
-  function merge(dest, src) {
-      return extend(dest, src, true);
-  }
 
-  /**
-   * simple class inheritance
-   * @param {Function} child
-   * @param {Function} base
-   * @param {Object} [properties]
-   */
-  function inherit(child, base, properties) {
-      var baseP = base.prototype,
-          childP;
+      // 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 locale_locales__getSetGlobalLocale (key, values) {
+          var data;
+          if (key) {
+              if (typeof values === 'undefined') {
+                  data = locale_locales__getLocale(key);
+              }
+              else {
+                  data = defineLocale(key, values);
+              }
 
-      childP = child.prototype = Object.create(baseP);
-      childP.constructor = child;
-      childP._super = baseP;
+              if (data) {
+                  // moment.duration._locale = moment._locale = data;
+                  globalLocale = data;
+              }
+          }
 
-      if (properties) {
-          extend(childP, properties);
+          return globalLocale._abbr;
       }
-  }
-
-  /**
-   * simple function bind
-   * @param {Function} fn
-   * @param {Object} context
-   * @returns {Function}
-   */
-  function bindFn(fn, context) {
-      return function boundFn() {
-          return fn.apply(context, arguments);
-      };
-  }
 
-  /**
-   * let a boolean value also be a function that must return a boolean
-   * this first item in args will be used as the context
-   * @param {Boolean|Function} val
-   * @param {Array} [args]
-   * @returns {Boolean}
-   */
-  function boolOrFn(val, args) {
-      if (typeof val == TYPE_FUNCTION) {
-          return val.apply(args ? args[0] || undefined : undefined, args);
+      function defineLocale (name, values) {
+          if (values !== null) {
+              values.abbr = name;
+              if (!locales[name]) {
+                  locales[name] = new Locale();
+              }
+              locales[name].set(values);
+
+              // backwards compat for now: also set the locale
+              locale_locales__getSetGlobalLocale(name);
+
+              return locales[name];
+          } else {
+              // useful for testing
+              delete locales[name];
+              return null;
+          }
       }
-      return val;
-  }
 
-  /**
-   * use the val2 when val1 is undefined
-   * @param {*} val1
-   * @param {*} val2
-   * @returns {*}
-   */
-  function ifUndefined(val1, val2) {
-      return (val1 === undefined) ? val2 : val1;
-  }
+      // returns locale data
+      function locale_locales__getLocale (key) {
+          var locale;
 
-  /**
-   * addEventListener with multiple events at once
-   * @param {EventTarget} target
-   * @param {String} types
-   * @param {Function} handler
-   */
-  function addEventListeners(target, types, handler) {
-      each(splitStr(types), function(type) {
-          target.addEventListener(type, handler, false);
-      });
-  }
+          if (key && key._locale && key._locale._abbr) {
+              key = key._locale._abbr;
+          }
 
-  /**
-   * removeEventListener with multiple events at once
-   * @param {EventTarget} target
-   * @param {String} types
-   * @param {Function} handler
-   */
-  function removeEventListeners(target, types, handler) {
-      each(splitStr(types), function(type) {
-          target.removeEventListener(type, handler, false);
-      });
-  }
+          if (!key) {
+              return globalLocale;
+          }
 
-  /**
-   * find if a node is in the given parent
-   * @method hasParent
-   * @param {HTMLElement} node
-   * @param {HTMLElement} parent
-   * @return {Boolean} found
-   */
-  function hasParent(node, parent) {
-      while (node) {
-          if (node == parent) {
-              return true;
+          if (!isArray(key)) {
+              //short-circuit everything else
+              locale = loadLocale(key);
+              if (locale) {
+                  return locale;
+              }
+              key = [key];
           }
-          node = node.parentNode;
+
+          return chooseLocale(key);
       }
-      return false;
-  }
 
-  /**
-   * small indexOf wrapper
-   * @param {String} str
-   * @param {String} find
-   * @returns {Boolean} found
-   */
-  function inStr(str, find) {
-      return str.indexOf(find) > -1;
-  }
+      var aliases = {};
 
-  /**
-   * split string on whitespace
-   * @param {String} str
-   * @returns {Array} words
-   */
-  function splitStr(str) {
-      return str.trim().split(/\s+/g);
-  }
+      function addUnitAlias (unit, shorthand) {
+          var lowerCase = unit.toLowerCase();
+          aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+      }
 
-  /**
-   * find if a array contains the object using indexOf or a simple polyFill
-   * @param {Array} src
-   * @param {String} find
-   * @param {String} [findByKey]
-   * @return {Boolean|Number} false when not found, or the index
-   */
-  function inArray(src, find, findByKey) {
-      if (src.indexOf && !findByKey) {
-          return src.indexOf(find);
-      } else {
-          var i = 0;
-          while (i < src.length) {
-              if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {
-                  return i;
+      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];
+                  }
               }
-              i++;
           }
-          return -1;
+
+          return normalizedInput;
       }
-  }
 
-  /**
-   * convert array-like objects to real arrays
-   * @param {Object} obj
-   * @returns {Array}
-   */
-  function toArray(obj) {
-      return Array.prototype.slice.call(obj, 0);
-  }
+      function makeGetSet (unit, keepTime) {
+          return function (value) {
+              if (value != null) {
+                  get_set__set(this, unit, value);
+                  utils_hooks__hooks.updateOffset(this, keepTime);
+                  return this;
+              } else {
+                  return get_set__get(this, unit);
+              }
+          };
+      }
 
-  /**
-   * unique array with objects based on a key (like 'id') or just by the array's value
-   * @param {Array} src [{id:1},{id:2},{id:1}]
-   * @param {String} [key]
-   * @param {Boolean} [sort=False]
-   * @returns {Array} [{id:1},{id:2}]
-   */
-  function uniqueArray(src, key, sort) {
-      var results = [];
-      var values = [];
-      var i = 0;
+      function get_set__get (mom, unit) {
+          return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
+      }
 
-      while (i < src.length) {
-          var val = key ? src[i][key] : src[i];
-          if (inArray(values, val) < 0) {
-              results.push(src[i]);
-          }
-          values[i] = val;
-          i++;
+      function get_set__set (mom, unit, value) {
+          return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
       }
 
-      if (sort) {
-          if (!key) {
-              results = results.sort();
+      // MOMENTS
+
+      function getSet (units, value) {
+          var unit;
+          if (typeof units === 'object') {
+              for (unit in units) {
+                  this.set(unit, units[unit]);
+              }
           } else {
-              results = results.sort(function sortUniqueArray(a, b) {
-                  return a[key] > b[key];
-              });
+              units = normalizeUnits(units);
+              if (typeof this[units] === 'function') {
+                  return this[units](value);
+              }
           }
+          return this;
       }
 
-      return results;
-  }
-
-  /**
-   * get the prefixed property
-   * @param {Object} obj
-   * @param {String} property
-   * @returns {String|Undefined} prefixed
-   */
-  function prefixed(obj, property) {
-      var prefix, prop;
-      var camelProp = property[0].toUpperCase() + property.slice(1);
-
-      var i = 0;
-      while (i < VENDOR_PREFIXES.length) {
-          prefix = VENDOR_PREFIXES[i];
-          prop = (prefix) ? prefix + camelProp : property;
+      function zeroFill(number, targetLength, forceSign) {
+          var output = '' + Math.abs(number),
+              sign = number >= 0;
 
-          if (prop in obj) {
-              return prop;
+          while (output.length < targetLength) {
+              output = '0' + output;
           }
-          i++;
+          return (sign ? (forceSign ? '+' : '') : '-') + output;
       }
-      return undefined;
-  }
 
-  /**
-   * get a unique id
-   * @returns {number} uniqueId
-   */
-  var _uniqueId = 1;
-  function uniqueId() {
-      return _uniqueId++;
-  }
+      var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|x|X|zz?|ZZ?|.)/g;
 
-  /**
-   * get the window object of an element
-   * @param {HTMLElement} element
-   * @returns {DocumentView|Window}
-   */
-  function getWindowForElement(element) {
-      var doc = element.ownerDocument;
-      return (doc.defaultView || doc.parentWindow);
-  }
+      var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
 
-  var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
+      var formatFunctions = {};
 
-  var SUPPORT_TOUCH = ('ontouchstart' in window);
-  var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;
-  var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
+      var formatTokenFunctions = {};
 
-  var INPUT_TYPE_TOUCH = 'touch';
-  var INPUT_TYPE_PEN = 'pen';
-  var INPUT_TYPE_MOUSE = 'mouse';
-  var INPUT_TYPE_KINECT = 'kinect';
+      // 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);
+              };
+          }
+      }
 
-  var COMPUTE_INTERVAL = 25;
+      function removeFormattingTokens(input) {
+          if (input.match(/\[[\s\S]/)) {
+              return input.replace(/^\[|\]$/g, '');
+          }
+          return input.replace(/\\/g, '');
+      }
 
-  var INPUT_START = 1;
-  var INPUT_MOVE = 2;
-  var INPUT_END = 4;
-  var INPUT_CANCEL = 8;
+      function makeFormatFunction(format) {
+          var array = format.match(formattingTokens), i, length;
 
-  var DIRECTION_NONE = 1;
-  var DIRECTION_LEFT = 2;
-  var DIRECTION_RIGHT = 4;
-  var DIRECTION_UP = 8;
-  var DIRECTION_DOWN = 16;
+          for (i = 0, length = array.length; i < length; i++) {
+              if (formatTokenFunctions[array[i]]) {
+                  array[i] = formatTokenFunctions[array[i]];
+              } else {
+                  array[i] = removeFormattingTokens(array[i]);
+              }
+          }
 
-  var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
-  var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
-  var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
+          return function (mom) {
+              var output = '';
+              for (i = 0; i < length; i++) {
+                  output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
+              }
+              return output;
+          };
+      }
 
-  var PROPS_XY = ['x', 'y'];
-  var PROPS_CLIENT_XY = ['clientX', 'clientY'];
+      // format date using native date object
+      function formatMoment(m, format) {
+          if (!m.isValid()) {
+              return m.localeData().invalidDate();
+          }
 
-  /**
-   * create new input type manager
-   * @param {Manager} manager
-   * @param {Function} callback
-   * @returns {Input}
-   * @constructor
-   */
-  function Input(manager, callback) {
-      var self = this;
-      this.manager = manager;
-      this.callback = callback;
-      this.element = manager.element;
-      this.target = manager.options.inputTarget;
+          format = expandFormat(format, m.localeData());
 
-      // smaller wrapper around the handler, for the scope and the enabled state of the manager,
-      // so when disabled the input events are completely bypassed.
-      this.domHandler = function(ev) {
-          if (boolOrFn(manager.options.enable, [manager])) {
-              self.handler(ev);
+          if (!formatFunctions[format]) {
+              formatFunctions[format] = makeFormatFunction(format);
           }
-      };
 
-      this.init();
+          return formatFunctions[format](m);
+      }
 
-  }
+      function expandFormat(format, locale) {
+          var i = 5;
 
-  Input.prototype = {
-      /**
-       * should handle the inputEvent data and trigger the callback
-       * @virtual
-       */
-      handler: function() { },
+          function replaceLongDateFormatTokens(input) {
+              return locale.longDateFormat(input) || input;
+          }
 
-      /**
-       * bind the events
-       */
-      init: function() {
-          this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
-          this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
-          this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
-      },
+          localFormattingTokens.lastIndex = 0;
+          while (i >= 0 && localFormattingTokens.test(format)) {
+              format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
+              localFormattingTokens.lastIndex = 0;
+              i -= 1;
+          }
 
-      /**
-       * unbind the events
-       */
-      destroy: function() {
-          this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
-          this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
-          this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+          return format;
       }
-  };
 
-  /**
-   * create new input type manager
-   * called by the Manager constructor
-   * @param {Hammer} manager
-   * @returns {Input}
-   */
-  function createInputInstance(manager) {
-      var Type;
-      var inputClass = manager.options.inputClass;
+      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 match1to3      = /\d{1,3}/;       //       0 - 999
+      var match1to4      = /\d{1,4}/;       //       0 - 9999
+      var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
 
-      if (inputClass) {
-          Type = inputClass;
-      } else if (SUPPORT_POINTER_EVENTS) {
-          Type = PointerEventInput;
-      } else if (SUPPORT_ONLY_TOUCH) {
-          Type = TouchInput;
-      } else if (!SUPPORT_TOUCH) {
-          Type = MouseInput;
-      } else {
-          Type = TouchMouseInput;
-      }
-      return new (Type)(manager, inputHandler);
-  }
+      var matchUnsigned  = /\d+/;           //       0 - inf
+      var matchSigned    = /[+-]?\d+/;      //    -inf - inf
 
-  /**
-   * handle input events
-   * @param {Manager} manager
-   * @param {String} eventType
-   * @param {Object} input
-   */
-  function inputHandler(manager, eventType, input) {
-      var pointersLen = input.pointers.length;
-      var changedPointersLen = input.changedPointers.length;
-      var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));
-      var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));
+      var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
 
-      input.isFirst = !!isFirst;
-      input.isFinal = !!isFinal;
+      var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
 
-      if (isFirst) {
-          manager.session = {};
-      }
+      // any word (or two) characters or numbers including two/three word month in arabic.
+      var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
 
-      // source event is the normalized value of the domEvents
-      // like 'touchstart, mouseup, pointerdown'
-      input.eventType = eventType;
+      var regexes = {};
 
-      // compute scale, rotation etc
-      computeInputData(manager, input);
+      function addRegexToken (token, regex, strictRegex) {
+          regexes[token] = typeof regex === 'function' ? regex : function (isStrict) {
+              return (isStrict && strictRegex) ? strictRegex : regex;
+          };
+      }
 
-      // emit secret event
-      manager.emit('hammer.input', input);
+      function getParseRegexForToken (token, config) {
+          if (!hasOwnProp(regexes, token)) {
+              return new RegExp(unescapeFormat(token));
+          }
 
-      manager.recognize(input);
-      manager.session.prevInput = input;
-  }
+          return regexes[token](config._strict, config._locale);
+      }
 
-  /**
-   * extend the data with some usable properties like scale, rotate, velocity etc
-   * @param {Object} manager
-   * @param {Object} input
-   */
-  function computeInputData(manager, input) {
-      var session = manager.session;
-      var pointers = input.pointers;
-      var pointersLength = pointers.length;
+      // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+      function unescapeFormat(s) {
+          return s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
+              return p1 || p2 || p3 || p4;
+          }).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+      }
 
-      // store the first input to calculate the distance and direction
-      if (!session.firstInput) {
-          session.firstInput = simpleCloneInputData(input);
+      var tokens = {};
+
+      function addParseToken (token, callback) {
+          var i, func = callback;
+          if (typeof token === 'string') {
+              token = [token];
+          }
+          if (typeof callback === 'number') {
+              func = function (input, array) {
+                  array[callback] = toInt(input);
+              };
+          }
+          for (i = 0; i < token.length; i++) {
+              tokens[token[i]] = func;
+          }
       }
 
-      // to compute scale and rotation we need to store the multiple touches
-      if (pointersLength > 1 && !session.firstMultiple) {
-          session.firstMultiple = simpleCloneInputData(input);
-      } else if (pointersLength === 1) {
-          session.firstMultiple = false;
+      function addWeekParseToken (token, callback) {
+          addParseToken(token, function (input, array, config, token) {
+              config._w = config._w || {};
+              callback(input, config._w, config, token);
+          });
       }
 
-      var firstInput = session.firstInput;
-      var firstMultiple = session.firstMultiple;
-      var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
+      function addTimeToArrayFromToken(token, input, config) {
+          if (input != null && hasOwnProp(tokens, token)) {
+              tokens[token](input, config._a, config, token);
+          }
+      }
 
-      var center = input.center = getCenter(pointers);
-      input.timeStamp = now();
-      input.deltaTime = input.timeStamp - firstInput.timeStamp;
+      var YEAR = 0;
+      var MONTH = 1;
+      var DATE = 2;
+      var HOUR = 3;
+      var MINUTE = 4;
+      var SECOND = 5;
+      var MILLISECOND = 6;
 
-      input.angle = getAngle(offsetCenter, center);
-      input.distance = getDistance(offsetCenter, center);
+      function daysInMonth(year, month) {
+          return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+      }
 
-      computeDeltaXY(session, input);
-      input.offsetDirection = getDirection(input.deltaX, input.deltaY);
+      // FORMATTING
 
-      input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
-      input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
+      addFormatToken('M', ['MM', 2], 'Mo', function () {
+          return this.month() + 1;
+      });
 
-      computeIntervalInputData(session, input);
+      addFormatToken('MMM', 0, 0, function (format) {
+          return this.localeData().monthsShort(this, format);
+      });
 
-      // find the correct target
-      var target = manager.element;
-      if (hasParent(input.srcEvent.target, target)) {
-          target = input.srcEvent.target;
-      }
-      input.target = target;
-  }
+      addFormatToken('MMMM', 0, 0, function (format) {
+          return this.localeData().months(this, format);
+      });
 
-  function computeDeltaXY(session, input) {
-      var center = input.center;
-      var offset = session.offsetDelta || {};
-      var prevDelta = session.prevDelta || {};
-      var prevInput = session.prevInput || {};
+      // ALIASES
 
-      if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
-          prevDelta = session.prevDelta = {
-              x: prevInput.deltaX || 0,
-              y: prevInput.deltaY || 0
-          };
+      addUnitAlias('month', 'M');
 
-          offset = session.offsetDelta = {
-              x: center.x,
-              y: center.y
-          };
-      }
+      // PARSING
 
-      input.deltaX = prevDelta.x + (center.x - offset.x);
-      input.deltaY = prevDelta.y + (center.y - offset.y);
-  }
+      addRegexToken('M',    match1to2);
+      addRegexToken('MM',   match1to2, match2);
+      addRegexToken('MMM',  matchWord);
+      addRegexToken('MMMM', matchWord);
 
-  /**
-   * velocity is calculated every x ms
-   * @param {Object} session
-   * @param {Object} input
-   */
-  function computeIntervalInputData(session, input) {
-      var last = session.lastInterval || input,
-          deltaTime = input.timeStamp - last.timeStamp,
-          velocity, velocityX, velocityY, direction;
+      addParseToken(['M', 'MM'], function (input, array) {
+          array[MONTH] = toInt(input) - 1;
+      });
 
-      if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
-          var deltaX = last.deltaX - input.deltaX;
-          var deltaY = last.deltaY - input.deltaY;
+      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 {
+              config._pf.invalidMonth = input;
+          }
+      });
 
-          var v = getVelocity(deltaTime, deltaX, deltaY);
-          velocityX = v.x;
-          velocityY = v.y;
-          velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;
-          direction = getDirection(deltaX, deltaY);
+      // LOCALES
 
-          session.lastInterval = input;
-      } else {
-          // use latest velocity info if it doesn't overtake a minimum period
-          velocity = last.velocity;
-          velocityX = last.velocityX;
-          velocityY = last.velocityY;
-          direction = last.direction;
+      var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
+      function localeMonths (m) {
+          return this._months[m.month()];
       }
 
-      input.velocity = velocity;
-      input.velocityX = velocityX;
-      input.velocityY = velocityY;
-      input.direction = direction;
-  }
+      var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
+      function localeMonthsShort (m) {
+          return this._monthsShort[m.month()];
+      }
 
-  /**
-   * create a simple clone from the input used for storage of firstInput and firstMultiple
-   * @param {Object} input
-   * @returns {Object} clonedInputData
-   */
-  function simpleCloneInputData(input) {
-      // make a simple copy of the pointers because we will get a reference if we don't
-      // we only need clientXY for the calculations
-      var pointers = [];
-      var i = 0;
-      while (i < input.pointers.length) {
-          pointers[i] = {
-              clientX: round(input.pointers[i].clientX),
-              clientY: round(input.pointers[i].clientY)
-          };
-          i++;
+      function localeMonthsParse (monthName, format, strict) {
+          var i, mom, regex;
+
+          if (!this._monthsParse) {
+              this._monthsParse = [];
+              this._longMonthsParse = [];
+              this._shortMonthsParse = [];
+          }
+
+          for (i = 0; i < 12; i++) {
+              // make the regex if we don't have it already
+              mom = create_utc__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;
+              }
+          }
       }
 
-      return {
-          timeStamp: now(),
-          pointers: pointers,
-          center: getCenter(pointers),
-          deltaX: input.deltaX,
-          deltaY: input.deltaY
-      };
-  }
+      // MOMENTS
 
-  /**
-   * get the center of all the pointers
-   * @param {Array} pointers
-   * @return {Object} center contains `x` and `y` properties
-   */
-  function getCenter(pointers) {
-      var pointersLength = pointers.length;
+      function setMonth (mom, value) {
+          var dayOfMonth;
 
-      // no need to loop when only one touch
-      if (pointersLength === 1) {
-          return {
-              x: round(pointers[0].clientX),
-              y: round(pointers[0].clientY)
-          };
+          // TODO: Move this out of here!
+          if (typeof value === 'string') {
+              value = mom.localeData().monthsParse(value);
+              // TODO: Another silent failure?
+              if (typeof value !== 'number') {
+                  return mom;
+              }
+          }
+
+          dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
+          mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+          return mom;
       }
 
-      var x = 0, y = 0, i = 0;
-      while (i < pointersLength) {
-          x += pointers[i].clientX;
-          y += pointers[i].clientY;
-          i++;
+      function getSetMonth (value) {
+          if (value != null) {
+              setMonth(this, value);
+              utils_hooks__hooks.updateOffset(this, true);
+              return this;
+          } else {
+              return get_set__get(this, 'Month');
+          }
       }
 
-      return {
-          x: round(x / pointersLength),
-          y: round(y / pointersLength)
-      };
-  }
+      function getDaysInMonth () {
+          return daysInMonth(this.year(), this.month());
+      }
 
-  /**
-   * calculate the velocity between two points. unit is in px per ms.
-   * @param {Number} deltaTime
-   * @param {Number} x
-   * @param {Number} y
-   * @return {Object} velocity `x` and `y`
-   */
-  function getVelocity(deltaTime, x, y) {
-      return {
-          x: x / deltaTime || 0,
-          y: y / deltaTime || 0
-      };
-  }
+      function checkOverflow (m) {
+          var overflow;
+          var a = m._a;
 
-  /**
-   * get the direction between two points
-   * @param {Number} x
-   * @param {Number} y
-   * @return {Number} direction
-   */
-  function getDirection(x, y) {
-      if (x === y) {
-          return DIRECTION_NONE;
+          if (a && m._pf.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 (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+                  overflow = DATE;
+              }
+
+              m._pf.overflow = overflow;
+          }
+
+          return m;
       }
 
-      if (abs(x) >= abs(y)) {
-          return x > 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
+      function warn(msg) {
+          if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
+              console.warn('Deprecation warning: ' + msg);
+          }
       }
-      return y > 0 ? DIRECTION_UP : DIRECTION_DOWN;
-  }
 
-  /**
-   * calculate the absolute distance between two points
-   * @param {Object} p1 {x, y}
-   * @param {Object} p2 {x, y}
-   * @param {Array} [props] containing x and y keys
-   * @return {Number} distance
-   */
-  function getDistance(p1, p2, props) {
-      if (!props) {
-          props = PROPS_XY;
+      function deprecate(msg, fn) {
+          var firstTime = true;
+          return extend(function () {
+              if (firstTime) {
+                  warn(msg);
+                  firstTime = false;
+              }
+              return fn.apply(this, arguments);
+          }, fn);
       }
-      var x = p2[props[0]] - p1[props[0]],
-          y = p2[props[1]] - p1[props[1]];
 
-      return Math.sqrt((x * x) + (y * y));
-  }
+      var deprecations = {};
 
-  /**
-   * calculate the angle between two coordinates
-   * @param {Object} p1
-   * @param {Object} p2
-   * @param {Array} [props] containing x and y keys
-   * @return {Number} angle
-   */
-  function getAngle(p1, p2, props) {
-      if (!props) {
-          props = PROPS_XY;
+      function deprecateSimple(name, msg) {
+          if (!deprecations[name]) {
+              warn(msg);
+              deprecations[name] = true;
+          }
       }
-      var x = p2[props[0]] - p1[props[0]],
-          y = p2[props[1]] - p1[props[1]];
-      return Math.atan2(y, x) * 180 / Math.PI;
-  }
 
-  /**
-   * calculate the rotation degrees between two pointersets
-   * @param {Array} start array of pointers
-   * @param {Array} end array of pointers
-   * @return {Number} rotation
-   */
-  function getRotation(start, end) {
-      return getAngle(end[1], end[0], PROPS_CLIENT_XY) - getAngle(start[1], start[0], PROPS_CLIENT_XY);
-  }
+      utils_hooks__hooks.suppressDeprecationWarnings = false;
 
-  /**
-   * calculate the scale factor between two pointersets
-   * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
-   * @param {Array} start array of pointers
-   * @param {Array} end array of pointers
-   * @return {Number} scale
-   */
-  function getScale(start, end) {
-      return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
-  }
+      var from_string__isoRegex = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
 
-  var MOUSE_INPUT_MAP = {
-      mousedown: INPUT_START,
-      mousemove: INPUT_MOVE,
-      mouseup: INPUT_END
-  };
+      var isoDates = [
+          ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
+          ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
+          ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
+          ['GGGG-[W]WW', /\d{4}-W\d{2}/],
+          ['YYYY-DDD', /\d{4}-\d{3}/]
+      ];
 
-  var MOUSE_ELEMENT_EVENTS = 'mousedown';
-  var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
+      // iso time formats and regexes
+      var isoTimes = [
+          ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
+          ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
+          ['HH:mm', /(T| )\d\d:\d\d/],
+          ['HH', /(T| )\d\d/]
+      ];
 
-  /**
-   * Mouse events input
-   * @constructor
-   * @extends Input
-   */
-  function MouseInput() {
-      this.evEl = MOUSE_ELEMENT_EVENTS;
-      this.evWin = MOUSE_WINDOW_EVENTS;
+      var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
 
-      this.allow = true; // used by Input.TouchMouse to disable mouse events
-      this.pressed = false; // mousedown state
+      // date from iso format
+      function configFromISO(config) {
+          var i, l,
+              string = config._i,
+              match = from_string__isoRegex.exec(string);
 
-      Input.apply(this, arguments);
-  }
+          if (match) {
+              config._pf.iso = true;
+              for (i = 0, l = isoDates.length; i < l; i++) {
+                  if (isoDates[i][1].exec(string)) {
+                      // match[5] should be 'T' or undefined
+                      config._f = isoDates[i][0] + (match[6] || ' ');
+                      break;
+                  }
+              }
+              for (i = 0, l = isoTimes.length; i < l; i++) {
+                  if (isoTimes[i][1].exec(string)) {
+                      config._f += isoTimes[i][0];
+                      break;
+                  }
+              }
+              if (string.match(matchOffset)) {
+                  config._f += 'Z';
+              }
+              configFromStringAndFormat(config);
+          } else {
+              config._isValid = false;
+          }
+      }
 
-  inherit(MouseInput, Input, {
-      /**
-       * handle mouse events
-       * @param {Object} ev
-       */
-      handler: function MEhandler(ev) {
-          var eventType = MOUSE_INPUT_MAP[ev.type];
+      // date from iso format or fallback
+      function configFromString(config) {
+          var matched = aspNetJsonRegex.exec(config._i);
 
-          // on start we want to have the left mouse button down
-          if (eventType & INPUT_START && ev.button === 0) {
-              this.pressed = true;
+          if (matched !== null) {
+              config._d = new Date(+matched[1]);
+              return;
           }
 
-          if (eventType & INPUT_MOVE && ev.which !== 1) {
-              eventType = INPUT_END;
+          configFromISO(config);
+          if (config._isValid === false) {
+              delete config._isValid;
+              utils_hooks__hooks.createFromInputFallback(config);
           }
+      }
 
-          // mouse must be down, and mouse events are allowed (see the TouchMouse input)
-          if (!this.pressed || !this.allow) {
-              return;
+      utils_hooks__hooks.createFromInputFallback = deprecate(
+          'moment construction falls back to js Date. This is ' +
+          'discouraged and will be removed in upcoming major ' +
+          'release. Please refer to ' +
+          'https://github.com/moment/moment/issues/1407 for more info.',
+          function (config) {
+              config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
           }
+      );
 
-          if (eventType & INPUT_END) {
-              this.pressed = false;
+      function createDate (y, m, d, h, M, s, ms) {
+          //can't just apply() to create a date:
+          //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
+          var date = new Date(y, m, d, h, M, s, ms);
+
+          //the date constructor doesn't accept years < 1970
+          if (y < 1970) {
+              date.setFullYear(y);
           }
+          return date;
+      }
 
-          this.callback(this.manager, eventType, {
-              pointers: [ev],
-              changedPointers: [ev],
-              pointerType: INPUT_TYPE_MOUSE,
-              srcEvent: ev
-          });
+      function createUTCDate (y) {
+          var date = new Date(Date.UTC.apply(null, arguments));
+          if (y < 1970) {
+              date.setUTCFullYear(y);
+          }
+          return date;
       }
-  });
 
-  var POINTER_INPUT_MAP = {
-      pointerdown: INPUT_START,
-      pointermove: INPUT_MOVE,
-      pointerup: INPUT_END,
-      pointercancel: INPUT_CANCEL,
-      pointerout: INPUT_CANCEL
-  };
+      addFormatToken(0, ['YY', 2], 0, function () {
+          return this.year() % 100;
+      });
 
-  // in IE10 the pointer types is defined as an enum
-  var IE10_POINTER_TYPE_ENUM = {
-      2: INPUT_TYPE_TOUCH,
-      3: INPUT_TYPE_PEN,
-      4: INPUT_TYPE_MOUSE,
-      5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816
-  };
+      addFormatToken(0, ['YYYY',   4],       0, 'year');
+      addFormatToken(0, ['YYYYY',  5],       0, 'year');
+      addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
 
-  var POINTER_ELEMENT_EVENTS = 'pointerdown';
-  var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';
+      // ALIASES
 
-  // IE10 has prefixed support, and case-sensitive
-  if (window.MSPointerEvent) {
-      POINTER_ELEMENT_EVENTS = 'MSPointerDown';
-      POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
-  }
+      addUnitAlias('year', 'y');
 
-  /**
-   * Pointer events input
-   * @constructor
-   * @extends Input
-   */
-  function PointerEventInput() {
-      this.evEl = POINTER_ELEMENT_EVENTS;
-      this.evWin = POINTER_WINDOW_EVENTS;
+      // PARSING
 
-      Input.apply(this, arguments);
+      addRegexToken('Y',      matchSigned);
+      addRegexToken('YY',     match1to2, match2);
+      addRegexToken('YYYY',   match1to4, match4);
+      addRegexToken('YYYYY',  match1to6, match6);
+      addRegexToken('YYYYYY', match1to6, match6);
 
-      this.store = (this.manager.session.pointerEvents = []);
-  }
+      addParseToken(['YYYY', 'YYYYY', 'YYYYYY'], YEAR);
+      addParseToken('YY', function (input, array) {
+          array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
+      });
 
-  inherit(PointerEventInput, Input, {
-      /**
-       * handle mouse events
-       * @param {Object} ev
-       */
-      handler: function PEhandler(ev) {
-          var store = this.store;
-          var removePointer = false;
-
-          var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
-          var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
-          var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
+      // HELPERS
 
-          var isTouch = (pointerType == INPUT_TYPE_TOUCH);
+      function daysInYear(year) {
+          return isLeapYear(year) ? 366 : 365;
+      }
 
-          // get index of the event in the store
-          var storeIndex = inArray(store, ev.pointerId, 'pointerId');
+      function isLeapYear(year) {
+          return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+      }
 
-          // start and mouse must be down
-          if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
-              if (storeIndex < 0) {
-                  store.push(ev);
-                  storeIndex = store.length - 1;
-              }
-          } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
-              removePointer = true;
-          }
+      // HOOKS
 
-          // it not found, so the pointer hasn't been down (so it's probably a hover)
-          if (storeIndex < 0) {
-              return;
-          }
+      utils_hooks__hooks.parseTwoDigitYear = function (input) {
+          return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+      };
 
-          // update the event in the store
-          store[storeIndex] = ev;
+      // MOMENTS
 
-          this.callback(this.manager, eventType, {
-              pointers: store,
-              changedPointers: [ev],
-              pointerType: pointerType,
-              srcEvent: ev
-          });
+      var getSetYear = makeGetSet('FullYear', false);
 
-          if (removePointer) {
-              // remove from the store
-              store.splice(storeIndex, 1);
-          }
+      function getIsLeapYear () {
+          return isLeapYear(this.year());
       }
-  });
 
-  var SINGLE_TOUCH_INPUT_MAP = {
-      touchstart: INPUT_START,
-      touchmove: INPUT_MOVE,
-      touchend: INPUT_END,
-      touchcancel: INPUT_CANCEL
-  };
+      addFormatToken('w', ['ww', 2], 'wo', 'week');
+      addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
 
-  var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
-  var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
+      // ALIASES
 
-  /**
-   * Touch events input
-   * @constructor
-   * @extends Input
-   */
-  function SingleTouchInput() {
-      this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
-      this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
-      this.started = false;
+      addUnitAlias('week', 'w');
+      addUnitAlias('isoWeek', 'W');
 
-      Input.apply(this, arguments);
-  }
+      // PARSING
 
-  inherit(SingleTouchInput, Input, {
-      handler: function TEhandler(ev) {
-          var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
+      addRegexToken('w',  match1to2);
+      addRegexToken('ww', match1to2, match2);
+      addRegexToken('W',  match1to2);
+      addRegexToken('WW', match1to2, match2);
 
-          // should we handle the touch events?
-          if (type === INPUT_START) {
-              this.started = true;
-          }
+      addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
+          week[token.substr(0, 1)] = toInt(input);
+      });
 
-          if (!this.started) {
-              return;
-          }
+      // HELPERS
 
-          var touches = normalizeSingleTouches.call(this, ev, type);
+      // firstDayOfWeek       0 = sun, 6 = sat
+      //                      the day of the week that starts the week
+      //                      (usually sunday or monday)
+      // firstDayOfWeekOfYear 0 = sun, 6 = sat
+      //                      the first week is the week that contains the first
+      //                      of this day of the week
+      //                      (eg. ISO weeks use thursday (4))
+      function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
+          var end = firstDayOfWeekOfYear - firstDayOfWeek,
+              daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
+              adjustedMoment;
 
-          // when done, reset the started state
-          if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
-              this.started = false;
+
+          if (daysToDayOfWeek > end) {
+              daysToDayOfWeek -= 7;
           }
 
-          this.callback(this.manager, type, {
-              pointers: touches[0],
-              changedPointers: touches[1],
-              pointerType: INPUT_TYPE_TOUCH,
-              srcEvent: ev
-          });
+          if (daysToDayOfWeek < end - 7) {
+              daysToDayOfWeek += 7;
+          }
+
+          adjustedMoment = local__createLocal(mom).add(daysToDayOfWeek, 'd');
+          return {
+              week: Math.ceil(adjustedMoment.dayOfYear() / 7),
+              year: adjustedMoment.year()
+          };
       }
-  });
 
-  /**
-   * @this {TouchInput}
-   * @param {Object} ev
-   * @param {Number} type flag
-   * @returns {undefined|Array} [all, changed]
-   */
-  function normalizeSingleTouches(ev, type) {
-      var all = toArray(ev.touches);
-      var changed = toArray(ev.changedTouches);
+      // LOCALES
 
-      if (type & (INPUT_END | INPUT_CANCEL)) {
-          all = uniqueArray(all.concat(changed), 'identifier', true);
+      function localeWeek (mom) {
+          return weekOfYear(mom, this._week.dow, this._week.doy).week;
       }
 
-      return [all, changed];
-  }
-
-  var TOUCH_INPUT_MAP = {
-      touchstart: INPUT_START,
-      touchmove: INPUT_MOVE,
-      touchend: INPUT_END,
-      touchcancel: INPUT_CANCEL
-  };
+      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.
+      };
 
-  var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
+      function localeFirstDayOfWeek () {
+          return this._week.dow;
+      }
 
-  /**
-   * Multi-user touch events input
-   * @constructor
-   * @extends Input
-   */
-  function TouchInput() {
-      this.evTarget = TOUCH_TARGET_EVENTS;
-      this.targetIds = {};
+      function localeFirstDayOfYear () {
+          return this._week.doy;
+      }
 
-      Input.apply(this, arguments);
-  }
+      // MOMENTS
 
-  inherit(TouchInput, Input, {
-      handler: function MTEhandler(ev) {
-          var type = TOUCH_INPUT_MAP[ev.type];
-          var touches = getTouches.call(this, ev, type);
-          if (!touches) {
-              return;
-          }
+      function getSetWeek (input) {
+          var week = this.localeData().week(this);
+          return input == null ? week : this.add((input - week) * 7, 'd');
+      }
 
-          this.callback(this.manager, type, {
-              pointers: touches[0],
-              changedPointers: touches[1],
-              pointerType: INPUT_TYPE_TOUCH,
-              srcEvent: ev
-          });
+      function getSetISOWeek (input) {
+          var week = weekOfYear(this, 1, 4).week;
+          return input == null ? week : this.add((input - week) * 7, 'd');
       }
-  });
 
-  /**
-   * @this {TouchInput}
-   * @param {Object} ev
-   * @param {Number} type flag
-   * @returns {undefined|Array} [all, changed]
-   */
-  function getTouches(ev, type) {
-      var allTouches = toArray(ev.touches);
-      var targetIds = this.targetIds;
+      addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
 
-      // when there is only one touch, the process can be simplified
-      if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
-          targetIds[allTouches[0].identifier] = true;
-          return [allTouches, allTouches];
-      }
+      // ALIASES
 
-      var i,
-          targetTouches,
-          changedTouches = toArray(ev.changedTouches),
-          changedTargetTouches = [],
-          target = this.target;
+      addUnitAlias('dayOfYear', 'DDD');
 
-      // get target touches from touches
-      targetTouches = allTouches.filter(function(touch) {
-          return hasParent(touch.target, target);
+      // PARSING
+
+      addRegexToken('DDD',  match1to3);
+      addRegexToken('DDDD', match3);
+      addParseToken(['DDD', 'DDDD'], function (input, array, config) {
+          config._dayOfYear = toInt(input);
       });
 
-      // collect touches
-      if (type === INPUT_START) {
-          i = 0;
-          while (i < targetTouches.length) {
-              targetIds[targetTouches[i].identifier] = true;
-              i++;
-          }
-      }
+      // HELPERS
 
-      // filter changed touches to only contain touches that exist in the collected target ids
-      i = 0;
-      while (i < changedTouches.length) {
-          if (targetIds[changedTouches[i].identifier]) {
-              changedTargetTouches.push(changedTouches[i]);
-          }
+      //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+      function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
+          var d = createUTCDate(year, 0, 1).getUTCDay();
+          var daysToAdd;
+          var dayOfYear;
 
-          // cleanup removed touches
-          if (type & (INPUT_END | INPUT_CANCEL)) {
-              delete targetIds[changedTouches[i].identifier];
-          }
-          i++;
-      }
+          d = d === 0 ? 7 : d;
+          weekday = weekday != null ? weekday : firstDayOfWeek;
+          daysToAdd = firstDayOfWeek - d + (d > firstDayOfWeekOfYear ? 7 : 0) - (d < firstDayOfWeek ? 7 : 0);
+          dayOfYear = 7 * (week - 1) + (weekday - firstDayOfWeek) + daysToAdd + 1;
 
-      if (!changedTargetTouches.length) {
-          return;
+          return {
+              year      : dayOfYear > 0 ? year      : year - 1,
+              dayOfYear : dayOfYear > 0 ? dayOfYear : daysInYear(year - 1) + dayOfYear
+          };
       }
 
-      return [
-          // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
-          uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),
-          changedTargetTouches
-      ];
-  }
-
-  /**
-   * Combined touch and mouse input
-   *
-   * Touch has a higher priority then mouse, and while touching no mouse events are allowed.
-   * This because touch devices also emit mouse events while doing a touch.
-   *
-   * @constructor
-   * @extends Input
-   */
-  function TouchMouseInput() {
-      Input.apply(this, arguments);
-
-      var handler = bindFn(this.handler, this);
-      this.touch = new TouchInput(this.manager, handler);
-      this.mouse = new MouseInput(this.manager, handler);
-  }
+      // MOMENTS
 
-  inherit(TouchMouseInput, Input, {
-      /**
-       * handle mouse and touch events
-       * @param {Hammer} manager
-       * @param {String} inputEvent
-       * @param {Object} inputData
-       */
-      handler: function TMEhandler(manager, inputEvent, inputData) {
-          var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),
-              isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);
+      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');
+      }
 
-          // when we're in a touch event, so  block all upcoming mouse events
-          // most mobile browser also emit mouseevents, right after touchstart
-          if (isTouch) {
-              this.mouse.allow = false;
-          } else if (isMouse && !this.mouse.allow) {
-              return;
+      // Pick the first defined of two or three arguments.
+      function defaults(a, b, c) {
+          if (a != null) {
+              return a;
           }
-
-          // reset the allowMouse when we're done
-          if (inputEvent & (INPUT_END | INPUT_CANCEL)) {
-              this.mouse.allow = true;
+          if (b != null) {
+              return b;
           }
-
-          this.callback(manager, inputEvent, inputData);
-      },
-
-      /**
-       * remove the event listeners
-       */
-      destroy: function destroy() {
-          this.touch.destroy();
-          this.mouse.destroy();
+          return c;
       }
-  });
-
-  var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
-  var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
 
-  // magical touchAction value
-  var TOUCH_ACTION_COMPUTE = 'compute';
-  var TOUCH_ACTION_AUTO = 'auto';
-  var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
-  var TOUCH_ACTION_NONE = 'none';
-  var TOUCH_ACTION_PAN_X = 'pan-x';
-  var TOUCH_ACTION_PAN_Y = 'pan-y';
+      function currentDateArray(config) {
+          var now = new Date();
+          if (config._useUTC) {
+              return [now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()];
+          }
+          return [now.getFullYear(), now.getMonth(), now.getDate()];
+      }
 
-  /**
-   * Touch Action
-   * sets the touchAction property or uses the js alternative
-   * @param {Manager} manager
-   * @param {String} value
-   * @constructor
-   */
-  function TouchAction(manager, value) {
-      this.manager = manager;
-      this.set(value);
-  }
+      // 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;
 
-  TouchAction.prototype = {
-      /**
-       * set the touchAction value on the element or enable the polyfill
-       * @param {String} value
-       */
-      set: function(value) {
-          // find out the touch-action by the event handlers
-          if (value == TOUCH_ACTION_COMPUTE) {
-              value = this.compute();
+          if (config._d) {
+              return;
           }
 
-          if (NATIVE_TOUCH_ACTION) {
-              this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
+          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);
           }
-          this.actions = value.toLowerCase().trim();
-      },
 
-      /**
-       * just re-set the touchAction value
-       */
-      update: function() {
-          this.set(this.manager.options.touchAction);
-      },
+          //if the day of the year is set, figure out what it is
+          if (config._dayOfYear) {
+              yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
 
-      /**
-       * compute the value for the touchAction property based on the recognizer's settings
-       * @returns {String} value
-       */
-      compute: function() {
-          var actions = [];
-          each(this.manager.recognizers, function(recognizer) {
-              if (boolOrFn(recognizer.options.enable, [recognizer])) {
-                  actions = actions.concat(recognizer.getTouchAction());
+              if (config._dayOfYear > daysInYear(yearToUse)) {
+                  config._pf._overflowDayOfYear = true;
               }
-          });
-          return cleanTouchActions(actions.join(' '));
-      },
 
-      /**
-       * this method is called on each input cycle and provides the preventing of the browser behavior
-       * @param {Object} input
-       */
-      preventDefaults: function(input) {
-          // not needed with native support for the touchAction property
-          if (NATIVE_TOUCH_ACTION) {
-              return;
+              date = createUTCDate(yearToUse, 0, config._dayOfYear);
+              config._a[MONTH] = date.getUTCMonth();
+              config._a[DATE] = date.getUTCDate();
           }
 
-          var srcEvent = input.srcEvent;
-          var direction = input.offsetDirection;
-
-          // if the touch action did prevented once this session
-          if (this.manager.session.prevented) {
-              srcEvent.preventDefault();
-              return;
+          // 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];
           }
 
-          var actions = this.actions;
-          var hasNone = inStr(actions, TOUCH_ACTION_NONE);
-          var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
-          var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
+          // 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];
+          }
 
-          if (hasNone ||
-              (hasPanY && direction & DIRECTION_HORIZONTAL) ||
-              (hasPanX && direction & DIRECTION_VERTICAL)) {
-              return this.preventSrc(srcEvent);
+          // 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;
           }
-      },
 
-      /**
-       * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
-       * @param {Object} srcEvent
-       */
-      preventSrc: function(srcEvent) {
-          this.manager.session.prevented = true;
-          srcEvent.preventDefault();
-      }
-  };
+          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);
+          }
 
-  /**
-   * when the touchActions are collected they are not a valid value, so we need to clean things up. *
-   * @param {String} actions
-   * @returns {*}
-   */
-  function cleanTouchActions(actions) {
-      // none
-      if (inStr(actions, TOUCH_ACTION_NONE)) {
-          return TOUCH_ACTION_NONE;
+          if (config._nextDay) {
+              config._a[HOUR] = 24;
+          }
       }
 
-      var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
-      var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
-
-      // pan-x and pan-y can be combined
-      if (hasPanX && hasPanY) {
-          return TOUCH_ACTION_PAN_X + ' ' + TOUCH_ACTION_PAN_Y;
-      }
+      function dayOfYearFromWeekInfo(config) {
+          var w, weekYear, week, weekday, dow, doy, temp;
 
-      // pan-x OR pan-y
-      if (hasPanX || hasPanY) {
-          return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
-      }
+          w = config._w;
+          if (w.GG != null || w.W != null || w.E != null) {
+              dow = 1;
+              doy = 4;
 
-      // manipulation
-      if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
-          return TOUCH_ACTION_MANIPULATION;
-      }
+              // 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(local__createLocal(), 1, 4).year);
+              week = defaults(w.W, 1);
+              weekday = defaults(w.E, 1);
+          } else {
+              dow = config._locale._week.dow;
+              doy = config._locale._week.doy;
 
-      return TOUCH_ACTION_AUTO;
-  }
+              weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
+              week = defaults(w.w, 1);
 
-  /**
-   * Recognizer flow explained; *
-   * All recognizers have the initial state of POSSIBLE when a input session starts.
-   * The definition of a input session is from the first input until the last input, with all it's movement in it. *
-   * Example session for mouse-input: mousedown -> mousemove -> mouseup
-   *
-   * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
-   * which determines with state it should be.
-   *
-   * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
-   * POSSIBLE to give it another change on the next cycle.
-   *
-   *               Possible
-   *                  |
-   *            +-----+---------------+
-   *            |                     |
-   *      +-----+-----+               |
-   *      |           |               |
-   *   Failed      Cancelled          |
-   *                          +-------+------+
-   *                          |              |
-   *                      Recognized       Began
-   *                                         |
-   *                                      Changed
-   *                                         |
-   *                                  Ended/Recognized
-   */
-  var STATE_POSSIBLE = 1;
-  var STATE_BEGAN = 2;
-  var STATE_CHANGED = 4;
-  var STATE_ENDED = 8;
-  var STATE_RECOGNIZED = STATE_ENDED;
-  var STATE_CANCELLED = 16;
-  var STATE_FAILED = 32;
-
-  /**
-   * Recognizer
-   * Every recognizer needs to extend from this class.
-   * @constructor
-   * @param {Object} options
-   */
-  function Recognizer(options) {
-      this.id = uniqueId();
-
-      this.manager = null;
-      this.options = merge(options || {}, this.defaults);
+              if (w.d != null) {
+                  // weekday -- low day numbers are considered next week
+                  weekday = w.d;
+                  if (weekday < dow) {
+                      ++week;
+                  }
+              } else if (w.e != null) {
+                  // local weekday -- counting starts from begining of week
+                  weekday = w.e + dow;
+              } else {
+                  // default to begining of week
+                  weekday = dow;
+              }
+          }
+          temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
 
-      // default is enable true
-      this.options.enable = ifUndefined(this.options.enable, true);
+          config._a[YEAR] = temp.year;
+          config._dayOfYear = temp.dayOfYear;
+      }
 
-      this.state = STATE_POSSIBLE;
+      utils_hooks__hooks.ISO_8601 = function () {};
 
-      this.simultaneous = {};
-      this.requireFail = [];
-  }
+      // 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 === utils_hooks__hooks.ISO_8601) {
+              configFromISO(config);
+              return;
+          }
 
-  Recognizer.prototype = {
-      /**
-       * @virtual
-       * @type {Object}
-       */
-      defaults: {},
+          config._a = [];
+          config._pf.empty = true;
 
-      /**
-       * set options
-       * @param {Object} options
-       * @return {Recognizer}
-       */
-      set: function(options) {
-          extend(this.options, options);
+          // 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;
 
-          // also update the touchAction, in case something changed about the directions/enabled state
-          this.manager && this.manager.touchAction.update();
-          return this;
-      },
+          tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
 
-      /**
-       * recognize simultaneous with an other recognizer.
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      recognizeWith: function(otherRecognizer) {
-          if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
-              return this;
+          for (i = 0; i < tokens.length; i++) {
+              token = tokens[i];
+              parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
+              if (parsedInput) {
+                  skipped = string.substr(0, string.indexOf(parsedInput));
+                  if (skipped.length > 0) {
+                      config._pf.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) {
+                      config._pf.empty = false;
+                  }
+                  else {
+                      config._pf.unusedTokens.push(token);
+                  }
+                  addTimeToArrayFromToken(token, parsedInput, config);
+              }
+              else if (config._strict && !parsedInput) {
+                  config._pf.unusedTokens.push(token);
+              }
           }
 
-          var simultaneous = this.simultaneous;
-          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-          if (!simultaneous[otherRecognizer.id]) {
-              simultaneous[otherRecognizer.id] = otherRecognizer;
-              otherRecognizer.recognizeWith(this);
+          // add remaining unparsed input length to the string
+          config._pf.charsLeftOver = stringLength - totalParsedInputLength;
+          if (string.length > 0) {
+              config._pf.unusedInput.push(string);
           }
-          return this;
-      },
 
-      /**
-       * drop the simultaneous link. it doesnt remove the link on the other recognizer.
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      dropRecognizeWith: function(otherRecognizer) {
-          if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
-              return this;
+          // clear _12h flag if hour is <= 12
+          if (config._pf.bigHour === true && config._a[HOUR] <= 12) {
+              config._pf.bigHour = undefined;
           }
+          // handle meridiem
+          config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
 
-          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-          delete this.simultaneous[otherRecognizer.id];
-          return this;
-      },
+          configFromArray(config);
+          checkOverflow(config);
+      }
 
-      /**
-       * recognizer can only run when an other is failing
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      requireFailure: function(otherRecognizer) {
-          if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
-              return this;
-          }
 
-          var requireFail = this.requireFail;
-          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-          if (inArray(requireFail, otherRecognizer) === -1) {
-              requireFail.push(otherRecognizer);
-              otherRecognizer.requireFailure(this);
-          }
-          return this;
-      },
+      function meridiemFixWrap (locale, hour, meridiem) {
+          var isPm;
 
-      /**
-       * drop the requireFailure link. it does not remove the link on the other recognizer.
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      dropRequireFailure: function(otherRecognizer) {
-          if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
-              return this;
+          if (meridiem == null) {
+              // nothing to do
+              return hour;
           }
-
-          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-          var index = inArray(this.requireFail, otherRecognizer);
-          if (index > -1) {
-              this.requireFail.splice(index, 1);
+          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;
           }
-          return this;
-      },
-
-      /**
-       * has require failures boolean
-       * @returns {boolean}
-       */
-      hasRequireFailures: function() {
-          return this.requireFail.length > 0;
-      },
+      }
 
-      /**
-       * if the recognizer can recognize simultaneous with an other recognizer
-       * @param {Recognizer} otherRecognizer
-       * @returns {Boolean}
-       */
-      canRecognizeWith: function(otherRecognizer) {
-          return !!this.simultaneous[otherRecognizer.id];
-      },
+      function configFromStringAndArray(config) {
+          var tempConfig,
+              bestMoment,
 
-      /**
-       * You should use `tryEmit` instead of `emit` directly to check
-       * that all the needed recognizers has failed before emitting.
-       * @param {Object} input
-       */
-      emit: function(input) {
-          var self = this;
-          var state = this.state;
+              scoreToBeat,
+              i,
+              currentScore;
 
-          function emit(withState) {
-              self.manager.emit(self.options.event + (withState ? stateStr(state) : ''), input);
+          if (config._f.length === 0) {
+              config._pf.invalidFormat = true;
+              config._d = new Date(NaN);
+              return;
           }
 
-          // 'panstart' and 'panmove'
-          if (state < STATE_ENDED) {
-              emit(true);
-          }
+          for (i = 0; i < config._f.length; i++) {
+              currentScore = 0;
+              tempConfig = copyConfig({}, config);
+              if (config._useUTC != null) {
+                  tempConfig._useUTC = config._useUTC;
+              }
+              tempConfig._pf = defaultParsingFlags();
+              tempConfig._f = config._f[i];
+              configFromStringAndFormat(tempConfig);
 
-          emit(); // simple 'eventName' events
+              if (!valid__isValid(tempConfig)) {
+                  continue;
+              }
 
-          // panend and pancancel
-          if (state >= STATE_ENDED) {
-              emit(true);
-          }
-      },
+              // if there is any input that was not parsed add a penalty for that format
+              currentScore += tempConfig._pf.charsLeftOver;
 
-      /**
-       * Check that all the require failure recognizers has failed,
-       * if true, it emits a gesture event,
-       * otherwise, setup the state to FAILED.
-       * @param {Object} input
-       */
-      tryEmit: function(input) {
-          if (this.canEmit()) {
-              return this.emit(input);
-          }
-          // it's failing anyway
-          this.state = STATE_FAILED;
-      },
+              //or tokens
+              currentScore += tempConfig._pf.unusedTokens.length * 10;
 
-      /**
-       * can we emit?
-       * @returns {boolean}
-       */
-      canEmit: function() {
-          var i = 0;
-          while (i < this.requireFail.length) {
-              if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
-                  return false;
+              tempConfig._pf.score = currentScore;
+
+              if (scoreToBeat == null || currentScore < scoreToBeat) {
+                  scoreToBeat = currentScore;
+                  bestMoment = tempConfig;
               }
-              i++;
           }
-          return true;
-      },
 
-      /**
-       * update the recognizer
-       * @param {Object} inputData
-       */
-      recognize: function(inputData) {
-          // make a new copy of the inputData
-          // so we can change the inputData without messing up the other recognizers
-          var inputDataClone = extend({}, inputData);
+          extend(config, bestMoment || tempConfig);
+      }
 
-          // is is enabled and allow recognizing?
-          if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
-              this.reset();
-              this.state = STATE_FAILED;
+      function configFromObject(config) {
+          if (config._d) {
               return;
           }
 
-          // reset when we've reached the end
-          if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
-              this.state = STATE_POSSIBLE;
-          }
+          var i = normalizeObjectUnits(config._i);
+          config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond];
 
-          this.state = this.process(inputDataClone);
+          configFromArray(config);
+      }
 
-          // the recognizer has recognized a gesture
-          // so trigger an event
-          if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
-              this.tryEmit(inputDataClone);
+      function createFromConfig (config) {
+          var input = config._i,
+              format = config._f,
+              res;
+
+          config._locale = config._locale || locale_locales__getLocale(config._l);
+
+          if (input === null || (format === undefined && input === '')) {
+              return valid__createInvalid({nullInput: true});
           }
-      },
 
-      /**
-       * return the state of the recognizer
-       * the actual recognizing happens in this method
-       * @virtual
-       * @param {Object} inputData
-       * @returns {Const} STATE
-       */
-      process: function(inputData) { }, // jshint ignore:line
+          if (typeof input === 'string') {
+              config._i = input = config._locale.preparse(input);
+          }
 
-      /**
-       * return the preferred touch-action
-       * @virtual
-       * @returns {Array}
-       */
-      getTouchAction: function() { },
+          if (isMoment(input)) {
+              return new Moment(checkOverflow(input));
+          } else if (isArray(format)) {
+              configFromStringAndArray(config);
+          } else if (format) {
+              configFromStringAndFormat(config);
+          } else {
+              configFromInput(config);
+          }
 
-      /**
-       * called when the gesture isn't allowed to recognize
-       * like when another is being recognized or it is disabled
-       * @virtual
-       */
-      reset: function() { }
-  };
+          res = new Moment(checkOverflow(config));
+          if (res._nextDay) {
+              // Adding is smart enough around DST
+              res.add(1, 'd');
+              res._nextDay = undefined;
+          }
 
-  /**
-   * get a usable string, used as event postfix
-   * @param {Const} state
-   * @returns {String} state
-   */
-  function stateStr(state) {
-      if (state & STATE_CANCELLED) {
-          return 'cancel';
-      } else if (state & STATE_ENDED) {
-          return 'end';
-      } else if (state & STATE_CHANGED) {
-          return 'move';
-      } else if (state & STATE_BEGAN) {
-          return 'start';
+          return res;
       }
-      return '';
-  }
 
-  /**
-   * direction cons to string
-   * @param {Const} direction
-   * @returns {String}
-   */
-  function directionStr(direction) {
-      if (direction == DIRECTION_DOWN) {
-          return 'down';
-      } else if (direction == DIRECTION_UP) {
-          return 'up';
-      } else if (direction == DIRECTION_LEFT) {
-          return 'left';
-      } else if (direction == DIRECTION_RIGHT) {
-          return 'right';
+      function configFromInput(config) {
+          var input = config._i;
+          if (input === undefined) {
+              config._d = new Date();
+          } else if (isDate(input)) {
+              config._d = new Date(+input);
+          } 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 (typeof(input) === 'object') {
+              configFromObject(config);
+          } else if (typeof(input) === 'number') {
+              // from milliseconds
+              config._d = new Date(input);
+          } else {
+              utils_hooks__hooks.createFromInputFallback(config);
+          }
       }
-      return '';
-  }
 
-  /**
-   * get a recognizer by name if it is bound to a manager
-   * @param {Recognizer|String} otherRecognizer
-   * @param {Recognizer} recognizer
-   * @returns {Recognizer}
-   */
-  function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
-      var manager = recognizer.manager;
-      if (manager) {
-          return manager.get(otherRecognizer);
-      }
-      return otherRecognizer;
-  }
+      function createLocalOrUTC (input, format, locale, strict, isUTC) {
+          var c = {};
 
-  /**
-   * This recognizer is just used as a base for the simple attribute recognizers.
-   * @constructor
-   * @extends Recognizer
-   */
-  function AttrRecognizer() {
-      Recognizer.apply(this, arguments);
-  }
+          if (typeof(locale) === 'boolean') {
+              strict = locale;
+              locale = 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;
+          c._pf = defaultParsingFlags();
 
-  inherit(AttrRecognizer, Recognizer, {
-      /**
-       * @namespace
-       * @memberof AttrRecognizer
-       */
-      defaults: {
-          /**
-           * @type {Number}
-           * @default 1
-           */
-          pointers: 1
-      },
+          return createFromConfig(c);
+      }
 
-      /**
-       * Used to check if it the recognizer receives valid input, like input.distance > 10.
-       * @memberof AttrRecognizer
-       * @param {Object} input
-       * @returns {Boolean} recognized
-       */
-      attrTest: function(input) {
-          var optionPointers = this.options.pointers;
-          return optionPointers === 0 || input.pointers.length === optionPointers;
-      },
+      function local__createLocal (input, format, locale, strict) {
+          return createLocalOrUTC(input, format, locale, strict, false);
+      }
 
-      /**
-       * Process the input and return the state for the recognizer
-       * @memberof AttrRecognizer
-       * @param {Object} input
-       * @returns {*} State
-       */
-      process: function(input) {
-          var state = this.state;
-          var eventType = input.eventType;
-
-          var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
-          var isValid = this.attrTest(input);
+      var prototypeMin = deprecate(
+           'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
+           function () {
+               var other = local__createLocal.apply(null, arguments);
+               return other < this ? this : other;
+           }
+       );
 
-          // on cancel input and we've recognized before, return STATE_CANCELLED
-          if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
-              return state | STATE_CANCELLED;
-          } else if (isRecognized || isValid) {
-              if (eventType & INPUT_END) {
-                  return state | STATE_ENDED;
-              } else if (!(state & STATE_BEGAN)) {
-                  return STATE_BEGAN;
-              }
-              return state | STATE_CHANGED;
+      var prototypeMax = deprecate(
+          'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
+          function () {
+              var other = local__createLocal.apply(null, arguments);
+              return other > this ? this : other;
           }
-          return STATE_FAILED;
-      }
-  });
-
-  /**
-   * Pan
-   * Recognized when the pointer is down and moved in the allowed direction.
-   * @constructor
-   * @extends AttrRecognizer
-   */
-  function PanRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-
-      this.pX = null;
-      this.pY = null;
-  }
-
-  inherit(PanRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof PanRecognizer
-       */
-      defaults: {
-          event: 'pan',
-          threshold: 10,
-          pointers: 1,
-          direction: DIRECTION_ALL
-      },
+      );
 
-      getTouchAction: function() {
-          var direction = this.options.direction;
-          var actions = [];
-          if (direction & DIRECTION_HORIZONTAL) {
-              actions.push(TOUCH_ACTION_PAN_Y);
+      // 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 (direction & DIRECTION_VERTICAL) {
-              actions.push(TOUCH_ACTION_PAN_X);
+          if (!moments.length) {
+              return local__createLocal();
           }
-          return actions;
-      },
-
-      directionTest: function(input) {
-          var options = this.options;
-          var hasMoved = true;
-          var distance = input.distance;
-          var direction = input.direction;
-          var x = input.deltaX;
-          var y = input.deltaY;
-
-          // lock to axis?
-          if (!(direction & options.direction)) {
-              if (options.direction & DIRECTION_HORIZONTAL) {
-                  direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
-                  hasMoved = x != this.pX;
-                  distance = Math.abs(input.deltaX);
-              } else {
-                  direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;
-                  hasMoved = y != this.pY;
-                  distance = Math.abs(input.deltaY);
+          res = moments[0];
+          for (i = 1; i < moments.length; ++i) {
+              if (moments[i][fn](res)) {
+                  res = moments[i];
               }
           }
-          input.direction = direction;
-          return hasMoved && distance > options.threshold && direction & options.direction;
-      },
+          return res;
+      }
 
-      attrTest: function(input) {
-          return AttrRecognizer.prototype.attrTest.call(this, input) &&
-              (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));
-      },
+      // TODO: Use [].sort instead?
+      function min () {
+          var args = [].slice.call(arguments, 0);
 
-      emit: function(input) {
-          this.pX = input.deltaX;
-          this.pY = input.deltaY;
+          return pickBy('isBefore', args);
+      }
 
-          var direction = directionStr(input.direction);
-          if (direction) {
-              this.manager.emit(this.options.event + direction, input);
-          }
+      function max () {
+          var args = [].slice.call(arguments, 0);
 
-          this._super.emit.call(this, input);
+          return pickBy('isAfter', args);
       }
-  });
 
-  /**
-   * Pinch
-   * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
-   * @constructor
-   * @extends AttrRecognizer
-   */
-  function PinchRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-  }
+      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;
 
-  inherit(PinchRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof PinchRecognizer
-       */
-      defaults: {
-          event: 'pinch',
-          threshold: 0,
-          pointers: 2
-      },
+          // representation for dateAddRemove
+          this._milliseconds = +milliseconds +
+              seconds * 1e3 + // 1000
+              minutes * 6e4 + // 1000 * 60
+              hours * 36e5; // 1000 * 60 * 60
+          // 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;
 
-      getTouchAction: function() {
-          return [TOUCH_ACTION_NONE];
-      },
+          this._data = {};
 
-      attrTest: function(input) {
-          return this._super.attrTest.call(this, input) &&
-              (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
-      },
+          this._locale = locale_locales__getLocale();
 
-      emit: function(input) {
-          this._super.emit.call(this, input);
-          if (input.scale !== 1) {
-              var inOut = input.scale < 1 ? 'in' : 'out';
-              this.manager.emit(this.options.event + inOut, input);
-          }
+          this._bubble();
       }
-  });
 
-  /**
-   * Press
-   * Recognized when the pointer is down for x ms without any movement.
-   * @constructor
-   * @extends Recognizer
-   */
-  function PressRecognizer() {
-      Recognizer.apply(this, arguments);
+      function isDuration (obj) {
+          return obj instanceof Duration;
+      }
 
-      this._timer = null;
-      this._input = null;
-  }
+      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);
+          });
+      }
 
-  inherit(PressRecognizer, Recognizer, {
-      /**
-       * @namespace
-       * @memberof PressRecognizer
-       */
-      defaults: {
-          event: 'press',
-          pointers: 1,
-          time: 500, // minimal time of the pointer to be pressed
-          threshold: 5 // a minimal movement is ok, but keep it low
-      },
+      offset('Z', ':');
+      offset('ZZ', '');
 
-      getTouchAction: function() {
-          return [TOUCH_ACTION_AUTO];
-      },
+      // PARSING
 
-      process: function(input) {
-          var options = this.options;
-          var validPointers = input.pointers.length === options.pointers;
-          var validMovement = input.distance < options.threshold;
-          var validTime = input.deltaTime > options.time;
+      addRegexToken('Z',  matchOffset);
+      addRegexToken('ZZ', matchOffset);
+      addParseToken(['Z', 'ZZ'], function (input, array, config) {
+          config._useUTC = true;
+          config._tzm = offsetFromString(input);
+      });
 
-          this._input = input;
+      // HELPERS
 
-          // we only allow little movement
-          // and we've reached an end event, so a tap is possible
-          if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {
-              this.reset();
-          } else if (input.eventType & INPUT_START) {
-              this.reset();
-              this._timer = setTimeoutContext(function() {
-                  this.state = STATE_RECOGNIZED;
-                  this.tryEmit();
-              }, options.time, this);
-          } else if (input.eventType & INPUT_END) {
-              return STATE_RECOGNIZED;
-          }
-          return STATE_FAILED;
-      },
+      // timezone chunker
+      // '+10:00' > ['10',  '00']
+      // '-1530'  > ['-15', '30']
+      var chunkOffset = /([\+\-]|\d\d)/gi;
 
-      reset: function() {
-          clearTimeout(this._timer);
-      },
+      function offsetFromString(string) {
+          var matches = ((string || '').match(matchOffset) || []);
+          var chunk   = matches[matches.length - 1] || [];
+          var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
+          var minutes = +(parts[1] * 60) + toInt(parts[2]);
 
-      emit: function(input) {
-          if (this.state !== STATE_RECOGNIZED) {
-              return;
-          }
+          return parts[0] === '+' ? minutes : -minutes;
+      }
 
-          if (input && (input.eventType & INPUT_END)) {
-              this.manager.emit(this.options.event + 'up', input);
+      // 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 : +local__createLocal(input)) - (+res);
+              // Use low-level api, because this fn is low-level api.
+              res._d.setTime(+res._d + diff);
+              utils_hooks__hooks.updateOffset(res, false);
+              return res;
           } else {
-              this._input.timeStamp = now();
-              this.manager.emit(this.options.event, this._input);
+              return local__createLocal(input).local();
           }
+          return model._isUTC ? local__createLocal(input).zone(model._offset || 0) : local__createLocal(input).local();
       }
-  });
 
-  /**
-   * Rotate
-   * Recognized when two or more pointer are moving in a circular motion.
-   * @constructor
-   * @extends AttrRecognizer
-   */
-  function RotateRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-  }
+      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;
+      }
 
-  inherit(RotateRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof RotateRecognizer
-       */
-      defaults: {
-          event: 'rotate',
-          threshold: 0,
-          pointers: 2
-      },
+      // HOOKS
 
-      getTouchAction: function() {
-          return [TOUCH_ACTION_NONE];
-      },
+      // This function will be called whenever a moment is mutated.
+      // It is intended to keep the offset in sync with the timezone.
+      utils_hooks__hooks.updateOffset = function () {};
 
-      attrTest: function(input) {
-          return this._super.attrTest.call(this, input) &&
-              (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
+      // 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) {
+          var offset = this._offset || 0,
+              localAdjust;
+          if (input != null) {
+              if (typeof input === 'string') {
+                  input = offsetFromString(input);
+              }
+              if (Math.abs(input) < 16) {
+                  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) {
+                      add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
+                  } else if (!this._changeInProgress) {
+                      this._changeInProgress = true;
+                      utils_hooks__hooks.updateOffset(this, true);
+                      this._changeInProgress = null;
+                  }
+              }
+              return this;
+          } else {
+              return this._isUTC ? offset : getDateOffset(this);
+          }
       }
-  });
 
-  /**
-   * Swipe
-   * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
-   * @constructor
-   * @extends AttrRecognizer
-   */
-  function SwipeRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-  }
+      function getSetZone (input, keepLocalTime) {
+          if (input != null) {
+              if (typeof input !== 'string') {
+                  input = -input;
+              }
 
-  inherit(SwipeRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof SwipeRecognizer
-       */
-      defaults: {
-          event: 'swipe',
-          threshold: 10,
-          velocity: 0.65,
-          direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
-          pointers: 1
-      },
+              this.utcOffset(input, keepLocalTime);
 
-      getTouchAction: function() {
-          return PanRecognizer.prototype.getTouchAction.call(this);
-      },
+              return this;
+          } else {
+              return -this.utcOffset();
+          }
+      }
 
-      attrTest: function(input) {
-          var direction = this.options.direction;
-          var velocity;
+      function setOffsetToUTC (keepLocalTime) {
+          return this.utcOffset(0, keepLocalTime);
+      }
 
-          if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
-              velocity = input.velocity;
-          } else if (direction & DIRECTION_HORIZONTAL) {
-              velocity = input.velocityX;
-          } else if (direction & DIRECTION_VERTICAL) {
-              velocity = input.velocityY;
+      function setOffsetToLocal (keepLocalTime) {
+          if (this._isUTC) {
+              this.utcOffset(0, keepLocalTime);
+              this._isUTC = false;
+
+              if (keepLocalTime) {
+                  this.subtract(getDateOffset(this), 'm');
+              }
           }
+          return this;
+      }
 
-          return this._super.attrTest.call(this, input) &&
-              direction & input.direction &&
-              input.distance > this.options.threshold &&
-              abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
-      },
+      function setOffsetToParsedOffset () {
+          if (this._tzm) {
+              this.utcOffset(this._tzm);
+          } else if (typeof this._i === 'string') {
+              this.utcOffset(offsetFromString(this._i));
+          }
+          return this;
+      }
 
-      emit: function(input) {
-          var direction = directionStr(input.direction);
-          if (direction) {
-              this.manager.emit(this.options.event + direction, input);
+      function hasAlignedHourOffset (input) {
+          if (!input) {
+              input = 0;
+          }
+          else {
+              input = local__createLocal(input).utcOffset();
           }
 
-          this.manager.emit(this.options.event, input);
+          return (this.utcOffset() - input) % 60 === 0;
       }
-  });
-
-  /**
-   * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
-   * between the given interval and position. The delay option can be used to recognize multi-taps without firing
-   * a single tap.
-   *
-   * The eventData from the emitted event contains the property `tapCount`, which contains the amount of
-   * multi-taps being recognized.
-   * @constructor
-   * @extends Recognizer
-   */
-  function TapRecognizer() {
-      Recognizer.apply(this, arguments);
 
-      // previous time and center,
-      // used for tap counting
-      this.pTime = false;
-      this.pCenter = false;
+      function isDaylightSavingTime () {
+          return (
+              this.utcOffset() > this.clone().month(0).utcOffset() ||
+              this.utcOffset() > this.clone().month(5).utcOffset()
+          );
+      }
 
-      this._timer = null;
-      this._input = null;
-      this.count = 0;
-  }
+      function isDaylightSavingTimeShifted () {
+          if (this._a) {
+              var other = this._isUTC ? create_utc__createUTC(this._a) : local__createLocal(this._a);
+              return this.isValid() && compareArrays(this._a, other.toArray()) > 0;
+          }
 
-  inherit(TapRecognizer, Recognizer, {
-      /**
-       * @namespace
-       * @memberof PinchRecognizer
-       */
-      defaults: {
-          event: 'tap',
-          pointers: 1,
-          taps: 1,
-          interval: 300, // max time between the multi-tap taps
-          time: 250, // max time of the pointer to be down (like finger on the screen)
-          threshold: 2, // a minimal movement is ok, but keep it low
-          posThreshold: 10 // a multi-tap can be a bit off the initial position
-      },
+          return false;
+      }
 
-      getTouchAction: function() {
-          return [TOUCH_ACTION_MANIPULATION];
-      },
+      function isLocal () {
+          return !this._isUTC;
+      }
 
-      process: function(input) {
-          var options = this.options;
+      function isUtcOffset () {
+          return this._isUTC;
+      }
 
-          var validPointers = input.pointers.length === options.pointers;
-          var validMovement = input.distance < options.threshold;
-          var validTouchTime = input.deltaTime < options.time;
-
-          this.reset();
-
-          if ((input.eventType & INPUT_START) && (this.count === 0)) {
-              return this.failTimeout();
-          }
+      function isUtc () {
+          return this._isUTC && this._offset === 0;
+      }
 
-          // we only allow little movement
-          // and we've reached an end event, so a tap is possible
-          if (validMovement && validTouchTime && validPointers) {
-              if (input.eventType != INPUT_END) {
-                  return this.failTimeout();
-              }
+      var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
 
-              var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
-              var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
+      // 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
+      var create__isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
 
-              this.pTime = input.timeStamp;
-              this.pCenter = input.center;
+      function create__createDuration (input, key) {
+          var duration = input,
+              // matching against regexp is expensive, do it on demand
+              match = null,
+              sign,
+              ret,
+              diffRes;
 
-              if (!validMultiTap || !validInterval) {
-                  this.count = 1;
+          if (isDuration(input)) {
+              duration = {
+                  ms : input._milliseconds,
+                  d  : input._days,
+                  M  : input._months
+              };
+          } else if (typeof input === 'number') {
+              duration = {};
+              if (key) {
+                  duration[key] = input;
               } else {
-                  this.count += 1;
+                  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(match[MILLISECOND]) * sign
+              };
+          } else if (!!(match = create__isoRegex.exec(input))) {
+              sign = (match[1] === '-') ? -1 : 1;
+              duration = {
+                  y : parseIso(match[2], sign),
+                  M : parseIso(match[3], sign),
+                  d : parseIso(match[4], sign),
+                  h : parseIso(match[5], sign),
+                  m : parseIso(match[6], sign),
+                  s : parseIso(match[7], sign),
+                  w : 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(local__createLocal(duration.from), local__createLocal(duration.to));
 
-              this._input = input;
-
-              // if tap count matches we have recognized it,
-              // else it has began recognizing...
-              var tapCount = this.count % options.taps;
-              if (tapCount === 0) {
-                  // no failing requirements, immediately trigger the tap event
-                  // or wait as long as the multitap interval to trigger
-                  if (!this.hasRequireFailures()) {
-                      return STATE_RECOGNIZED;
-                  } else {
-                      this._timer = setTimeoutContext(function() {
-                          this.state = STATE_RECOGNIZED;
-                          this.tryEmit();
-                      }, options.interval, this);
-                      return STATE_BEGAN;
-                  }
-              }
+              duration = {};
+              duration.ms = diffRes.milliseconds;
+              duration.M = diffRes.months;
           }
-          return STATE_FAILED;
-      },
-
-      failTimeout: function() {
-          this._timer = setTimeoutContext(function() {
-              this.state = STATE_FAILED;
-          }, this.options.interval, this);
-          return STATE_FAILED;
-      },
 
-      reset: function() {
-          clearTimeout(this._timer);
-      },
+          ret = new Duration(duration);
 
-      emit: function() {
-          if (this.state == STATE_RECOGNIZED ) {
-              this._input.tapCount = this.count;
-              this.manager.emit(this.options.event, this._input);
+          if (isDuration(input) && hasOwnProp(input, '_locale')) {
+              ret._locale = input._locale;
           }
-      }
-  });
-
-  /**
-   * Simple way to create an manager with a default set of recognizers.
-   * @param {HTMLElement} element
-   * @param {Object} [options]
-   * @constructor
-   */
-  function Hammer(element, options) {
-      options = options || {};
-      options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
-      return new Manager(element, options);
-  }
-
-  /**
-   * @const {string}
-   */
-  Hammer.VERSION = '2.0.4';
-
-  /**
-   * default settings
-   * @namespace
-   */
-  Hammer.defaults = {
-      /**
-       * set if DOM events are being triggered.
-       * But this is slower and unused by simple implementations, so disabled by default.
-       * @type {Boolean}
-       * @default false
-       */
-      domEvents: false,
-
-      /**
-       * The value for the touchAction property/fallback.
-       * When set to `compute` it will magically set the correct value based on the added recognizers.
-       * @type {String}
-       * @default compute
-       */
-      touchAction: TOUCH_ACTION_COMPUTE,
-
-      /**
-       * @type {Boolean}
-       * @default true
-       */
-      enable: true,
-
-      /**
-       * EXPERIMENTAL FEATURE -- can be removed/changed
-       * Change the parent input target element.
-       * If Null, then it is being set the to main element.
-       * @type {Null|EventTarget}
-       * @default null
-       */
-      inputTarget: null,
 
-      /**
-       * force an input class
-       * @type {Null|Function}
-       * @default null
-       */
-      inputClass: null,
-
-      /**
-       * Default recognizer setup when calling `Hammer()`
-       * When creating a new Manager these will be skipped.
-       * @type {Array}
-       */
-      preset: [
-          // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
-          [RotateRecognizer, { enable: false }],
-          [PinchRecognizer, { enable: false }, ['rotate']],
-          [SwipeRecognizer,{ direction: DIRECTION_HORIZONTAL }],
-          [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ['swipe']],
-          [TapRecognizer],
-          [TapRecognizer, { event: 'doubletap', taps: 2 }, ['tap']],
-          [PressRecognizer]
-      ],
-
-      /**
-       * Some CSS properties can be used to improve the working of Hammer.
-       * Add them to this method and they will be set when creating a new Manager.
-       * @namespace
-       */
-      cssProps: {
-          /**
-           * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
-           * @type {String}
-           * @default 'none'
-           */
-          userSelect: 'none',
-
-          /**
-           * Disable the Windows Phone grippers when pressing an element.
-           * @type {String}
-           * @default 'none'
-           */
-          touchSelect: 'none',
-
-          /**
-           * Disables the default callout shown when you touch and hold a touch target.
-           * On iOS, when you touch and hold a touch target such as a link, Safari displays
-           * a callout containing information about the link. This property allows you to disable that callout.
-           * @type {String}
-           * @default 'none'
-           */
-          touchCallout: 'none',
-
-          /**
-           * Specifies whether zooming is enabled. Used by IE10>
-           * @type {String}
-           * @default 'none'
-           */
-          contentZooming: 'none',
-
-          /**
-           * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
-           * @type {String}
-           * @default 'none'
-           */
-          userDrag: 'none',
-
-          /**
-           * Overrides the highlight color shown when the user taps a link or a JavaScript
-           * clickable element in iOS. This property obeys the alpha value, if specified.
-           * @type {String}
-           * @default 'rgba(0,0,0,0)'
-           */
-          tapHighlightColor: 'rgba(0,0,0,0)'
+          return ret;
       }
-  };
-
-  var STOP = 1;
-  var FORCED_STOP = 2;
-
-  /**
-   * Manager
-   * @param {HTMLElement} element
-   * @param {Object} [options]
-   * @constructor
-   */
-  function Manager(element, options) {
-      options = options || {};
-
-      this.options = merge(options, Hammer.defaults);
-      this.options.inputTarget = this.options.inputTarget || element;
-
-      this.handlers = {};
-      this.session = {};
-      this.recognizers = [];
-
-      this.element = element;
-      this.input = createInputInstance(this);
-      this.touchAction = new TouchAction(this, this.options.touchAction);
 
-      toggleCssProps(this, true);
-
-      each(options.recognizers, function(item) {
-          var recognizer = this.add(new (item[0])(item[1]));
-          item[2] && recognizer.recognizeWith(item[2]);
-          item[3] && recognizer.requireFailure(item[3]);
-      }, this);
-  }
-
-  Manager.prototype = {
-      /**
-       * set options
-       * @param {Object} options
-       * @returns {Manager}
-       */
-      set: function(options) {
-          extend(this.options, options);
+      create__createDuration.fn = Duration.prototype;
 
-          // Options that need a little more setup
-          if (options.touchAction) {
-              this.touchAction.update();
-          }
-          if (options.inputTarget) {
-              // Clean up existing event listeners and reinitialize
-              this.input.destroy();
-              this.input.target = options.inputTarget;
-              this.input.init();
-          }
-          return this;
-      },
+      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;
+      }
 
-      /**
-       * stop recognizing for this session.
-       * This session will be discarded, when a new [input]start event is fired.
-       * When forced, the recognizer cycle is stopped immediately.
-       * @param {Boolean} [force]
-       */
-      stop: function(force) {
-          this.session.stopped = force ? FORCED_STOP : STOP;
-      },
+      function positiveMomentsDifference(base, other) {
+          var res = {milliseconds: 0, months: 0};
 
-      /**
-       * run the recognizers!
-       * called by the inputHandler function on every movement of the pointers (touches)
-       * it walks through all the recognizers and tries to detect the gesture that is being made
-       * @param {Object} inputData
-       */
-      recognize: function(inputData) {
-          var session = this.session;
-          if (session.stopped) {
-              return;
+          res.months = other.month() - base.month() +
+              (other.year() - base.year()) * 12;
+          if (base.clone().add(res.months, 'M').isAfter(other)) {
+              --res.months;
           }
 
-          // run the touch-action polyfill
-          this.touchAction.preventDefaults(inputData);
-
-          var recognizer;
-          var recognizers = this.recognizers;
+          res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
 
-          // this holds the recognizer that is being recognized.
-          // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
-          // if no recognizer is detecting a thing, it is set to `null`
-          var curRecognizer = session.curRecognizer;
+          return res;
+      }
 
-          // reset when the last recognizer is recognized
-          // or when we're in a new session
-          if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
-              curRecognizer = session.curRecognizer = null;
+      function momentsDifference(base, other) {
+          var res;
+          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;
           }
 
-          var i = 0;
-          while (i < recognizers.length) {
-              recognizer = recognizers[i];
+          return res;
+      }
 
-              // find out if we are allowed try to recognize the input for this one.
-              // 1.   allow if the session is NOT forced stopped (see the .stop() method)
-              // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
-              //      that is being recognized.
-              // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
-              //      this can be setup with the `recognizeWith()` method on the recognizer.
-              if (session.stopped !== FORCED_STOP && ( // 1
-                      !curRecognizer || recognizer == curRecognizer || // 2
-                      recognizer.canRecognizeWith(curRecognizer))) { // 3
-                  recognizer.recognize(inputData);
-              } else {
-                  recognizer.reset();
+      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).');
+                  tmp = val; val = period; period = tmp;
               }
 
-              // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
-              // current active recognizer. but only if we don't already have an active recognizer
-              if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
-                  curRecognizer = session.curRecognizer = recognizer;
-              }
-              i++;
-          }
-      },
+              val = typeof val === 'string' ? +val : val;
+              dur = create__createDuration(val, period);
+              add_subtract__addSubtract(this, dur, direction);
+              return this;
+          };
+      }
 
-      /**
-       * get a recognizer by its event name.
-       * @param {Recognizer|String} recognizer
-       * @returns {Recognizer|Null}
-       */
-      get: function(recognizer) {
-          if (recognizer instanceof Recognizer) {
-              return recognizer;
-          }
+      function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
+          var milliseconds = duration._milliseconds,
+              days = duration._days,
+              months = duration._months;
+          updateOffset = updateOffset == null ? true : updateOffset;
 
-          var recognizers = this.recognizers;
-          for (var i = 0; i < recognizers.length; i++) {
-              if (recognizers[i].options.event == recognizer) {
-                  return recognizers[i];
-              }
+          if (milliseconds) {
+              mom._d.setTime(+mom._d + milliseconds * isAdding);
           }
-          return null;
-      },
-
-      /**
-       * add a recognizer to the manager
-       * existing recognizers with the same event name will be removed
-       * @param {Recognizer} recognizer
-       * @returns {Recognizer|Manager}
-       */
-      add: function(recognizer) {
-          if (invokeArrayArg(recognizer, 'add', this)) {
-              return this;
+          if (days) {
+              get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
           }
-
-          // remove existing
-          var existing = this.get(recognizer.options.event);
-          if (existing) {
-              this.remove(existing);
+          if (months) {
+              setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
           }
-
-          this.recognizers.push(recognizer);
-          recognizer.manager = this;
-
-          this.touchAction.update();
-          return recognizer;
-      },
-
-      /**
-       * remove a recognizer by name or instance
-       * @param {Recognizer|String} recognizer
-       * @returns {Manager}
-       */
-      remove: function(recognizer) {
-          if (invokeArrayArg(recognizer, 'remove', this)) {
-              return this;
+          if (updateOffset) {
+              utils_hooks__hooks.updateOffset(mom, days || months);
           }
+      }
 
-          var recognizers = this.recognizers;
-          recognizer = this.get(recognizer);
-          recognizers.splice(inArray(recognizers, recognizer), 1);
-
-          this.touchAction.update();
-          return this;
-      },
+      var add_subtract__add      = createAdder(1, 'add');
+      var add_subtract__subtract = createAdder(-1, 'subtract');
 
-      /**
-       * bind event
-       * @param {String} events
-       * @param {Function} handler
-       * @returns {EventEmitter} this
-       */
-      on: function(events, handler) {
-          var handlers = this.handlers;
-          each(splitStr(events), function(event) {
-              handlers[event] = handlers[event] || [];
-              handlers[event].push(handler);
-          });
-          return this;
-      },
+      function moment_calendar__calendar (time) {
+          // 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 || local__createLocal(),
+              sod = cloneWithOffset(now, this).startOf('day'),
+              diff = this.diff(sod, 'days', true),
+              format = diff < -6 ? 'sameElse' :
+                  diff < -1 ? 'lastWeek' :
+                  diff < 0 ? 'lastDay' :
+                  diff < 1 ? 'sameDay' :
+                  diff < 2 ? 'nextDay' :
+                  diff < 7 ? 'nextWeek' : 'sameElse';
+          return this.format(this.localeData().calendar(format, this, local__createLocal(now)));
+      }
 
-      /**
-       * unbind event, leave emit blank to remove all handlers
-       * @param {String} events
-       * @param {Function} [handler]
-       * @returns {EventEmitter} this
-       */
-      off: function(events, handler) {
-          var handlers = this.handlers;
-          each(splitStr(events), function(event) {
-              if (!handler) {
-                  delete handlers[event];
-              } else {
-                  handlers[event].splice(inArray(handlers[event], handler), 1);
-              }
-          });
-          return this;
-      },
+      function clone () {
+          return new Moment(this);
+      }
 
-      /**
-       * emit event to the listeners
-       * @param {String} event
-       * @param {Object} data
-       */
-      emit: function(event, data) {
-          // we also want to trigger dom events
-          if (this.options.domEvents) {
-              triggerDomEvent(event, data);
+      function isAfter (input, units) {
+          var inputMs;
+          units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
+          if (units === 'millisecond') {
+              input = isMoment(input) ? input : local__createLocal(input);
+              return +this > +input;
+          } else {
+              inputMs = isMoment(input) ? +input : +local__createLocal(input);
+              return inputMs < +this.clone().startOf(units);
           }
+      }
 
-          // no handlers, so skip it all
-          var handlers = this.handlers[event] && this.handlers[event].slice();
-          if (!handlers || !handlers.length) {
-              return;
+      function isBefore (input, units) {
+          var inputMs;
+          units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
+          if (units === 'millisecond') {
+              input = isMoment(input) ? input : local__createLocal(input);
+              return +this < +input;
+          } else {
+              inputMs = isMoment(input) ? +input : +local__createLocal(input);
+              return +this.clone().endOf(units) < inputMs;
           }
+      }
 
-          data.type = event;
-          data.preventDefault = function() {
-              data.srcEvent.preventDefault();
-          };
+      function isBetween (from, to, units) {
+          return this.isAfter(from, units) && this.isBefore(to, units);
+      }
 
-          var i = 0;
-          while (i < handlers.length) {
-              handlers[i](data);
-              i++;
+      function isSame (input, units) {
+          var inputMs;
+          units = normalizeUnits(units || 'millisecond');
+          if (units === 'millisecond') {
+              input = isMoment(input) ? input : local__createLocal(input);
+              return +this === +input;
+          } else {
+              inputMs = +local__createLocal(input);
+              return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units));
           }
-      },
-
-      /**
-       * destroy the manager and unbinds all events
-       * it doesn't unbind dom events, that is the user own responsibility
-       */
-      destroy: function() {
-          this.element && toggleCssProps(this, false);
-
-          this.handlers = {};
-          this.session = {};
-          this.input.destroy();
-          this.element = null;
       }
-  };
-
-  /**
-   * add/remove the css properties as defined in manager.options.cssProps
-   * @param {Manager} manager
-   * @param {Boolean} add
-   */
-  function toggleCssProps(manager, add) {
-      var element = manager.element;
-      each(manager.options.cssProps, function(value, name) {
-          element.style[prefixed(element.style, name)] = add ? value : '';
-      });
-  }
-
-  /**
-   * trigger dom event
-   * @param {String} event
-   * @param {Object} data
-   */
-  function triggerDomEvent(event, data) {
-      var gestureEvent = document.createEvent('Event');
-      gestureEvent.initEvent(event, true, true);
-      gestureEvent.gesture = data;
-      data.target.dispatchEvent(gestureEvent);
-  }
-
-  extend(Hammer, {
-      INPUT_START: INPUT_START,
-      INPUT_MOVE: INPUT_MOVE,
-      INPUT_END: INPUT_END,
-      INPUT_CANCEL: INPUT_CANCEL,
-
-      STATE_POSSIBLE: STATE_POSSIBLE,
-      STATE_BEGAN: STATE_BEGAN,
-      STATE_CHANGED: STATE_CHANGED,
-      STATE_ENDED: STATE_ENDED,
-      STATE_RECOGNIZED: STATE_RECOGNIZED,
-      STATE_CANCELLED: STATE_CANCELLED,
-      STATE_FAILED: STATE_FAILED,
-
-      DIRECTION_NONE: DIRECTION_NONE,
-      DIRECTION_LEFT: DIRECTION_LEFT,
-      DIRECTION_RIGHT: DIRECTION_RIGHT,
-      DIRECTION_UP: DIRECTION_UP,
-      DIRECTION_DOWN: DIRECTION_DOWN,
-      DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
-      DIRECTION_VERTICAL: DIRECTION_VERTICAL,
-      DIRECTION_ALL: DIRECTION_ALL,
-
-      Manager: Manager,
-      Input: Input,
-      TouchAction: TouchAction,
-
-      TouchInput: TouchInput,
-      MouseInput: MouseInput,
-      PointerEventInput: PointerEventInput,
-      TouchMouseInput: TouchMouseInput,
-      SingleTouchInput: SingleTouchInput,
-
-      Recognizer: Recognizer,
-      AttrRecognizer: AttrRecognizer,
-      Tap: TapRecognizer,
-      Pan: PanRecognizer,
-      Swipe: SwipeRecognizer,
-      Pinch: PinchRecognizer,
-      Rotate: RotateRecognizer,
-      Press: PressRecognizer,
-
-      on: addEventListeners,
-      off: removeEventListeners,
-      each: each,
-      merge: merge,
-      extend: extend,
-      inherit: inherit,
-      bindFn: bindFn,
-      prefixed: prefixed
-  });
-
-  if ("function" == TYPE_FUNCTION && __webpack_require__(107)) {
-      !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
-          return Hammer;
-      }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-  } else if (typeof module != 'undefined' && module.exports) {
-      module.exports = Hammer;
-  } else {
-      window[exportName] = Hammer;
-  }
-
-  })(window, document, 'Hammer');
-
-
-/***/ },
-/* 71 */
-/***/ function(module, exports, __webpack_require__) {
 
-  /* WEBPACK VAR INJECTION */(function(module) {//! moment.js
-  //! version : 2.10.2
-  //! 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 utils_hooks__hooks () {
-          return hookCallback.apply(null, arguments);
+      function absFloor (number) {
+          if (number < 0) {
+              return Math.ceil(number);
+          } else {
+              return Math.floor(number);
+          }
       }
 
-      // This is done to register the method called with moment()
-      // without creating circular dependencies.
-      function setHookCallback (callback) {
-          hookCallback = callback;
-      }
+      function diff (input, units, asFloat) {
+          var that = cloneWithOffset(input, this),
+              zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4,
+              delta, output;
 
-      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
-          };
-      }
+          units = normalizeUnits(units);
 
-      function isArray(input) {
-          return Object.prototype.toString.call(input) === '[object Array]';
+          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 isDate(input) {
-          return Object.prototype.toString.call(input) === '[object Date]' || input instanceof Date;
-      }
+      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;
 
-      function map(arr, fn) {
-          var res = [], i;
-          for (i = 0; i < arr.length; ++i) {
-              res.push(fn(arr[i], i));
+          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);
           }
-          return res;
+
+          return -(wholeMonthDiff + adjust);
       }
 
-      function hasOwnProp(a, b) {
-          return Object.prototype.hasOwnProperty.call(a, b);
+      utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
+
+      function toString () {
+          return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
       }
 
-      function extend(a, b) {
-          for (var i in b) {
-              if (hasOwnProp(b, i)) {
-                  a[i] = b[i];
+      function moment_format__toISOString () {
+          var m = this.clone().utc();
+          if (0 < m.year() && m.year() <= 9999) {
+              if ('function' === typeof Date.prototype.toISOString) {
+                  // native implementation is ~50x faster, use it when we can
+                  return this.toDate().toISOString();
+              } else {
+                  return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
               }
+          } else {
+              return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
           }
+      }
 
-          if (hasOwnProp(b, 'toString')) {
-              a.toString = b.toString;
-          }
-
-          if (hasOwnProp(b, 'valueOf')) {
-              a.valueOf = b.valueOf;
-          }
+      function format (inputString) {
+          var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);
+          return this.localeData().postformat(output);
+      }
 
-          return a;
+      function from (time, withoutSuffix) {
+          return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
       }
 
-      function create_utc__createUTC (input, format, locale, strict) {
-          return createLocalOrUTC(input, format, locale, strict, true).utc();
+      function fromNow (withoutSuffix) {
+          return this.from(local__createLocal(), withoutSuffix);
       }
 
-      function valid__isValid(m) {
-          if (m._isValid == null) {
-              m._isValid = !isNaN(m._d.getTime()) &&
-                  m._pf.overflow < 0 &&
-                  !m._pf.empty &&
-                  !m._pf.invalidMonth &&
-                  !m._pf.nullInput &&
-                  !m._pf.invalidFormat &&
-                  !m._pf.userInvalidated;
+      function locale (key) {
+          var newLocaleData;
 
-              if (m._strict) {
-                  m._isValid = m._isValid &&
-                      m._pf.charsLeftOver === 0 &&
-                      m._pf.unusedTokens.length === 0 &&
-                      m._pf.bigHour === undefined;
+          if (key === undefined) {
+              return this._locale._abbr;
+          } else {
+              newLocaleData = locale_locales__getLocale(key);
+              if (newLocaleData != null) {
+                  this._locale = newLocaleData;
               }
+              return this;
           }
-          return m._isValid;
       }
 
-      function valid__createInvalid (flags) {
-          var m = create_utc__createUTC(NaN);
-          if (flags != null) {
-              extend(m._pf, flags);
-          }
-          else {
-              m._pf.userInvalidated = true;
+      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);
+              }
           }
+      );
 
-          return m;
+      function localeData () {
+          return this._locale;
       }
 
-      var momentProperties = utils_hooks__hooks.momentProperties = [];
-
-      function copyConfig(to, from) {
-          var i, prop, val;
-
-          if (typeof from._isAMomentObject !== 'undefined') {
-              to._isAMomentObject = from._isAMomentObject;
-          }
-          if (typeof from._i !== 'undefined') {
-              to._i = from._i;
-          }
-          if (typeof from._f !== 'undefined') {
-              to._f = from._f;
-          }
-          if (typeof from._l !== 'undefined') {
-              to._l = from._l;
-          }
-          if (typeof from._strict !== 'undefined') {
-              to._strict = from._strict;
-          }
-          if (typeof from._tzm !== 'undefined') {
-              to._tzm = from._tzm;
-          }
-          if (typeof from._isUTC !== 'undefined') {
-              to._isUTC = from._isUTC;
-          }
-          if (typeof from._offset !== 'undefined') {
-              to._offset = from._offset;
+      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':
+              this.hours(0);
+              /* falls through */
+          case 'hour':
+              this.minutes(0);
+              /* falls through */
+          case 'minute':
+              this.seconds(0);
+              /* falls through */
+          case 'second':
+              this.milliseconds(0);
           }
-          if (typeof from._pf !== 'undefined') {
-              to._pf = from._pf;
+
+          // weeks are a special case
+          if (units === 'week') {
+              this.weekday(0);
           }
-          if (typeof from._locale !== 'undefined') {
-              to._locale = from._locale;
+          if (units === 'isoWeek') {
+              this.isoWeekday(1);
           }
 
-          if (momentProperties.length > 0) {
-              for (i in momentProperties) {
-                  prop = momentProperties[i];
-                  val = from[prop];
-                  if (typeof val !== 'undefined') {
-                      to[prop] = val;
-                  }
-              }
+          // quarters are also special
+          if (units === 'quarter') {
+              this.month(Math.floor(this.month() / 3) * 3);
           }
 
-          return to;
+          return this;
       }
 
-      var updateInProgress = false;
-
-      // Moment prototype object
-      function Moment(config) {
-          copyConfig(this, config);
-          this._d = new Date(+config._d);
-          // Prevent infinite loop in case updateOffset creates new moment
-          // objects.
-          if (updateInProgress === false) {
-              updateInProgress = true;
-              utils_hooks__hooks.updateOffset(this);
-              updateInProgress = false;
+      function endOf (units) {
+          units = normalizeUnits(units);
+          if (units === undefined || units === 'millisecond') {
+              return this;
           }
+          return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
       }
 
-      function isMoment (obj) {
-          return obj instanceof Moment || (obj != null && hasOwnProp(obj, '_isAMomentObject'));
+      function to_type__valueOf () {
+          return +this._d - ((this._offset || 0) * 60000);
       }
 
-      function toInt(argumentForCoercion) {
-          var coercedNumber = +argumentForCoercion,
-              value = 0;
-
-          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
-              if (coercedNumber >= 0) {
-                  value = Math.floor(coercedNumber);
-              } else {
-                  value = Math.ceil(coercedNumber);
-              }
-          }
+      function unix () {
+          return Math.floor(+this / 1000);
+      }
 
-          return value;
+      function toDate () {
+          return this._offset ? new Date(+this) : this._d;
       }
 
-      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 toArray () {
+          var m = this;
+          return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
       }
 
-      function Locale() {
+      function moment_valid__isValid () {
+          return valid__isValid(this);
       }
 
-      var locales = {};
-      var globalLocale;
+      function parsingFlags () {
+          return extend({}, this._pf);
+      }
 
-      function normalizeLocale(key) {
-          return key ? key.toLowerCase().replace('_', '-') : key;
+      function invalidAt () {
+          return this._pf.overflow;
       }
 
-      // 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;
+      addFormatToken(0, ['gg', 2], 0, function () {
+          return this.weekYear() % 100;
+      });
 
-          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;
-      }
+      addFormatToken(0, ['GG', 2], 0, function () {
+          return this.isoWeekYear() % 100;
+      });
 
-      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;
-                  !(function webpackMissingModule() { var e = new Error("Cannot find module \"./locale\""); e.code = 'MODULE_NOT_FOUND'; throw e; }());
-                  // because defineLocale currently also sets the global locale, we
-                  // want to undo that for lazy loaded locales
-                  locale_locales__getSetGlobalLocale(oldLocale);
-              } catch (e) { }
-          }
-          return locales[name];
+      function addWeekYearFormatToken (token, getter) {
+          addFormatToken(0, [token, token.length], 0, getter);
       }
 
-      // 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 locale_locales__getSetGlobalLocale (key, values) {
-          var data;
-          if (key) {
-              if (typeof values === 'undefined') {
-                  data = locale_locales__getLocale(key);
-              }
-              else {
-                  data = defineLocale(key, values);
-              }
+      addWeekYearFormatToken('gggg',     'weekYear');
+      addWeekYearFormatToken('ggggg',    'weekYear');
+      addWeekYearFormatToken('GGGG',  'isoWeekYear');
+      addWeekYearFormatToken('GGGGG', 'isoWeekYear');
 
-              if (data) {
-                  // moment.duration._locale = moment._locale = data;
-                  globalLocale = data;
-              }
-          }
+      // ALIASES
 
-          return globalLocale._abbr;
-      }
+      addUnitAlias('weekYear', 'gg');
+      addUnitAlias('isoWeekYear', 'GG');
 
-      function defineLocale (name, values) {
-          if (values !== null) {
-              values.abbr = name;
-              if (!locales[name]) {
-                  locales[name] = new Locale();
-              }
-              locales[name].set(values);
+      // PARSING
 
-              // backwards compat for now: also set the locale
-              locale_locales__getSetGlobalLocale(name);
+      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);
 
-              return locales[name];
-          } else {
-              // useful for testing
-              delete locales[name];
-              return null;
-          }
-      }
+      addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
+          week[token.substr(0, 2)] = toInt(input);
+      });
 
-      // returns locale data
-      function locale_locales__getLocale (key) {
-          var locale;
+      addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
+          week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
+      });
 
-          if (key && key._locale && key._locale._abbr) {
-              key = key._locale._abbr;
-          }
+      // HELPERS
 
-          if (!key) {
-              return globalLocale;
-          }
+      function weeksInYear(year, dow, doy) {
+          return weekOfYear(local__createLocal([year, 11, 31 + dow - doy]), dow, doy).week;
+      }
 
-          if (!isArray(key)) {
-              //short-circuit everything else
-              locale = loadLocale(key);
-              if (locale) {
-                  return locale;
-              }
-              key = [key];
-          }
+      // MOMENTS
 
-          return chooseLocale(key);
+      function getSetWeekYear (input) {
+          var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
+          return input == null ? year : this.add((input - year), 'y');
       }
 
-      var aliases = {};
+      function getSetISOWeekYear (input) {
+          var year = weekOfYear(this, 1, 4).year;
+          return input == null ? year : this.add((input - year), 'y');
+      }
 
-      function addUnitAlias (unit, shorthand) {
-          var lowerCase = unit.toLowerCase();
-          aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+      function getISOWeeksInYear () {
+          return weeksInYear(this.year(), 1, 4);
       }
 
-      function normalizeUnits(units) {
-          return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
+      function getWeeksInYear () {
+          var weekInfo = this.localeData()._week;
+          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
       }
 
-      function normalizeObjectUnits(inputObject) {
-          var normalizedInput = {},
-              normalizedProp,
-              prop;
+      addFormatToken('Q', 0, 0, 'quarter');
 
-          for (prop in inputObject) {
-              if (hasOwnProp(inputObject, prop)) {
-                  normalizedProp = normalizeUnits(prop);
-                  if (normalizedProp) {
-                      normalizedInput[normalizedProp] = inputObject[prop];
-                  }
-              }
-          }
+      // ALIASES
 
-          return normalizedInput;
-      }
+      addUnitAlias('quarter', 'Q');
 
-      function makeGetSet (unit, keepTime) {
-          return function (value) {
-              if (value != null) {
-                  get_set__set(this, unit, value);
-                  utils_hooks__hooks.updateOffset(this, keepTime);
-                  return this;
-              } else {
-                  return get_set__get(this, unit);
-              }
-          };
-      }
+      // PARSING
 
-      function get_set__get (mom, unit) {
-          return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
-      }
+      addRegexToken('Q', match1);
+      addParseToken('Q', function (input, array) {
+          array[MONTH] = (toInt(input) - 1) * 3;
+      });
 
-      function get_set__set (mom, unit, value) {
-          return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
+      // MOMENTS
+
+      function getSetQuarter (input) {
+          return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
       }
 
+      addFormatToken('D', ['DD', 2], 'Do', 'date');
+
+      // ALIASES
+
+      addUnitAlias('date', 'D');
+
+      // PARSING
+
+      addRegexToken('D',  match1to2);
+      addRegexToken('DD', match1to2, match2);
+      addRegexToken('Do', function (isStrict, locale) {
+          return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
+      });
+
+      addParseToken(['D', 'DD'], DATE);
+      addParseToken('Do', function (input, array) {
+          array[DATE] = toInt(input.match(match1to2)[0], 10);
+      });
+
       // MOMENTS
 
-      function getSet (units, value) {
-          var unit;
-          if (typeof units === 'object') {
-              for (unit in units) {
-                  this.set(unit, units[unit]);
-              }
+      var getSetDayOfMonth = makeGetSet('Date', true);
+
+      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');
+
+      // PARSING
+
+      addRegexToken('d',    match1to2);
+      addRegexToken('e',    match1to2);
+      addRegexToken('E',    match1to2);
+      addRegexToken('dd',   matchWord);
+      addRegexToken('ddd',  matchWord);
+      addRegexToken('dddd', matchWord);
+
+      addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) {
+          var weekday = config._locale.weekdaysParse(input);
+          // if we didn't get a weekday name, mark the date as invalid
+          if (weekday != null) {
+              week.d = weekday;
           } else {
-              units = normalizeUnits(units);
-              if (typeof this[units] === 'function') {
-                  return this[units](value);
-              }
+              config._pf.invalidWeekday = input;
           }
-          return this;
-      }
+      });
 
-      function zeroFill(number, targetLength, forceSign) {
-          var output = '' + Math.abs(number),
-              sign = number >= 0;
+      addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
+          week[token] = toInt(input);
+      });
 
-          while (output.length < targetLength) {
-              output = '0' + output;
+      // HELPERS
+
+      function parseWeekday(input, locale) {
+          if (typeof input === 'string') {
+              if (!isNaN(input)) {
+                  input = parseInt(input, 10);
+              }
+              else {
+                  input = locale.weekdaysParse(input);
+                  if (typeof input !== 'number') {
+                      return null;
+                  }
+              }
           }
-          return (sign ? (forceSign ? '+' : '') : '-') + output;
+          return input;
       }
 
-      var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|x|X|zz?|ZZ?|.)/g;
+      // LOCALES
 
-      var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
+      var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
+      function localeWeekdays (m) {
+          return this._weekdays[m.day()];
+      }
 
-      var formatFunctions = {};
+      var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
+      function localeWeekdaysShort (m) {
+          return this._weekdaysShort[m.day()];
+      }
 
-      var formatTokenFunctions = {};
+      var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
+      function localeWeekdaysMin (m) {
+          return this._weekdaysMin[m.day()];
+      }
 
-      // 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]);
-              };
+      function localeWeekdaysParse (weekdayName) {
+          var i, mom, regex;
+
+          if (!this._weekdaysParse) {
+              this._weekdaysParse = [];
           }
-          if (ordinal) {
-              formatTokenFunctions[ordinal] = function () {
-                  return this.localeData().ordinal(func.apply(this, arguments), token);
-              };
+
+          for (i = 0; i < 7; i++) {
+              // make the regex if we don't have it already
+              if (!this._weekdaysParse[i]) {
+                  mom = local__createLocal([2000, 1]).day(i);
+                  regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
+                  this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
+              }
+              // test the regex
+              if (this._weekdaysParse[i].test(weekdayName)) {
+                  return i;
+              }
           }
       }
 
-      function removeFormattingTokens(input) {
-          if (input.match(/\[[\s\S]/)) {
-              return input.replace(/^\[|\]$/g, '');
+      // MOMENTS
+
+      function getSetDayOfWeek (input) {
+          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;
           }
-          return input.replace(/\\/g, '');
       }
 
-      function makeFormatFunction(format) {
-          var array = format.match(formattingTokens), i, length;
+      function getSetLocaleDayOfWeek (input) {
+          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+          return input == null ? weekday : this.add(input - weekday, 'd');
+      }
 
-          for (i = 0, length = array.length; i < length; i++) {
-              if (formatTokenFunctions[array[i]]) {
-                  array[i] = formatTokenFunctions[array[i]];
-              } else {
-                  array[i] = removeFormattingTokens(array[i]);
-              }
-          }
+      function getSetISODayOfWeek (input) {
+          // 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.
+          return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
+      }
 
-          return function (mom) {
-              var output = '';
-              for (i = 0; i < length; i++) {
-                  output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
-              }
-              return output;
-          };
+      addFormatToken('H', ['HH', 2], 0, 'hour');
+      addFormatToken('h', ['hh', 2], 0, function () {
+          return this.hours() % 12 || 12;
+      });
+
+      function meridiem (token, lowercase) {
+          addFormatToken(token, 0, 0, function () {
+              return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
+          });
       }
 
-      // format date using native date object
-      function formatMoment(m, format) {
-          if (!m.isValid()) {
-              return m.localeData().invalidDate();
-          }
+      meridiem('a', true);
+      meridiem('A', false);
 
-          format = expandFormat(format, m.localeData());
+      // ALIASES
 
-          if (!formatFunctions[format]) {
-              formatFunctions[format] = makeFormatFunction(format);
-          }
+      addUnitAlias('hour', 'h');
 
-          return formatFunctions[format](m);
+      // PARSING
+
+      function matchMeridiem (isStrict, locale) {
+          return locale._meridiemParse;
       }
 
-      function expandFormat(format, locale) {
-          var i = 5;
+      addRegexToken('a',  matchMeridiem);
+      addRegexToken('A',  matchMeridiem);
+      addRegexToken('H',  match1to2);
+      addRegexToken('h',  match1to2);
+      addRegexToken('HH', match1to2, match2);
+      addRegexToken('hh', match1to2, match2);
+
+      addParseToken(['H', 'HH'], HOUR);
+      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);
+          config._pf.bigHour = true;
+      });
+
+      // LOCALES
 
-          function replaceLongDateFormatTokens(input) {
-              return locale.longDateFormat(input) || input;
-          }
+      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');
+      }
 
-          localFormattingTokens.lastIndex = 0;
-          while (i >= 0 && localFormattingTokens.test(format)) {
-              format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
-              localFormattingTokens.lastIndex = 0;
-              i -= 1;
+      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
+      function localeMeridiem (hours, minutes, isLower) {
+          if (hours > 11) {
+              return isLower ? 'pm' : 'PM';
+          } else {
+              return isLower ? 'am' : 'AM';
           }
-
-          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 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
+      // MOMENTS
 
-      var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
+      // 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);
 
-      var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
+      addFormatToken('m', ['mm', 2], 0, 'minute');
 
-      // any word (or two) characters or numbers including two/three word month in arabic.
-      var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
+      // ALIASES
 
-      var regexes = {};
+      addUnitAlias('minute', 'm');
 
-      function addRegexToken (token, regex, strictRegex) {
-          regexes[token] = typeof regex === 'function' ? regex : function (isStrict) {
-              return (isStrict && strictRegex) ? strictRegex : regex;
-          };
-      }
+      // PARSING
 
-      function getParseRegexForToken (token, config) {
-          if (!hasOwnProp(regexes, token)) {
-              return new RegExp(unescapeFormat(token));
-          }
+      addRegexToken('m',  match1to2);
+      addRegexToken('mm', match1to2, match2);
+      addParseToken(['m', 'mm'], MINUTE);
 
-          return regexes[token](config._strict, config._locale);
-      }
+      // MOMENTS
 
-      // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
-      function unescapeFormat(s) {
-          return s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
-              return p1 || p2 || p3 || p4;
-          }).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-      }
+      var getSetMinute = makeGetSet('Minutes', false);
 
-      var tokens = {};
+      addFormatToken('s', ['ss', 2], 0, 'second');
 
-      function addParseToken (token, callback) {
-          var i, func = callback;
-          if (typeof token === 'string') {
-              token = [token];
-          }
-          if (typeof callback === 'number') {
-              func = function (input, array) {
-                  array[callback] = toInt(input);
-              };
-          }
-          for (i = 0; i < token.length; i++) {
-              tokens[token[i]] = func;
-          }
-      }
+      // ALIASES
 
-      function addWeekParseToken (token, callback) {
-          addParseToken(token, function (input, array, config, token) {
-              config._w = config._w || {};
-              callback(input, config._w, config, token);
-          });
-      }
+      addUnitAlias('second', 's');
 
-      function addTimeToArrayFromToken(token, input, config) {
-          if (input != null && hasOwnProp(tokens, token)) {
-              tokens[token](input, config._a, config, token);
-          }
-      }
+      // PARSING
 
-      var YEAR = 0;
-      var MONTH = 1;
-      var DATE = 2;
-      var HOUR = 3;
-      var MINUTE = 4;
-      var SECOND = 5;
-      var MILLISECOND = 6;
+      addRegexToken('s',  match1to2);
+      addRegexToken('ss', match1to2, match2);
+      addParseToken(['s', 'ss'], SECOND);
 
-      function daysInMonth(year, month) {
-          return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
-      }
+      // MOMENTS
 
-      // FORMATTING
+      var getSetSecond = makeGetSet('Seconds', false);
 
-      addFormatToken('M', ['MM', 2], 'Mo', function () {
-          return this.month() + 1;
+      addFormatToken('S', 0, 0, function () {
+          return ~~(this.millisecond() / 100);
       });
 
-      addFormatToken('MMM', 0, 0, function (format) {
-          return this.localeData().monthsShort(this, format);
+      addFormatToken(0, ['SS', 2], 0, function () {
+          return ~~(this.millisecond() / 10);
       });
 
-      addFormatToken('MMMM', 0, 0, function (format) {
-          return this.localeData().months(this, format);
-      });
+      function millisecond__milliseconds (token) {
+          addFormatToken(0, [token, 3], 0, 'millisecond');
+      }
+
+      millisecond__milliseconds('SSS');
+      millisecond__milliseconds('SSSS');
 
       // ALIASES
 
-      addUnitAlias('month', 'M');
+      addUnitAlias('millisecond', 'ms');
 
       // PARSING
 
-      addRegexToken('M',    match1to2);
-      addRegexToken('MM',   match1to2, match2);
-      addRegexToken('MMM',  matchWord);
-      addRegexToken('MMMM', matchWord);
-
-      addParseToken(['M', 'MM'], function (input, array) {
-          array[MONTH] = toInt(input) - 1;
+      addRegexToken('S',    match1to3, match1);
+      addRegexToken('SS',   match1to3, match2);
+      addRegexToken('SSS',  match1to3, match3);
+      addRegexToken('SSSS', matchUnsigned);
+      addParseToken(['S', 'SS', 'SSS', 'SSSS'], function (input, array) {
+          array[MILLISECOND] = toInt(('0.' + input) * 1000);
       });
 
-      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 {
-              config._pf.invalidMonth = input;
-          }
-      });
+      // MOMENTS
 
-      // LOCALES
+      var getSetMillisecond = makeGetSet('Milliseconds', false);
 
-      var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
-      function localeMonths (m) {
-          return this._months[m.month()];
+      addFormatToken('z',  0, 0, 'zoneAbbr');
+      addFormatToken('zz', 0, 0, 'zoneName');
+
+      // MOMENTS
+
+      function getZoneAbbr () {
+          return this._isUTC ? 'UTC' : '';
       }
 
-      var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
-      function localeMonthsShort (m) {
-          return this._monthsShort[m.month()];
+      function getZoneName () {
+          return this._isUTC ? 'Coordinated Universal Time' : '';
       }
 
-      function localeMonthsParse (monthName, format, strict) {
-          var i, mom, regex;
+      var momentPrototype__proto = Moment.prototype;
 
-          if (!this._monthsParse) {
-              this._monthsParse = [];
-              this._longMonthsParse = [];
-              this._shortMonthsParse = [];
-          }
+      momentPrototype__proto.add          = add_subtract__add;
+      momentPrototype__proto.calendar     = moment_calendar__calendar;
+      momentPrototype__proto.clone        = clone;
+      momentPrototype__proto.diff         = diff;
+      momentPrototype__proto.endOf        = endOf;
+      momentPrototype__proto.format       = format;
+      momentPrototype__proto.from         = from;
+      momentPrototype__proto.fromNow      = fromNow;
+      momentPrototype__proto.get          = getSet;
+      momentPrototype__proto.invalidAt    = invalidAt;
+      momentPrototype__proto.isAfter      = isAfter;
+      momentPrototype__proto.isBefore     = isBefore;
+      momentPrototype__proto.isBetween    = isBetween;
+      momentPrototype__proto.isSame       = isSame;
+      momentPrototype__proto.isValid      = moment_valid__isValid;
+      momentPrototype__proto.lang         = lang;
+      momentPrototype__proto.locale       = locale;
+      momentPrototype__proto.localeData   = localeData;
+      momentPrototype__proto.max          = prototypeMax;
+      momentPrototype__proto.min          = prototypeMin;
+      momentPrototype__proto.parsingFlags = parsingFlags;
+      momentPrototype__proto.set          = getSet;
+      momentPrototype__proto.startOf      = startOf;
+      momentPrototype__proto.subtract     = add_subtract__subtract;
+      momentPrototype__proto.toArray      = toArray;
+      momentPrototype__proto.toDate       = toDate;
+      momentPrototype__proto.toISOString  = moment_format__toISOString;
+      momentPrototype__proto.toJSON       = moment_format__toISOString;
+      momentPrototype__proto.toString     = toString;
+      momentPrototype__proto.unix         = unix;
+      momentPrototype__proto.valueOf      = to_type__valueOf;
 
-          for (i = 0; i < 12; i++) {
-              // make the regex if we don't have it already
-              mom = create_utc__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;
-              }
-          }
-      }
+      // Year
+      momentPrototype__proto.year       = getSetYear;
+      momentPrototype__proto.isLeapYear = getIsLeapYear;
 
-      // MOMENTS
+      // Week Year
+      momentPrototype__proto.weekYear    = getSetWeekYear;
+      momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
 
-      function setMonth (mom, value) {
-          var dayOfMonth;
+      // Quarter
+      momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
 
-          // TODO: Move this out of here!
-          if (typeof value === 'string') {
-              value = mom.localeData().monthsParse(value);
-              // TODO: Another silent failure?
-              if (typeof value !== 'number') {
-                  return mom;
-              }
-          }
+      // Month
+      momentPrototype__proto.month       = getSetMonth;
+      momentPrototype__proto.daysInMonth = getDaysInMonth;
 
-          dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
-          mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
-          return mom;
-      }
+      // Week
+      momentPrototype__proto.week           = momentPrototype__proto.weeks        = getSetWeek;
+      momentPrototype__proto.isoWeek        = momentPrototype__proto.isoWeeks     = getSetISOWeek;
+      momentPrototype__proto.weeksInYear    = getWeeksInYear;
+      momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
 
-      function getSetMonth (value) {
-          if (value != null) {
-              setMonth(this, value);
-              utils_hooks__hooks.updateOffset(this, true);
-              return this;
-          } else {
-              return get_set__get(this, 'Month');
-          }
-      }
+      // Day
+      momentPrototype__proto.date       = getSetDayOfMonth;
+      momentPrototype__proto.day        = momentPrototype__proto.days             = getSetDayOfWeek;
+      momentPrototype__proto.weekday    = getSetLocaleDayOfWeek;
+      momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
+      momentPrototype__proto.dayOfYear  = getSetDayOfYear;
 
-      function getDaysInMonth () {
-          return daysInMonth(this.year(), this.month());
-      }
+      // Hour
+      momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
 
-      function checkOverflow (m) {
-          var overflow;
-          var a = m._a;
+      // Minute
+      momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
 
-          if (a && m._pf.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;
+      // Second
+      momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
 
-              if (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
-                  overflow = DATE;
-              }
+      // Millisecond
+      momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
 
-              m._pf.overflow = overflow;
-          }
+      // Offset
+      momentPrototype__proto.utcOffset            = getSetOffset;
+      momentPrototype__proto.utc                  = setOffsetToUTC;
+      momentPrototype__proto.local                = setOffsetToLocal;
+      momentPrototype__proto.parseZone            = setOffsetToParsedOffset;
+      momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
+      momentPrototype__proto.isDST                = isDaylightSavingTime;
+      momentPrototype__proto.isDSTShifted         = isDaylightSavingTimeShifted;
+      momentPrototype__proto.isLocal              = isLocal;
+      momentPrototype__proto.isUtcOffset          = isUtcOffset;
+      momentPrototype__proto.isUtc                = isUtc;
+      momentPrototype__proto.isUTC                = isUtc;
 
-          return m;
+      // Timezone
+      momentPrototype__proto.zoneAbbr = getZoneAbbr;
+      momentPrototype__proto.zoneName = getZoneName;
+
+      // Deprecations
+      momentPrototype__proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
+      momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
+      momentPrototype__proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
+      momentPrototype__proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
+
+      var momentPrototype = momentPrototype__proto;
+
+      function moment__createUnix (input) {
+          return local__createLocal(input * 1000);
       }
 
-      function warn(msg) {
-          if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
-              console.warn('Deprecation warning: ' + msg);
-          }
+      function moment__createInZone () {
+          return local__createLocal.apply(null, arguments).parseZone();
       }
 
-      function deprecate(msg, fn) {
-          var firstTime = true;
-          return extend(function () {
-              if (firstTime) {
-                  warn(msg);
-                  firstTime = false;
-              }
-              return fn.apply(this, arguments);
-          }, fn);
+      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 locale_calendar__calendar (key, mom, now) {
+          var output = this._calendar[key];
+          return typeof output === 'function' ? output.call(mom, now) : output;
       }
 
-      var deprecations = {};
+      var defaultLongDateFormat = {
+          LTS  : 'h:mm:ss A',
+          LT   : 'h:mm A',
+          L    : 'MM/DD/YYYY',
+          LL   : 'MMMM D, YYYY',
+          LLL  : 'MMMM D, YYYY LT',
+          LLLL : 'dddd, MMMM D, YYYY LT'
+      };
 
-      function deprecateSimple(name, msg) {
-          if (!deprecations[name]) {
-              warn(msg);
-              deprecations[name] = true;
+      function longDateFormat (key) {
+          var output = this._longDateFormat[key];
+          if (!output && this._longDateFormat[key.toUpperCase()]) {
+              output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {
+                  return val.slice(1);
+              });
+              this._longDateFormat[key] = output;
           }
+          return output;
       }
 
-      utils_hooks__hooks.suppressDeprecationWarnings = false;
+      var defaultInvalidDate = 'Invalid date';
 
-      var from_string__isoRegex = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+      function invalidDate () {
+          return this._invalidDate;
+      }
 
-      var isoDates = [
-          ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
-          ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
-          ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
-          ['GGGG-[W]WW', /\d{4}-W\d{2}/],
-          ['YYYY-DDD', /\d{4}-\d{3}/]
-      ];
+      var defaultOrdinal = '%d';
+      var defaultOrdinalParse = /\d{1,2}/;
 
-      // iso time formats and regexes
-      var isoTimes = [
-          ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
-          ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
-          ['HH:mm', /(T| )\d\d:\d\d/],
-          ['HH', /(T| )\d\d/]
-      ];
+      function ordinal (number) {
+          return this._ordinal.replace('%d', number);
+      }
 
-      var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
+      function preParsePostFormat (string) {
+          return string;
+      }
 
-      // date from iso format
-      function configFromISO(config) {
-          var i, l,
-              string = config._i,
-              match = from_string__isoRegex.exec(string);
+      var defaultRelativeTime = {
+          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'
+      };
 
-          if (match) {
-              config._pf.iso = true;
-              for (i = 0, l = isoDates.length; i < l; i++) {
-                  if (isoDates[i][1].exec(string)) {
-                      // match[5] should be 'T' or undefined
-                      config._f = isoDates[i][0] + (match[6] || ' ');
-                      break;
-                  }
-              }
-              for (i = 0, l = isoTimes.length; i < l; i++) {
-                  if (isoTimes[i][1].exec(string)) {
-                      config._f += isoTimes[i][0];
-                      break;
-                  }
-              }
-              if (string.match(matchOffset)) {
-                  config._f += 'Z';
+      function relative__relativeTime (number, withoutSuffix, string, isFuture) {
+          var output = this._relativeTime[string];
+          return (typeof output === 'function') ?
+              output(number, withoutSuffix, string, isFuture) :
+              output.replace(/%d/i, number);
+      }
+
+      function pastFuture (diff, output) {
+          var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+          return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
+      }
+
+      function locale_set__set (config) {
+          var prop, i;
+          for (i in config) {
+              prop = config[i];
+              if (typeof prop === 'function') {
+                  this[i] = prop;
+              } else {
+                  this['_' + i] = prop;
               }
-              configFromStringAndFormat(config);
-          } else {
-              config._isValid = false;
           }
+          // Lenient ordinal parsing accepts just a number in addition to
+          // number + (possibly) stuff coming from _ordinalParseLenient.
+          this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + /\d{1,2}/.source);
       }
 
-      // date from iso format or fallback
-      function configFromString(config) {
-          var matched = aspNetJsonRegex.exec(config._i);
+      var prototype__proto = Locale.prototype;
+
+      prototype__proto._calendar       = defaultCalendar;
+      prototype__proto.calendar        = locale_calendar__calendar;
+      prototype__proto._longDateFormat = defaultLongDateFormat;
+      prototype__proto.longDateFormat  = longDateFormat;
+      prototype__proto._invalidDate    = defaultInvalidDate;
+      prototype__proto.invalidDate     = invalidDate;
+      prototype__proto._ordinal        = defaultOrdinal;
+      prototype__proto.ordinal         = ordinal;
+      prototype__proto._ordinalParse   = defaultOrdinalParse;
+      prototype__proto.preparse        = preParsePostFormat;
+      prototype__proto.postformat      = preParsePostFormat;
+      prototype__proto._relativeTime   = defaultRelativeTime;
+      prototype__proto.relativeTime    = relative__relativeTime;
+      prototype__proto.pastFuture      = pastFuture;
+      prototype__proto.set             = locale_set__set;
+
+      // Month
+      prototype__proto.months       =        localeMonths;
+      prototype__proto._months      = defaultLocaleMonths;
+      prototype__proto.monthsShort  =        localeMonthsShort;
+      prototype__proto._monthsShort = defaultLocaleMonthsShort;
+      prototype__proto.monthsParse  =        localeMonthsParse;
+
+      // Week
+      prototype__proto.week = localeWeek;
+      prototype__proto._week = defaultLocaleWeek;
+      prototype__proto.firstDayOfYear = localeFirstDayOfYear;
+      prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
+
+      // Day of Week
+      prototype__proto.weekdays       =        localeWeekdays;
+      prototype__proto._weekdays      = defaultLocaleWeekdays;
+      prototype__proto.weekdaysMin    =        localeWeekdaysMin;
+      prototype__proto._weekdaysMin   = defaultLocaleWeekdaysMin;
+      prototype__proto.weekdaysShort  =        localeWeekdaysShort;
+      prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
+      prototype__proto.weekdaysParse  =        localeWeekdaysParse;
 
-          if (matched !== null) {
-              config._d = new Date(+matched[1]);
-              return;
-          }
+      // Hours
+      prototype__proto.isPM = localeIsPM;
+      prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
+      prototype__proto.meridiem = localeMeridiem;
 
-          configFromISO(config);
-          if (config._isValid === false) {
-              delete config._isValid;
-              utils_hooks__hooks.createFromInputFallback(config);
-          }
+      function lists__get (format, index, field, setter) {
+          var locale = locale_locales__getLocale();
+          var utc = create_utc__createUTC().set(setter, index);
+          return locale[field](utc, format);
       }
 
-      utils_hooks__hooks.createFromInputFallback = deprecate(
-          'moment construction falls back to js Date. This is ' +
-          'discouraged and will be removed in upcoming major ' +
-          'release. Please refer to ' +
-          'https://github.com/moment/moment/issues/1407 for more info.',
-          function (config) {
-              config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+      function list (format, index, field, count, setter) {
+          if (typeof format === 'number') {
+              index = format;
+              format = undefined;
           }
-      );
 
-      function createDate (y, m, d, h, M, s, ms) {
-          //can't just apply() to create a date:
-          //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
-          var date = new Date(y, m, d, h, M, s, ms);
+          format = format || '';
 
-          //the date constructor doesn't accept years < 1970
-          if (y < 1970) {
-              date.setFullYear(y);
+          if (index != null) {
+              return lists__get(format, index, field, setter);
           }
-          return date;
-      }
 
-      function createUTCDate (y) {
-          var date = new Date(Date.UTC.apply(null, arguments));
-          if (y < 1970) {
-              date.setUTCFullYear(y);
+          var i;
+          var out = [];
+          for (i = 0; i < count; i++) {
+              out[i] = lists__get(format, i, field, setter);
           }
-          return date;
+          return out;
       }
 
-      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');
+      function lists__listMonths (format, index) {
+          return list(format, index, 'months', 12, 'month');
+      }
 
-      // ALIASES
+      function lists__listMonthsShort (format, index) {
+          return list(format, index, 'monthsShort', 12, 'month');
+      }
 
-      addUnitAlias('year', 'y');
+      function lists__listWeekdays (format, index) {
+          return list(format, index, 'weekdays', 7, 'day');
+      }
 
-      // PARSING
+      function lists__listWeekdaysShort (format, index) {
+          return list(format, index, 'weekdaysShort', 7, 'day');
+      }
 
-      addRegexToken('Y',      matchSigned);
-      addRegexToken('YY',     match1to2, match2);
-      addRegexToken('YYYY',   match1to4, match4);
-      addRegexToken('YYYYY',  match1to6, match6);
-      addRegexToken('YYYYYY', match1to6, match6);
+      function lists__listWeekdaysMin (format, index) {
+          return list(format, index, 'weekdaysMin', 7, 'day');
+      }
 
-      addParseToken(['YYYY', 'YYYYY', 'YYYYYY'], YEAR);
-      addParseToken('YY', function (input, array) {
-          array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
+      locale_locales__getSetGlobalLocale('en', {
+          ordinalParse: /\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;
+          }
       });
 
-      // HELPERS
-
-      function daysInYear(year) {
-          return isLeapYear(year) ? 366 : 365;
-      }
-
-      function isLeapYear(year) {
-          return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
-      }
+      // Side effect imports
+      utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
+      utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
 
-      // HOOKS
+      var mathAbs = Math.abs;
 
-      utils_hooks__hooks.parseTwoDigitYear = function (input) {
-          return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
-      };
+      function duration_abs__abs () {
+          var data           = this._data;
 
-      // MOMENTS
+          this._milliseconds = mathAbs(this._milliseconds);
+          this._days         = mathAbs(this._days);
+          this._months       = mathAbs(this._months);
 
-      var getSetYear = makeGetSet('FullYear', false);
+          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);
 
-      function getIsLeapYear () {
-          return isLeapYear(this.year());
+          return this;
       }
 
-      addFormatToken('w', ['ww', 2], 'wo', 'week');
-      addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
-
-      // ALIASES
+      function duration_add_subtract__addSubtract (duration, input, value, direction) {
+          var other = create__createDuration(input, value);
 
-      addUnitAlias('week', 'w');
-      addUnitAlias('isoWeek', 'W');
+          duration._milliseconds += direction * other._milliseconds;
+          duration._days         += direction * other._days;
+          duration._months       += direction * other._months;
 
-      // PARSING
+          return duration._bubble();
+      }
 
-      addRegexToken('w',  match1to2);
-      addRegexToken('ww', match1to2, match2);
-      addRegexToken('W',  match1to2);
-      addRegexToken('WW', match1to2, match2);
+      // supports only 2.0-style add(1, 's') or add(duration)
+      function duration_add_subtract__add (input, value) {
+          return duration_add_subtract__addSubtract(this, input, value, 1);
+      }
 
-      addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
-          week[token.substr(0, 1)] = toInt(input);
-      });
+      // supports only 2.0-style subtract(1, 's') or subtract(duration)
+      function duration_add_subtract__subtract (input, value) {
+          return duration_add_subtract__addSubtract(this, input, value, -1);
+      }
 
-      // HELPERS
+      function bubble () {
+          var milliseconds = this._milliseconds;
+          var days         = this._days;
+          var months       = this._months;
+          var data         = this._data;
+          var seconds, minutes, hours, years = 0;
 
-      // firstDayOfWeek       0 = sun, 6 = sat
-      //                      the day of the week that starts the week
-      //                      (usually sunday or monday)
-      // firstDayOfWeekOfYear 0 = sun, 6 = sat
-      //                      the first week is the week that contains the first
-      //                      of this day of the week
-      //                      (eg. ISO weeks use thursday (4))
-      function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
-          var end = firstDayOfWeekOfYear - firstDayOfWeek,
-              daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
-              adjustedMoment;
+          // 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;
 
-          if (daysToDayOfWeek > end) {
-              daysToDayOfWeek -= 7;
-          }
+          minutes           = absFloor(seconds / 60);
+          data.minutes      = minutes % 60;
 
-          if (daysToDayOfWeek < end - 7) {
-              daysToDayOfWeek += 7;
-          }
+          hours             = absFloor(minutes / 60);
+          data.hours        = hours % 24;
 
-          adjustedMoment = local__createLocal(mom).add(daysToDayOfWeek, 'd');
-          return {
-              week: Math.ceil(adjustedMoment.dayOfYear() / 7),
-              year: adjustedMoment.year()
-          };
-      }
+          days += absFloor(hours / 24);
 
-      // LOCALES
+          // Accurately convert days to years, assume start from year 0.
+          years = absFloor(daysToYears(days));
+          days -= absFloor(yearsToDays(years));
 
-      function localeWeek (mom) {
-          return weekOfYear(mom, this._week.dow, this._week.doy).week;
-      }
+          // 30 days to a month
+          // TODO (iskren): Use anchor date (like 1st Jan) to compute this.
+          months += absFloor(days / 30);
+          days   %= 30;
 
-      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.
-      };
+          // 12 months -> 1 year
+          years  += absFloor(months / 12);
+          months %= 12;
 
-      function localeFirstDayOfWeek () {
-          return this._week.dow;
-      }
+          data.days   = days;
+          data.months = months;
+          data.years  = years;
 
-      function localeFirstDayOfYear () {
-          return this._week.doy;
+          return this;
       }
 
-      // MOMENTS
-
-      function getSetWeek (input) {
-          var week = this.localeData().week(this);
-          return input == null ? week : this.add((input - week) * 7, 'd');
+      function daysToYears (days) {
+          // 400 years have 146097 days (taking into account leap year rules)
+          return days * 400 / 146097;
       }
 
-      function getSetISOWeek (input) {
-          var week = weekOfYear(this, 1, 4).week;
-          return input == null ? week : this.add((input - week) * 7, 'd');
+      function yearsToDays (years) {
+          // years * 365 + absFloor(years / 4) -
+          //     absFloor(years / 100) + absFloor(years / 400);
+          return years * 146097 / 400;
       }
 
-      addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
-
-      // ALIASES
-
-      addUnitAlias('dayOfYear', 'DDD');
-
-      // PARSING
-
-      addRegexToken('DDD',  match1to3);
-      addRegexToken('DDDD', match3);
-      addParseToken(['DDD', 'DDDD'], function (input, array, config) {
-          config._dayOfYear = toInt(input);
-      });
+      function as (units) {
+          var days;
+          var months;
+          var milliseconds = this._milliseconds;
 
-      // HELPERS
+          units = normalizeUnits(units);
 
-      //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
-      function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
-          var d = createUTCDate(year, 0, 1).getUTCDay();
-          var daysToAdd;
-          var dayOfYear;
+          if (units === 'month' || units === 'year') {
+              days   = this._days   + milliseconds / 864e5;
+              months = this._months + daysToYears(days) * 12;
+              return units === 'month' ? months : months / 12;
+          } else {
+              // handle milliseconds separately because of floating point math errors (issue #1867)
+              days = this._days + Math.round(yearsToDays(this._months / 12));
+              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 * 24 * 60      + milliseconds / 6e4;
+                  case 'second' : return days * 24 * 60 * 60 + milliseconds / 1000;
+                  // Math.floor prevents floating point math errors here
+                  case 'millisecond': return Math.floor(days * 24 * 60 * 60 * 1000) + milliseconds;
+                  default: throw new Error('Unknown unit ' + units);
+              }
+          }
+      }
 
-          d = d === 0 ? 7 : d;
-          weekday = weekday != null ? weekday : firstDayOfWeek;
-          daysToAdd = firstDayOfWeek - d + (d > firstDayOfWeekOfYear ? 7 : 0) - (d < firstDayOfWeek ? 7 : 0);
-          dayOfYear = 7 * (week - 1) + (weekday - firstDayOfWeek) + daysToAdd + 1;
+      // TODO: Use this.as('ms')?
+      function duration_as__valueOf () {
+          return (
+              this._milliseconds +
+              this._days * 864e5 +
+              (this._months % 12) * 2592e6 +
+              toInt(this._months / 12) * 31536e6
+          );
+      }
 
-          return {
-              year      : dayOfYear > 0 ? year      : year - 1,
-              dayOfYear : dayOfYear > 0 ? dayOfYear : daysInYear(year - 1) + dayOfYear
+      function makeAs (alias) {
+          return function () {
+              return this.as(alias);
           };
       }
 
-      // 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');
-      }
+      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');
 
-      // 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 duration_get__get (units) {
+          units = normalizeUnits(units);
+          return this[units + 's']();
       }
 
-      function currentDateArray(config) {
-          var now = new Date();
-          if (config._useUTC) {
-              return [now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()];
-          }
-          return [now.getFullYear(), now.getMonth(), now.getDate()];
+      function makeGetter(name) {
+          return function () {
+              return this._data[name];
+          };
       }
 
-      // 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;
+      var duration_get__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');
 
-          if (config._d) {
-              return;
-          }
+      function weeks () {
+          return absFloor(this.days() / 7);
+      }
 
-          currentDate = currentDateArray(config);
+      var round = Math.round;
+      var thresholds = {
+          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
+      };
 
-          //compute day of the year from weeks and weekdays
-          if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
-              dayOfYearFromWeekInfo(config);
-          }
+      // 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);
+      }
 
-          //if the day of the year is set, figure out what it is
-          if (config._dayOfYear) {
-              yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+      function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
+          var duration = create__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'));
 
-              if (config._dayOfYear > daysInYear(yearToUse)) {
-                  config._pf._overflowDayOfYear = true;
-              }
+          var a = seconds < thresholds.s && ['s', 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];
 
-              date = createUTCDate(yearToUse, 0, config._dayOfYear);
-              config._a[MONTH] = date.getUTCMonth();
-              config._a[DATE] = date.getUTCDate();
-          }
+          a[2] = withoutSuffix;
+          a[3] = +posNegDuration > 0;
+          a[4] = locale;
+          return substituteTimeAgo.apply(null, a);
+      }
 
-          // 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];
+      // This function allows you to set a threshold for relative time strings
+      function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
+          if (thresholds[threshold] === undefined) {
+              return false;
           }
-
-          // 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];
+          if (limit === undefined) {
+              return thresholds[threshold];
           }
+          thresholds[threshold] = limit;
+          return true;
+      }
 
-          // 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;
-          }
+      function humanize (withSuffix) {
+          var locale = this.localeData();
+          var output = duration_humanize__relativeTime(this, !withSuffix, locale);
 
-          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 (withSuffix) {
+              output = locale.pastFuture(+this, output);
           }
 
-          if (config._nextDay) {
-              config._a[HOUR] = 24;
-          }
+          return locale.postformat(output);
       }
 
-      function dayOfYearFromWeekInfo(config) {
-          var w, weekYear, week, weekday, dow, doy, temp;
-
-          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(local__createLocal(), 1, 4).year);
-              week = defaults(w.W, 1);
-              weekday = defaults(w.E, 1);
-          } else {
-              dow = config._locale._week.dow;
-              doy = config._locale._week.doy;
+      var iso_string__abs = Math.abs;
 
-              weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
-              week = defaults(w.w, 1);
+      function iso_string__toISOString() {
+          // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+          var Y = iso_string__abs(this.years());
+          var M = iso_string__abs(this.months());
+          var D = iso_string__abs(this.days());
+          var h = iso_string__abs(this.hours());
+          var m = iso_string__abs(this.minutes());
+          var s = iso_string__abs(this.seconds() + this.milliseconds() / 1000);
+          var total = this.asSeconds();
 
-              if (w.d != null) {
-                  // weekday -- low day numbers are considered next week
-                  weekday = w.d;
-                  if (weekday < dow) {
-                      ++week;
-                  }
-              } else if (w.e != null) {
-                  // local weekday -- counting starts from begining of week
-                  weekday = w.e + dow;
-              } else {
-                  // default to begining of week
-                  weekday = dow;
-              }
+          if (!total) {
+              // this is the same as C#'s (Noda) and python (isodate)...
+              // but not other JS (goog.date)
+              return 'P0D';
           }
-          temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
 
-          config._a[YEAR] = temp.year;
-          config._dayOfYear = temp.dayOfYear;
+          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' : '');
       }
 
-      utils_hooks__hooks.ISO_8601 = function () {};
+      var duration_prototype__proto = Duration.prototype;
 
-      // 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 === utils_hooks__hooks.ISO_8601) {
-              configFromISO(config);
-              return;
-          }
+      duration_prototype__proto.abs            = duration_abs__abs;
+      duration_prototype__proto.add            = duration_add_subtract__add;
+      duration_prototype__proto.subtract       = duration_add_subtract__subtract;
+      duration_prototype__proto.as             = as;
+      duration_prototype__proto.asMilliseconds = asMilliseconds;
+      duration_prototype__proto.asSeconds      = asSeconds;
+      duration_prototype__proto.asMinutes      = asMinutes;
+      duration_prototype__proto.asHours        = asHours;
+      duration_prototype__proto.asDays         = asDays;
+      duration_prototype__proto.asWeeks        = asWeeks;
+      duration_prototype__proto.asMonths       = asMonths;
+      duration_prototype__proto.asYears        = asYears;
+      duration_prototype__proto.valueOf        = duration_as__valueOf;
+      duration_prototype__proto._bubble        = bubble;
+      duration_prototype__proto.get            = duration_get__get;
+      duration_prototype__proto.milliseconds   = duration_get__milliseconds;
+      duration_prototype__proto.seconds        = seconds;
+      duration_prototype__proto.minutes        = minutes;
+      duration_prototype__proto.hours          = hours;
+      duration_prototype__proto.days           = days;
+      duration_prototype__proto.weeks          = weeks;
+      duration_prototype__proto.months         = months;
+      duration_prototype__proto.years          = years;
+      duration_prototype__proto.humanize       = humanize;
+      duration_prototype__proto.toISOString    = iso_string__toISOString;
+      duration_prototype__proto.toString       = iso_string__toISOString;
+      duration_prototype__proto.toJSON         = iso_string__toISOString;
+      duration_prototype__proto.locale         = locale;
+      duration_prototype__proto.localeData     = localeData;
 
-          config._a = [];
-          config._pf.empty = true;
+      // Deprecations
+      duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
+      duration_prototype__proto.lang = lang;
 
-          // 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;
+      // Side effect imports
 
-          tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
+      addFormatToken('X', 0, 0, 'unix');
+      addFormatToken('x', 0, 0, 'valueOf');
 
-          for (i = 0; i < tokens.length; i++) {
-              token = tokens[i];
-              parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
-              if (parsedInput) {
-                  skipped = string.substr(0, string.indexOf(parsedInput));
-                  if (skipped.length > 0) {
-                      config._pf.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) {
-                      config._pf.empty = false;
-                  }
-                  else {
-                      config._pf.unusedTokens.push(token);
-                  }
-                  addTimeToArrayFromToken(token, parsedInput, config);
-              }
-              else if (config._strict && !parsedInput) {
-                  config._pf.unusedTokens.push(token);
-              }
-          }
+      // PARSING
 
-          // add remaining unparsed input length to the string
-          config._pf.charsLeftOver = stringLength - totalParsedInputLength;
-          if (string.length > 0) {
-              config._pf.unusedInput.push(string);
-          }
+      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));
+      });
 
-          // clear _12h flag if hour is <= 12
-          if (config._pf.bigHour === true && config._a[HOUR] <= 12) {
-              config._pf.bigHour = undefined;
-          }
-          // handle meridiem
-          config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
+      // Side effect imports
 
-          configFromArray(config);
-          checkOverflow(config);
-      }
 
+      utils_hooks__hooks.version = '2.10.2';
 
-      function meridiemFixWrap (locale, hour, meridiem) {
-          var isPm;
+      setHookCallback(local__createLocal);
 
-          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;
-          }
-      }
+      utils_hooks__hooks.fn                    = momentPrototype;
+      utils_hooks__hooks.min                   = min;
+      utils_hooks__hooks.max                   = max;
+      utils_hooks__hooks.utc                   = create_utc__createUTC;
+      utils_hooks__hooks.unix                  = moment__createUnix;
+      utils_hooks__hooks.months                = lists__listMonths;
+      utils_hooks__hooks.isDate                = isDate;
+      utils_hooks__hooks.locale                = locale_locales__getSetGlobalLocale;
+      utils_hooks__hooks.invalid               = valid__createInvalid;
+      utils_hooks__hooks.duration              = create__createDuration;
+      utils_hooks__hooks.isMoment              = isMoment;
+      utils_hooks__hooks.weekdays              = lists__listWeekdays;
+      utils_hooks__hooks.parseZone             = moment__createInZone;
+      utils_hooks__hooks.localeData            = locale_locales__getLocale;
+      utils_hooks__hooks.isDuration            = isDuration;
+      utils_hooks__hooks.monthsShort           = lists__listMonthsShort;
+      utils_hooks__hooks.weekdaysMin           = lists__listWeekdaysMin;
+      utils_hooks__hooks.defineLocale          = defineLocale;
+      utils_hooks__hooks.weekdaysShort         = lists__listWeekdaysShort;
+      utils_hooks__hooks.normalizeUnits        = normalizeUnits;
+      utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
 
-      function configFromStringAndArray(config) {
-          var tempConfig,
-              bestMoment,
+      var _moment = utils_hooks__hooks;
 
-              scoreToBeat,
-              i,
-              currentScore;
+      return _moment;
 
-          if (config._f.length === 0) {
-              config._pf.invalidFormat = true;
-              config._d = new Date(NaN);
-              return;
-          }
+  }));
+  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(90)(module)))
 
-          for (i = 0; i < config._f.length; i++) {
-              currentScore = 0;
-              tempConfig = copyConfig({}, config);
-              if (config._useUTC != null) {
-                  tempConfig._useUTC = config._useUTC;
-              }
-              tempConfig._pf = defaultParsingFlags();
-              tempConfig._f = config._f[i];
-              configFromStringAndFormat(tempConfig);
+/***/ },
+/* 71 */
+/***/ function(module, exports, __webpack_require__) {
 
-              if (!valid__isValid(tempConfig)) {
-                  continue;
-              }
+  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';
 
-              // if there is any input that was not parsed add a penalty for that format
-              currentScore += tempConfig._pf.charsLeftOver;
+  (function (factory) {
+    if (true) {
+      // AMD. Register as an anonymous module.
+      !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+    } else if (typeof exports === 'object') {
+      // Node. Does not work with strict CommonJS, but
+      // only CommonJS-like environments that support module.exports,
+      // like Node.
+      module.exports = factory();
+    } else {
+      // Browser globals (root is window)
+      window.propagating = factory();
+    }
+  }(function () {
+    var _firstTarget = null; // singleton, will contain the target element where the touch event started
+    var _processing = false; // singleton, true when a touch event is being handled
 
-              //or tokens
-              currentScore += tempConfig._pf.unusedTokens.length * 10;
+    /**
+     * Extend an Hammer.js instance with event propagation.
+     *
+     * Features:
+     * - Events emitted by hammer will propagate in order from child to parent
+     *   elements.
+     * - Events are extended with a function `event.stopPropagation()` to stop
+     *   propagation to parent elements.
+     * - An option `preventDefault` to stop all default browser behavior.
+     *
+     * Usage:
+     *   var hammer = propagatingHammer(new Hammer(element));
+     *   var hammer = propagatingHammer(new Hammer(element), {preventDefault: true});
+     *
+     * @param {Hammer.Manager} hammer   An hammer instance.
+     * @param {Object} [options]        Available options:
+     *                                  - `preventDefault: true | 'mouse' | 'touch' | 'pen'`.
+     *                                    Enforce preventing the default browser behavior.
+     *                                    Cannot be set to `false`.
+     * @return {Hammer.Manager} Returns the same hammer instance with extended
+     *                          functionality
+     */
+    return function propagating(hammer, options) {
+      if (options && options.preventDefault === false) {
+        throw new Error('Only supports preventDefault == true');
+      }
+      var _options = options || {
+        preventDefault: false
+      };
 
-              tempConfig._pf.score = currentScore;
+      if (hammer.Manager) {
+        // This looks like the Hammer constructor.
+        // Overload the constructors with our own.
+        var Hammer = hammer;
 
-              if (scoreToBeat == null || currentScore < scoreToBeat) {
-                  scoreToBeat = currentScore;
-                  bestMoment = tempConfig;
-              }
-          }
+        var PropagatingHammer = function(element, options) {
+          return propagating(new Hammer(element, options), _options);
+        };
+        Hammer.extend(PropagatingHammer, Hammer);
+        PropagatingHammer.Manager = function (element, options) {
+          return propagating(new Hammer.Manager(element, options), _options);
+        };
 
-          extend(config, bestMoment || tempConfig);
+        return PropagatingHammer;
       }
 
-      function configFromObject(config) {
-          if (config._d) {
-              return;
-          }
+      // attach to DOM element
+      var element = hammer.element;
+      element.hammer = hammer;
 
-          var i = normalizeObjectUnits(config._i);
-          config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond];
+      // move the original functions that we will wrap
+      hammer._on = hammer.on;
+      hammer._off = hammer.off;
+      hammer._emit = hammer.emit;
+      hammer._destroy = hammer.destroy;
 
-          configFromArray(config);
-      }
+      /** @type {Object.<String, Array.<function>>} */
+      hammer._handlers = {};
 
-      function createFromConfig (config) {
-          var input = config._i,
-              format = config._f,
-              res;
+      // register an event to catch the start of a gesture and store the
+      // target in a singleton
+      hammer._on('hammer.input', function (event) {
+        if (_options.preventDefault === true || (_options.preventDefault === event.pointerType)) {
+          event.preventDefault();
+        }
+        if (event.isFirst) {
+          _firstTarget = event.target;
+          _processing = true;
+        }
+        if (event.isFinal) {
+          _processing = false;
+        }
+      });
 
-          config._locale = config._locale || locale_locales__getLocale(config._l);
+      /**
+       * Register a handler for one or multiple events
+       * @param {String} events    A space separated string with events
+       * @param {function} handler A callback function, called as handler(event)
+       * @returns {Hammer.Manager} Returns the hammer instance
+       */
+      hammer.on = function (events, handler) {
+        // register the handler
+        split(events).forEach(function (event) {
+          var _handlers = hammer._handlers[event];
+          if (!_handlers) {
+            hammer._handlers[event] = _handlers = [];
 
-          if (input === null || (format === undefined && input === '')) {
-              return valid__createInvalid({nullInput: true});
+            // register the static, propagated handler
+            hammer._on(event, propagatedHandler);
           }
+          _handlers.push(handler);
+        });
 
-          if (typeof input === 'string') {
-              config._i = input = config._locale.preparse(input);
-          }
+        return hammer;
+      };
 
-          if (isMoment(input)) {
-              return new Moment(checkOverflow(input));
-          } else if (isArray(format)) {
-              configFromStringAndArray(config);
-          } else if (format) {
-              configFromStringAndFormat(config);
-          } else {
-              configFromInput(config);
-          }
+      /**
+       * Unregister a handler for one or multiple events
+       * @param {String} events      A space separated string with events
+       * @param {function} [handler] Optional. The registered handler. If not
+       *                             provided, all handlers for given events
+       *                             are removed.
+       * @returns {Hammer.Manager}   Returns the hammer instance
+       */
+      hammer.off = function (events, handler) {
+        // unregister the handler
+        split(events).forEach(function (event) {
+          var _handlers = hammer._handlers[event];
+          if (_handlers) {
+            _handlers = handler ? _handlers.filter(function (h) {
+              return h !== handler;
+            }) : [];
 
-          res = new Moment(checkOverflow(config));
-          if (res._nextDay) {
-              // Adding is smart enough around DST
-              res.add(1, 'd');
-              res._nextDay = undefined;
+            if (_handlers.length > 0) {
+              hammer._handlers[event] = _handlers;
+            }
+            else {
+              // remove static, propagated handler
+              hammer._off(event, propagatedHandler);
+              delete hammer._handlers[event];
+            }
           }
+        });
 
-          return res;
-      }
+        return hammer;
+      };
 
-      function configFromInput(config) {
-          var input = config._i;
-          if (input === undefined) {
-              config._d = new Date();
-          } else if (isDate(input)) {
-              config._d = new Date(+input);
-          } 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 (typeof(input) === 'object') {
-              configFromObject(config);
-          } else if (typeof(input) === 'number') {
-              // from milliseconds
-              config._d = new Date(input);
-          } else {
-              utils_hooks__hooks.createFromInputFallback(config);
-          }
-      }
+      /**
+       * Emit to the event listeners
+       * @param {string} eventType
+       * @param {Event} event
+       */
+      hammer.emit = function(eventType, event) {
+        if (!_processing) {
+          _firstTarget = event.target;
+        }
+        hammer._emit(eventType, event);
+      };
 
-      function createLocalOrUTC (input, format, locale, strict, isUTC) {
-          var c = {};
+      hammer.destroy = function () {
+        // Detach from DOM element
+        var element = hammer.element;
+        delete element.hammer;
 
-          if (typeof(locale) === 'boolean') {
-              strict = locale;
-              locale = 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;
-          c._pf = defaultParsingFlags();
+        // clear all handlers
+        hammer._handlers = {};
 
-          return createFromConfig(c);
-      }
+        // call original hammer destroy
+        hammer._destroy();
+      };
 
-      function local__createLocal (input, format, locale, strict) {
-          return createLocalOrUTC(input, format, locale, strict, false);
+      // split a string with space separated words
+      function split(events) {
+        return events.match(/[^ ]+/g);
       }
 
-      var prototypeMin = deprecate(
-           'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
-           function () {
-               var other = local__createLocal.apply(null, arguments);
-               return other < this ? this : other;
-           }
-       );
-
-      var prototypeMax = deprecate(
-          'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
-          function () {
-              var other = local__createLocal.apply(null, arguments);
-              return other > this ? this : other;
+      /**
+       * A static event handler, applying event propagation.
+       * @param {Object} event
+       */
+      function propagatedHandler(event) {
+        // let only a single hammer instance handle this event
+        if (event.type !== 'hammer.input') {
+          // it is possible that the same srcEvent is used with multiple hammer events,
+          // we keep track on which events are handled in an object _handled
+          if (!event.srcEvent._handled) {
+            event.srcEvent._handled = {};
           }
-      );
 
-      // 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 local__createLocal();
+          if (event.srcEvent._handled[event.type]) {
+            return;
           }
-          res = moments[0];
-          for (i = 1; i < moments.length; ++i) {
-              if (moments[i][fn](res)) {
-                  res = moments[i];
-              }
+          else {
+            event.srcEvent._handled[event.type] = true;
           }
-          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);
-      }
+        // attach a stopPropagation function to the event
+        var stopped = false;
+        event.stopPropagation = function () {
+          stopped = true;
+        };
 
-      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;
+        // attach firstTarget property to the event
+        event.firstTarget = _firstTarget;
 
-          // representation for dateAddRemove
-          this._milliseconds = +milliseconds +
-              seconds * 1e3 + // 1000
-              minutes * 6e4 + // 1000 * 60
-              hours * 36e5; // 1000 * 60 * 60
-          // 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;
+        // propagate over all elements (until stopped)
+        var elem = _firstTarget;
+        while (elem && !stopped) {
+          var _handlers = elem.hammer && elem.hammer._handlers[event.type];
+          if (_handlers) {
+            for (var i = 0; i < _handlers.length && !stopped; i++) {
+              _handlers[i](event);
+            }
+          }
 
-          this._data = {};
+          elem = elem.parentNode;
+        }
+      }
 
-          this._locale = locale_locales__getLocale();
+      return hammer;
+    };
+  }));
 
-          this._bubble();
-      }
 
-      function isDuration (obj) {
-          return obj instanceof Duration;
-      }
+/***/ },
+/* 72 */
+/***/ function(module, exports, __webpack_require__) {
 
-      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);
-          });
-      }
+  var __WEBPACK_AMD_DEFINE_RESULT__;/*! Hammer.JS - v2.0.4 - 2014-09-28
+   * http://hammerjs.github.io/
+   *
+   * Copyright (c) 2014 Jorik Tangelder;
+   * Licensed under the MIT license */
+  (function(window, document, exportName, undefined) {
+    'use strict';
 
-      offset('Z', ':');
-      offset('ZZ', '');
+  var VENDOR_PREFIXES = ['', 'webkit', 'moz', 'MS', 'ms', 'o'];
+  var TEST_ELEMENT = document.createElement('div');
 
-      // PARSING
+  var TYPE_FUNCTION = 'function';
 
-      addRegexToken('Z',  matchOffset);
-      addRegexToken('ZZ', matchOffset);
-      addParseToken(['Z', 'ZZ'], function (input, array, config) {
-          config._useUTC = true;
-          config._tzm = offsetFromString(input);
-      });
+  var round = Math.round;
+  var abs = Math.abs;
+  var now = Date.now;
 
-      // HELPERS
+  /**
+   * set a timeout with a given scope
+   * @param {Function} fn
+   * @param {Number} timeout
+   * @param {Object} context
+   * @returns {number}
+   */
+  function setTimeoutContext(fn, timeout, context) {
+      return setTimeout(bindFn(fn, context), timeout);
+  }
 
-      // timezone chunker
-      // '+10:00' > ['10',  '00']
-      // '-1530'  > ['-15', '30']
-      var chunkOffset = /([\+\-]|\d\d)/gi;
+  /**
+   * if the argument is an array, we want to execute the fn on each entry
+   * if it aint an array we don't want to do a thing.
+   * this is used by all the methods that accept a single and array argument.
+   * @param {*|Array} arg
+   * @param {String} fn
+   * @param {Object} [context]
+   * @returns {Boolean}
+   */
+  function invokeArrayArg(arg, fn, context) {
+      if (Array.isArray(arg)) {
+          each(arg, context[fn], context);
+          return true;
+      }
+      return false;
+  }
 
-      function offsetFromString(string) {
-          var matches = ((string || '').match(matchOffset) || []);
-          var chunk   = matches[matches.length - 1] || [];
-          var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
-          var minutes = +(parts[1] * 60) + toInt(parts[2]);
+  /**
+   * walk objects and arrays
+   * @param {Object} obj
+   * @param {Function} iterator
+   * @param {Object} context
+   */
+  function each(obj, iterator, context) {
+      var i;
 
-          return parts[0] === '+' ? minutes : -minutes;
+      if (!obj) {
+          return;
       }
 
-      // 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 : +local__createLocal(input)) - (+res);
-              // Use low-level api, because this fn is low-level api.
-              res._d.setTime(+res._d + diff);
-              utils_hooks__hooks.updateOffset(res, false);
-              return res;
-          } else {
-              return local__createLocal(input).local();
+      if (obj.forEach) {
+          obj.forEach(iterator, context);
+      } else if (obj.length !== undefined) {
+          i = 0;
+          while (i < obj.length) {
+              iterator.call(context, obj[i], i, obj);
+              i++;
+          }
+      } else {
+          for (i in obj) {
+              obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
           }
-          return model._isUTC ? local__createLocal(input).zone(model._offset || 0) : local__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;
+  /**
+   * extend object.
+   * means that properties in dest will be overwritten by the ones in src.
+   * @param {Object} dest
+   * @param {Object} src
+   * @param {Boolean} [merge]
+   * @returns {Object} dest
+   */
+  function extend(dest, src, merge) {
+      var keys = Object.keys(src);
+      var i = 0;
+      while (i < keys.length) {
+          if (!merge || (merge && dest[keys[i]] === undefined)) {
+              dest[keys[i]] = src[keys[i]];
+          }
+          i++;
       }
+      return dest;
+  }
 
-      // HOOKS
+  /**
+   * merge the values from src in the dest.
+   * means that properties that exist in dest will not be overwritten by src
+   * @param {Object} dest
+   * @param {Object} src
+   * @returns {Object} dest
+   */
+  function merge(dest, src) {
+      return extend(dest, src, true);
+  }
 
-      // This function will be called whenever a moment is mutated.
-      // It is intended to keep the offset in sync with the timezone.
-      utils_hooks__hooks.updateOffset = function () {};
+  /**
+   * simple class inheritance
+   * @param {Function} child
+   * @param {Function} base
+   * @param {Object} [properties]
+   */
+  function inherit(child, base, properties) {
+      var baseP = base.prototype,
+          childP;
 
-      // MOMENTS
+      childP = child.prototype = Object.create(baseP);
+      childP.constructor = child;
+      childP._super = baseP;
 
-      // 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) {
-          var offset = this._offset || 0,
-              localAdjust;
-          if (input != null) {
-              if (typeof input === 'string') {
-                  input = offsetFromString(input);
-              }
-              if (Math.abs(input) < 16) {
-                  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) {
-                      add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
-                  } else if (!this._changeInProgress) {
-                      this._changeInProgress = true;
-                      utils_hooks__hooks.updateOffset(this, true);
-                      this._changeInProgress = null;
-                  }
-              }
-              return this;
-          } else {
-              return this._isUTC ? offset : getDateOffset(this);
-          }
+      if (properties) {
+          extend(childP, properties);
       }
+  }
 
-      function getSetZone (input, keepLocalTime) {
-          if (input != null) {
-              if (typeof input !== 'string') {
-                  input = -input;
-              }
-
-              this.utcOffset(input, keepLocalTime);
+  /**
+   * simple function bind
+   * @param {Function} fn
+   * @param {Object} context
+   * @returns {Function}
+   */
+  function bindFn(fn, context) {
+      return function boundFn() {
+          return fn.apply(context, arguments);
+      };
+  }
 
-              return this;
-          } else {
-              return -this.utcOffset();
-          }
+  /**
+   * let a boolean value also be a function that must return a boolean
+   * this first item in args will be used as the context
+   * @param {Boolean|Function} val
+   * @param {Array} [args]
+   * @returns {Boolean}
+   */
+  function boolOrFn(val, args) {
+      if (typeof val == TYPE_FUNCTION) {
+          return val.apply(args ? args[0] || undefined : undefined, args);
       }
+      return val;
+  }
 
-      function setOffsetToUTC (keepLocalTime) {
-          return this.utcOffset(0, keepLocalTime);
-      }
+  /**
+   * use the val2 when val1 is undefined
+   * @param {*} val1
+   * @param {*} val2
+   * @returns {*}
+   */
+  function ifUndefined(val1, val2) {
+      return (val1 === undefined) ? val2 : val1;
+  }
 
-      function setOffsetToLocal (keepLocalTime) {
-          if (this._isUTC) {
-              this.utcOffset(0, keepLocalTime);
-              this._isUTC = false;
+  /**
+   * addEventListener with multiple events at once
+   * @param {EventTarget} target
+   * @param {String} types
+   * @param {Function} handler
+   */
+  function addEventListeners(target, types, handler) {
+      each(splitStr(types), function(type) {
+          target.addEventListener(type, handler, false);
+      });
+  }
 
-              if (keepLocalTime) {
-                  this.subtract(getDateOffset(this), 'm');
-              }
+  /**
+   * removeEventListener with multiple events at once
+   * @param {EventTarget} target
+   * @param {String} types
+   * @param {Function} handler
+   */
+  function removeEventListeners(target, types, handler) {
+      each(splitStr(types), function(type) {
+          target.removeEventListener(type, handler, false);
+      });
+  }
+
+  /**
+   * find if a node is in the given parent
+   * @method hasParent
+   * @param {HTMLElement} node
+   * @param {HTMLElement} parent
+   * @return {Boolean} found
+   */
+  function hasParent(node, parent) {
+      while (node) {
+          if (node == parent) {
+              return true;
           }
-          return this;
+          node = node.parentNode;
       }
+      return false;
+  }
 
-      function setOffsetToParsedOffset () {
-          if (this._tzm) {
-              this.utcOffset(this._tzm);
-          } else if (typeof this._i === 'string') {
-              this.utcOffset(offsetFromString(this._i));
+  /**
+   * small indexOf wrapper
+   * @param {String} str
+   * @param {String} find
+   * @returns {Boolean} found
+   */
+  function inStr(str, find) {
+      return str.indexOf(find) > -1;
+  }
+
+  /**
+   * split string on whitespace
+   * @param {String} str
+   * @returns {Array} words
+   */
+  function splitStr(str) {
+      return str.trim().split(/\s+/g);
+  }
+
+  /**
+   * find if a array contains the object using indexOf or a simple polyFill
+   * @param {Array} src
+   * @param {String} find
+   * @param {String} [findByKey]
+   * @return {Boolean|Number} false when not found, or the index
+   */
+  function inArray(src, find, findByKey) {
+      if (src.indexOf && !findByKey) {
+          return src.indexOf(find);
+      } else {
+          var i = 0;
+          while (i < src.length) {
+              if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {
+                  return i;
+              }
+              i++;
           }
-          return this;
+          return -1;
       }
+  }
 
-      function hasAlignedHourOffset (input) {
-          if (!input) {
-              input = 0;
-          }
-          else {
-              input = local__createLocal(input).utcOffset();
-          }
+  /**
+   * convert array-like objects to real arrays
+   * @param {Object} obj
+   * @returns {Array}
+   */
+  function toArray(obj) {
+      return Array.prototype.slice.call(obj, 0);
+  }
 
-          return (this.utcOffset() - input) % 60 === 0;
-      }
+  /**
+   * unique array with objects based on a key (like 'id') or just by the array's value
+   * @param {Array} src [{id:1},{id:2},{id:1}]
+   * @param {String} [key]
+   * @param {Boolean} [sort=False]
+   * @returns {Array} [{id:1},{id:2}]
+   */
+  function uniqueArray(src, key, sort) {
+      var results = [];
+      var values = [];
+      var i = 0;
 
-      function isDaylightSavingTime () {
-          return (
-              this.utcOffset() > this.clone().month(0).utcOffset() ||
-              this.utcOffset() > this.clone().month(5).utcOffset()
-          );
+      while (i < src.length) {
+          var val = key ? src[i][key] : src[i];
+          if (inArray(values, val) < 0) {
+              results.push(src[i]);
+          }
+          values[i] = val;
+          i++;
       }
 
-      function isDaylightSavingTimeShifted () {
-          if (this._a) {
-              var other = this._isUTC ? create_utc__createUTC(this._a) : local__createLocal(this._a);
-              return this.isValid() && compareArrays(this._a, other.toArray()) > 0;
+      if (sort) {
+          if (!key) {
+              results = results.sort();
+          } else {
+              results = results.sort(function sortUniqueArray(a, b) {
+                  return a[key] > b[key];
+              });
           }
-
-          return false;
       }
 
-      function isLocal () {
-          return !this._isUTC;
-      }
+      return results;
+  }
 
-      function isUtcOffset () {
-          return this._isUTC;
-      }
+  /**
+   * get the prefixed property
+   * @param {Object} obj
+   * @param {String} property
+   * @returns {String|Undefined} prefixed
+   */
+  function prefixed(obj, property) {
+      var prefix, prop;
+      var camelProp = property[0].toUpperCase() + property.slice(1);
 
-      function isUtc () {
-          return this._isUTC && this._offset === 0;
+      var i = 0;
+      while (i < VENDOR_PREFIXES.length) {
+          prefix = VENDOR_PREFIXES[i];
+          prop = (prefix) ? prefix + camelProp : property;
+
+          if (prop in obj) {
+              return prop;
+          }
+          i++;
       }
+      return undefined;
+  }
 
-      var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
+  /**
+   * get a unique id
+   * @returns {number} uniqueId
+   */
+  var _uniqueId = 1;
+  function uniqueId() {
+      return _uniqueId++;
+  }
 
-      // 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
-      var create__isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
+  /**
+   * get the window object of an element
+   * @param {HTMLElement} element
+   * @returns {DocumentView|Window}
+   */
+  function getWindowForElement(element) {
+      var doc = element.ownerDocument;
+      return (doc.defaultView || doc.parentWindow);
+  }
 
-      function create__createDuration (input, key) {
-          var duration = input,
-              // matching against regexp is expensive, do it on demand
-              match = null,
-              sign,
-              ret,
-              diffRes;
+  var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
 
-          if (isDuration(input)) {
-              duration = {
-                  ms : input._milliseconds,
-                  d  : input._days,
-                  M  : input._months
-              };
-          } else if (typeof input === 'number') {
-              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(match[MILLISECOND]) * sign
-              };
-          } else if (!!(match = create__isoRegex.exec(input))) {
-              sign = (match[1] === '-') ? -1 : 1;
-              duration = {
-                  y : parseIso(match[2], sign),
-                  M : parseIso(match[3], sign),
-                  d : parseIso(match[4], sign),
-                  h : parseIso(match[5], sign),
-                  m : parseIso(match[6], sign),
-                  s : parseIso(match[7], sign),
-                  w : 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(local__createLocal(duration.from), local__createLocal(duration.to));
+  var SUPPORT_TOUCH = ('ontouchstart' in window);
+  var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;
+  var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
 
-              duration = {};
-              duration.ms = diffRes.milliseconds;
-              duration.M = diffRes.months;
-          }
+  var INPUT_TYPE_TOUCH = 'touch';
+  var INPUT_TYPE_PEN = 'pen';
+  var INPUT_TYPE_MOUSE = 'mouse';
+  var INPUT_TYPE_KINECT = 'kinect';
 
-          ret = new Duration(duration);
+  var COMPUTE_INTERVAL = 25;
 
-          if (isDuration(input) && hasOwnProp(input, '_locale')) {
-              ret._locale = input._locale;
-          }
+  var INPUT_START = 1;
+  var INPUT_MOVE = 2;
+  var INPUT_END = 4;
+  var INPUT_CANCEL = 8;
 
-          return ret;
-      }
+  var DIRECTION_NONE = 1;
+  var DIRECTION_LEFT = 2;
+  var DIRECTION_RIGHT = 4;
+  var DIRECTION_UP = 8;
+  var DIRECTION_DOWN = 16;
 
-      create__createDuration.fn = Duration.prototype;
+  var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
+  var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
+  var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
 
-      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;
-      }
+  var PROPS_XY = ['x', 'y'];
+  var PROPS_CLIENT_XY = ['clientX', 'clientY'];
 
-      function positiveMomentsDifference(base, other) {
-          var res = {milliseconds: 0, months: 0};
+  /**
+   * create new input type manager
+   * @param {Manager} manager
+   * @param {Function} callback
+   * @returns {Input}
+   * @constructor
+   */
+  function Input(manager, callback) {
+      var self = this;
+      this.manager = manager;
+      this.callback = callback;
+      this.element = manager.element;
+      this.target = manager.options.inputTarget;
 
-          res.months = other.month() - base.month() +
-              (other.year() - base.year()) * 12;
-          if (base.clone().add(res.months, 'M').isAfter(other)) {
-              --res.months;
+      // smaller wrapper around the handler, for the scope and the enabled state of the manager,
+      // so when disabled the input events are completely bypassed.
+      this.domHandler = function(ev) {
+          if (boolOrFn(manager.options.enable, [manager])) {
+              self.handler(ev);
           }
+      };
 
-          res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
+      this.init();
 
-          return res;
-      }
+  }
 
-      function momentsDifference(base, other) {
-          var res;
-          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;
-          }
+  Input.prototype = {
+      /**
+       * should handle the inputEvent data and trigger the callback
+       * @virtual
+       */
+      handler: function() { },
 
-          return res;
+      /**
+       * bind the events
+       */
+      init: function() {
+          this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
+          this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
+          this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+      },
+
+      /**
+       * unbind the events
+       */
+      destroy: function() {
+          this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
+          this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
+          this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
       }
+  };
 
-      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).');
-                  tmp = val; val = period; period = tmp;
-              }
+  /**
+   * create new input type manager
+   * called by the Manager constructor
+   * @param {Hammer} manager
+   * @returns {Input}
+   */
+  function createInputInstance(manager) {
+      var Type;
+      var inputClass = manager.options.inputClass;
 
-              val = typeof val === 'string' ? +val : val;
-              dur = create__createDuration(val, period);
-              add_subtract__addSubtract(this, dur, direction);
-              return this;
-          };
+      if (inputClass) {
+          Type = inputClass;
+      } else if (SUPPORT_POINTER_EVENTS) {
+          Type = PointerEventInput;
+      } else if (SUPPORT_ONLY_TOUCH) {
+          Type = TouchInput;
+      } else if (!SUPPORT_TOUCH) {
+          Type = MouseInput;
+      } else {
+          Type = TouchMouseInput;
       }
+      return new (Type)(manager, inputHandler);
+  }
 
-      function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
-          var milliseconds = duration._milliseconds,
-              days = duration._days,
-              months = duration._months;
-          updateOffset = updateOffset == null ? true : updateOffset;
+  /**
+   * handle input events
+   * @param {Manager} manager
+   * @param {String} eventType
+   * @param {Object} input
+   */
+  function inputHandler(manager, eventType, input) {
+      var pointersLen = input.pointers.length;
+      var changedPointersLen = input.changedPointers.length;
+      var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));
+      var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));
 
-          if (milliseconds) {
-              mom._d.setTime(+mom._d + milliseconds * isAdding);
-          }
-          if (days) {
-              get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
-          }
-          if (months) {
-              setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
-          }
-          if (updateOffset) {
-              utils_hooks__hooks.updateOffset(mom, days || months);
-          }
+      input.isFirst = !!isFirst;
+      input.isFinal = !!isFinal;
+
+      if (isFirst) {
+          manager.session = {};
       }
 
-      var add_subtract__add      = createAdder(1, 'add');
-      var add_subtract__subtract = createAdder(-1, 'subtract');
+      // source event is the normalized value of the domEvents
+      // like 'touchstart, mouseup, pointerdown'
+      input.eventType = eventType;
 
-      function moment_calendar__calendar (time) {
-          // 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 || local__createLocal(),
-              sod = cloneWithOffset(now, this).startOf('day'),
-              diff = this.diff(sod, 'days', true),
-              format = diff < -6 ? 'sameElse' :
-                  diff < -1 ? 'lastWeek' :
-                  diff < 0 ? 'lastDay' :
-                  diff < 1 ? 'sameDay' :
-                  diff < 2 ? 'nextDay' :
-                  diff < 7 ? 'nextWeek' : 'sameElse';
-          return this.format(this.localeData().calendar(format, this, local__createLocal(now)));
-      }
+      // compute scale, rotation etc
+      computeInputData(manager, input);
 
-      function clone () {
-          return new Moment(this);
-      }
+      // emit secret event
+      manager.emit('hammer.input', input);
 
-      function isAfter (input, units) {
-          var inputMs;
-          units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
-          if (units === 'millisecond') {
-              input = isMoment(input) ? input : local__createLocal(input);
-              return +this > +input;
-          } else {
-              inputMs = isMoment(input) ? +input : +local__createLocal(input);
-              return inputMs < +this.clone().startOf(units);
-          }
-      }
+      manager.recognize(input);
+      manager.session.prevInput = input;
+  }
 
-      function isBefore (input, units) {
-          var inputMs;
-          units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
-          if (units === 'millisecond') {
-              input = isMoment(input) ? input : local__createLocal(input);
-              return +this < +input;
-          } else {
-              inputMs = isMoment(input) ? +input : +local__createLocal(input);
-              return +this.clone().endOf(units) < inputMs;
-          }
-      }
+  /**
+   * extend the data with some usable properties like scale, rotate, velocity etc
+   * @param {Object} manager
+   * @param {Object} input
+   */
+  function computeInputData(manager, input) {
+      var session = manager.session;
+      var pointers = input.pointers;
+      var pointersLength = pointers.length;
 
-      function isBetween (from, to, units) {
-          return this.isAfter(from, units) && this.isBefore(to, units);
+      // store the first input to calculate the distance and direction
+      if (!session.firstInput) {
+          session.firstInput = simpleCloneInputData(input);
       }
 
-      function isSame (input, units) {
-          var inputMs;
-          units = normalizeUnits(units || 'millisecond');
-          if (units === 'millisecond') {
-              input = isMoment(input) ? input : local__createLocal(input);
-              return +this === +input;
-          } else {
-              inputMs = +local__createLocal(input);
-              return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units));
-          }
+      // to compute scale and rotation we need to store the multiple touches
+      if (pointersLength > 1 && !session.firstMultiple) {
+          session.firstMultiple = simpleCloneInputData(input);
+      } else if (pointersLength === 1) {
+          session.firstMultiple = false;
       }
 
-      function absFloor (number) {
-          if (number < 0) {
-              return Math.ceil(number);
-          } else {
-              return Math.floor(number);
-          }
-      }
+      var firstInput = session.firstInput;
+      var firstMultiple = session.firstMultiple;
+      var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
 
-      function diff (input, units, asFloat) {
-          var that = cloneWithOffset(input, this),
-              zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4,
-              delta, output;
+      var center = input.center = getCenter(pointers);
+      input.timeStamp = now();
+      input.deltaTime = input.timeStamp - firstInput.timeStamp;
 
-          units = normalizeUnits(units);
+      input.angle = getAngle(offsetCenter, center);
+      input.distance = getDistance(offsetCenter, center);
 
-          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);
-      }
+      computeDeltaXY(session, input);
+      input.offsetDirection = getDirection(input.deltaX, input.deltaY);
 
-      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;
+      input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
+      input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
 
-          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);
-          }
+      computeIntervalInputData(session, input);
 
-          return -(wholeMonthDiff + adjust);
+      // find the correct target
+      var target = manager.element;
+      if (hasParent(input.srcEvent.target, target)) {
+          target = input.srcEvent.target;
       }
+      input.target = target;
+  }
 
-      utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
+  function computeDeltaXY(session, input) {
+      var center = input.center;
+      var offset = session.offsetDelta || {};
+      var prevDelta = session.prevDelta || {};
+      var prevInput = session.prevInput || {};
 
-      function toString () {
-          return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
-      }
+      if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
+          prevDelta = session.prevDelta = {
+              x: prevInput.deltaX || 0,
+              y: prevInput.deltaY || 0
+          };
 
-      function moment_format__toISOString () {
-          var m = this.clone().utc();
-          if (0 < m.year() && m.year() <= 9999) {
-              if ('function' === typeof Date.prototype.toISOString) {
-                  // native implementation is ~50x faster, use it when we can
-                  return this.toDate().toISOString();
-              } else {
-                  return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
-              }
-          } else {
-              return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
-          }
+          offset = session.offsetDelta = {
+              x: center.x,
+              y: center.y
+          };
       }
 
-      function format (inputString) {
-          var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);
-          return this.localeData().postformat(output);
-      }
+      input.deltaX = prevDelta.x + (center.x - offset.x);
+      input.deltaY = prevDelta.y + (center.y - offset.y);
+  }
 
-      function from (time, withoutSuffix) {
-          return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
-      }
+  /**
+   * velocity is calculated every x ms
+   * @param {Object} session
+   * @param {Object} input
+   */
+  function computeIntervalInputData(session, input) {
+      var last = session.lastInterval || input,
+          deltaTime = input.timeStamp - last.timeStamp,
+          velocity, velocityX, velocityY, direction;
 
-      function fromNow (withoutSuffix) {
-          return this.from(local__createLocal(), withoutSuffix);
-      }
+      if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
+          var deltaX = last.deltaX - input.deltaX;
+          var deltaY = last.deltaY - input.deltaY;
 
-      function locale (key) {
-          var newLocaleData;
+          var v = getVelocity(deltaTime, deltaX, deltaY);
+          velocityX = v.x;
+          velocityY = v.y;
+          velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;
+          direction = getDirection(deltaX, deltaY);
 
-          if (key === undefined) {
-              return this._locale._abbr;
-          } else {
-              newLocaleData = locale_locales__getLocale(key);
-              if (newLocaleData != null) {
-                  this._locale = newLocaleData;
-              }
-              return this;
-          }
+          session.lastInterval = input;
+      } else {
+          // use latest velocity info if it doesn't overtake a minimum period
+          velocity = last.velocity;
+          velocityX = last.velocityX;
+          velocityY = last.velocityY;
+          direction = last.direction;
       }
 
-      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);
-              }
-          }
-      );
+      input.velocity = velocity;
+      input.velocityX = velocityX;
+      input.velocityY = velocityY;
+      input.direction = direction;
+  }
 
-      function localeData () {
-          return this._locale;
+  /**
+   * create a simple clone from the input used for storage of firstInput and firstMultiple
+   * @param {Object} input
+   * @returns {Object} clonedInputData
+   */
+  function simpleCloneInputData(input) {
+      // make a simple copy of the pointers because we will get a reference if we don't
+      // we only need clientXY for the calculations
+      var pointers = [];
+      var i = 0;
+      while (i < input.pointers.length) {
+          pointers[i] = {
+              clientX: round(input.pointers[i].clientX),
+              clientY: round(input.pointers[i].clientY)
+          };
+          i++;
       }
 
-      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':
-              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);
-          }
+      return {
+          timeStamp: now(),
+          pointers: pointers,
+          center: getCenter(pointers),
+          deltaX: input.deltaX,
+          deltaY: input.deltaY
+      };
+  }
 
-          // quarters are also special
-          if (units === 'quarter') {
-              this.month(Math.floor(this.month() / 3) * 3);
-          }
+  /**
+   * get the center of all the pointers
+   * @param {Array} pointers
+   * @return {Object} center contains `x` and `y` properties
+   */
+  function getCenter(pointers) {
+      var pointersLength = pointers.length;
 
-          return this;
+      // no need to loop when only one touch
+      if (pointersLength === 1) {
+          return {
+              x: round(pointers[0].clientX),
+              y: round(pointers[0].clientY)
+          };
       }
 
-      function endOf (units) {
-          units = normalizeUnits(units);
-          if (units === undefined || units === 'millisecond') {
-              return this;
-          }
-          return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
+      var x = 0, y = 0, i = 0;
+      while (i < pointersLength) {
+          x += pointers[i].clientX;
+          y += pointers[i].clientY;
+          i++;
       }
 
-      function to_type__valueOf () {
-          return +this._d - ((this._offset || 0) * 60000);
-      }
+      return {
+          x: round(x / pointersLength),
+          y: round(y / pointersLength)
+      };
+  }
+
+  /**
+   * calculate the velocity between two points. unit is in px per ms.
+   * @param {Number} deltaTime
+   * @param {Number} x
+   * @param {Number} y
+   * @return {Object} velocity `x` and `y`
+   */
+  function getVelocity(deltaTime, x, y) {
+      return {
+          x: x / deltaTime || 0,
+          y: y / deltaTime || 0
+      };
+  }
 
-      function unix () {
-          return Math.floor(+this / 1000);
+  /**
+   * get the direction between two points
+   * @param {Number} x
+   * @param {Number} y
+   * @return {Number} direction
+   */
+  function getDirection(x, y) {
+      if (x === y) {
+          return DIRECTION_NONE;
       }
 
-      function toDate () {
-          return this._offset ? new Date(+this) : this._d;
+      if (abs(x) >= abs(y)) {
+          return x > 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
       }
+      return y > 0 ? DIRECTION_UP : DIRECTION_DOWN;
+  }
 
-      function toArray () {
-          var m = this;
-          return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
+  /**
+   * calculate the absolute distance between two points
+   * @param {Object} p1 {x, y}
+   * @param {Object} p2 {x, y}
+   * @param {Array} [props] containing x and y keys
+   * @return {Number} distance
+   */
+  function getDistance(p1, p2, props) {
+      if (!props) {
+          props = PROPS_XY;
       }
+      var x = p2[props[0]] - p1[props[0]],
+          y = p2[props[1]] - p1[props[1]];
 
-      function moment_valid__isValid () {
-          return valid__isValid(this);
-      }
+      return Math.sqrt((x * x) + (y * y));
+  }
 
-      function parsingFlags () {
-          return extend({}, this._pf);
+  /**
+   * calculate the angle between two coordinates
+   * @param {Object} p1
+   * @param {Object} p2
+   * @param {Array} [props] containing x and y keys
+   * @return {Number} angle
+   */
+  function getAngle(p1, p2, props) {
+      if (!props) {
+          props = PROPS_XY;
       }
+      var x = p2[props[0]] - p1[props[0]],
+          y = p2[props[1]] - p1[props[1]];
+      return Math.atan2(y, x) * 180 / Math.PI;
+  }
 
-      function invalidAt () {
-          return this._pf.overflow;
-      }
+  /**
+   * calculate the rotation degrees between two pointersets
+   * @param {Array} start array of pointers
+   * @param {Array} end array of pointers
+   * @return {Number} rotation
+   */
+  function getRotation(start, end) {
+      return getAngle(end[1], end[0], PROPS_CLIENT_XY) - getAngle(start[1], start[0], PROPS_CLIENT_XY);
+  }
 
-      addFormatToken(0, ['gg', 2], 0, function () {
-          return this.weekYear() % 100;
-      });
+  /**
+   * calculate the scale factor between two pointersets
+   * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
+   * @param {Array} start array of pointers
+   * @param {Array} end array of pointers
+   * @return {Number} scale
+   */
+  function getScale(start, end) {
+      return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
+  }
 
-      addFormatToken(0, ['GG', 2], 0, function () {
-          return this.isoWeekYear() % 100;
-      });
+  var MOUSE_INPUT_MAP = {
+      mousedown: INPUT_START,
+      mousemove: INPUT_MOVE,
+      mouseup: INPUT_END
+  };
 
-      function addWeekYearFormatToken (token, getter) {
-          addFormatToken(0, [token, token.length], 0, getter);
-      }
+  var MOUSE_ELEMENT_EVENTS = 'mousedown';
+  var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
 
-      addWeekYearFormatToken('gggg',     'weekYear');
-      addWeekYearFormatToken('ggggg',    'weekYear');
-      addWeekYearFormatToken('GGGG',  'isoWeekYear');
-      addWeekYearFormatToken('GGGGG', 'isoWeekYear');
+  /**
+   * Mouse events input
+   * @constructor
+   * @extends Input
+   */
+  function MouseInput() {
+      this.evEl = MOUSE_ELEMENT_EVENTS;
+      this.evWin = MOUSE_WINDOW_EVENTS;
 
-      // ALIASES
+      this.allow = true; // used by Input.TouchMouse to disable mouse events
+      this.pressed = false; // mousedown state
 
-      addUnitAlias('weekYear', 'gg');
-      addUnitAlias('isoWeekYear', 'GG');
+      Input.apply(this, arguments);
+  }
 
-      // PARSING
+  inherit(MouseInput, Input, {
+      /**
+       * handle mouse events
+       * @param {Object} ev
+       */
+      handler: function MEhandler(ev) {
+          var eventType = MOUSE_INPUT_MAP[ev.type];
 
-      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);
+          // on start we want to have the left mouse button down
+          if (eventType & INPUT_START && ev.button === 0) {
+              this.pressed = true;
+          }
 
-      addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
-          week[token.substr(0, 2)] = toInt(input);
-      });
+          if (eventType & INPUT_MOVE && ev.which !== 1) {
+              eventType = INPUT_END;
+          }
 
-      addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
-          week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
-      });
+          // mouse must be down, and mouse events are allowed (see the TouchMouse input)
+          if (!this.pressed || !this.allow) {
+              return;
+          }
 
-      // HELPERS
+          if (eventType & INPUT_END) {
+              this.pressed = false;
+          }
 
-      function weeksInYear(year, dow, doy) {
-          return weekOfYear(local__createLocal([year, 11, 31 + dow - doy]), dow, doy).week;
+          this.callback(this.manager, eventType, {
+              pointers: [ev],
+              changedPointers: [ev],
+              pointerType: INPUT_TYPE_MOUSE,
+              srcEvent: ev
+          });
       }
+  });
 
-      // MOMENTS
+  var POINTER_INPUT_MAP = {
+      pointerdown: INPUT_START,
+      pointermove: INPUT_MOVE,
+      pointerup: INPUT_END,
+      pointercancel: INPUT_CANCEL,
+      pointerout: INPUT_CANCEL
+  };
 
-      function getSetWeekYear (input) {
-          var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
-          return input == null ? year : this.add((input - year), 'y');
-      }
+  // in IE10 the pointer types is defined as an enum
+  var IE10_POINTER_TYPE_ENUM = {
+      2: INPUT_TYPE_TOUCH,
+      3: INPUT_TYPE_PEN,
+      4: INPUT_TYPE_MOUSE,
+      5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816
+  };
 
-      function getSetISOWeekYear (input) {
-          var year = weekOfYear(this, 1, 4).year;
-          return input == null ? year : this.add((input - year), 'y');
-      }
+  var POINTER_ELEMENT_EVENTS = 'pointerdown';
+  var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';
 
-      function getISOWeeksInYear () {
-          return weeksInYear(this.year(), 1, 4);
-      }
+  // IE10 has prefixed support, and case-sensitive
+  if (window.MSPointerEvent) {
+      POINTER_ELEMENT_EVENTS = 'MSPointerDown';
+      POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
+  }
 
-      function getWeeksInYear () {
-          var weekInfo = this.localeData()._week;
-          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
-      }
+  /**
+   * Pointer events input
+   * @constructor
+   * @extends Input
+   */
+  function PointerEventInput() {
+      this.evEl = POINTER_ELEMENT_EVENTS;
+      this.evWin = POINTER_WINDOW_EVENTS;
 
-      addFormatToken('Q', 0, 0, 'quarter');
+      Input.apply(this, arguments);
 
-      // ALIASES
+      this.store = (this.manager.session.pointerEvents = []);
+  }
 
-      addUnitAlias('quarter', 'Q');
+  inherit(PointerEventInput, Input, {
+      /**
+       * handle mouse events
+       * @param {Object} ev
+       */
+      handler: function PEhandler(ev) {
+          var store = this.store;
+          var removePointer = false;
 
-      // PARSING
+          var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
+          var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
+          var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
 
-      addRegexToken('Q', match1);
-      addParseToken('Q', function (input, array) {
-          array[MONTH] = (toInt(input) - 1) * 3;
-      });
+          var isTouch = (pointerType == INPUT_TYPE_TOUCH);
 
-      // MOMENTS
+          // get index of the event in the store
+          var storeIndex = inArray(store, ev.pointerId, 'pointerId');
 
-      function getSetQuarter (input) {
-          return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
-      }
+          // start and mouse must be down
+          if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
+              if (storeIndex < 0) {
+                  store.push(ev);
+                  storeIndex = store.length - 1;
+              }
+          } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
+              removePointer = true;
+          }
 
-      addFormatToken('D', ['DD', 2], 'Do', 'date');
+          // it not found, so the pointer hasn't been down (so it's probably a hover)
+          if (storeIndex < 0) {
+              return;
+          }
 
-      // ALIASES
+          // update the event in the store
+          store[storeIndex] = ev;
 
-      addUnitAlias('date', 'D');
+          this.callback(this.manager, eventType, {
+              pointers: store,
+              changedPointers: [ev],
+              pointerType: pointerType,
+              srcEvent: ev
+          });
 
-      // PARSING
+          if (removePointer) {
+              // remove from the store
+              store.splice(storeIndex, 1);
+          }
+      }
+  });
 
-      addRegexToken('D',  match1to2);
-      addRegexToken('DD', match1to2, match2);
-      addRegexToken('Do', function (isStrict, locale) {
-          return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
-      });
+  var SINGLE_TOUCH_INPUT_MAP = {
+      touchstart: INPUT_START,
+      touchmove: INPUT_MOVE,
+      touchend: INPUT_END,
+      touchcancel: INPUT_CANCEL
+  };
 
-      addParseToken(['D', 'DD'], DATE);
-      addParseToken('Do', function (input, array) {
-          array[DATE] = toInt(input.match(match1to2)[0], 10);
-      });
+  var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
+  var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
 
-      // MOMENTS
+  /**
+   * Touch events input
+   * @constructor
+   * @extends Input
+   */
+  function SingleTouchInput() {
+      this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
+      this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
+      this.started = false;
 
-      var getSetDayOfMonth = makeGetSet('Date', true);
+      Input.apply(this, arguments);
+  }
 
-      addFormatToken('d', 0, 'do', 'day');
+  inherit(SingleTouchInput, Input, {
+      handler: function TEhandler(ev) {
+          var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
 
-      addFormatToken('dd', 0, 0, function (format) {
-          return this.localeData().weekdaysMin(this, format);
-      });
+          // should we handle the touch events?
+          if (type === INPUT_START) {
+              this.started = true;
+          }
 
-      addFormatToken('ddd', 0, 0, function (format) {
-          return this.localeData().weekdaysShort(this, format);
-      });
+          if (!this.started) {
+              return;
+          }
 
-      addFormatToken('dddd', 0, 0, function (format) {
-          return this.localeData().weekdays(this, format);
-      });
+          var touches = normalizeSingleTouches.call(this, ev, type);
 
-      addFormatToken('e', 0, 0, 'weekday');
-      addFormatToken('E', 0, 0, 'isoWeekday');
+          // when done, reset the started state
+          if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
+              this.started = false;
+          }
 
-      // ALIASES
+          this.callback(this.manager, type, {
+              pointers: touches[0],
+              changedPointers: touches[1],
+              pointerType: INPUT_TYPE_TOUCH,
+              srcEvent: ev
+          });
+      }
+  });
 
-      addUnitAlias('day', 'd');
-      addUnitAlias('weekday', 'e');
-      addUnitAlias('isoWeekday', 'E');
+  /**
+   * @this {TouchInput}
+   * @param {Object} ev
+   * @param {Number} type flag
+   * @returns {undefined|Array} [all, changed]
+   */
+  function normalizeSingleTouches(ev, type) {
+      var all = toArray(ev.touches);
+      var changed = toArray(ev.changedTouches);
 
-      // PARSING
+      if (type & (INPUT_END | INPUT_CANCEL)) {
+          all = uniqueArray(all.concat(changed), 'identifier', true);
+      }
 
-      addRegexToken('d',    match1to2);
-      addRegexToken('e',    match1to2);
-      addRegexToken('E',    match1to2);
-      addRegexToken('dd',   matchWord);
-      addRegexToken('ddd',  matchWord);
-      addRegexToken('dddd', matchWord);
+      return [all, changed];
+  }
 
-      addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) {
-          var weekday = config._locale.weekdaysParse(input);
-          // if we didn't get a weekday name, mark the date as invalid
-          if (weekday != null) {
-              week.d = weekday;
-          } else {
-              config._pf.invalidWeekday = input;
-          }
-      });
+  var TOUCH_INPUT_MAP = {
+      touchstart: INPUT_START,
+      touchmove: INPUT_MOVE,
+      touchend: INPUT_END,
+      touchcancel: INPUT_CANCEL
+  };
 
-      addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
-          week[token] = toInt(input);
-      });
+  var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
 
-      // HELPERS
+  /**
+   * Multi-user touch events input
+   * @constructor
+   * @extends Input
+   */
+  function TouchInput() {
+      this.evTarget = TOUCH_TARGET_EVENTS;
+      this.targetIds = {};
 
-      function parseWeekday(input, locale) {
-          if (typeof input === 'string') {
-              if (!isNaN(input)) {
-                  input = parseInt(input, 10);
-              }
-              else {
-                  input = locale.weekdaysParse(input);
-                  if (typeof input !== 'number') {
-                      return null;
-                  }
-              }
-          }
-          return input;
-      }
+      Input.apply(this, arguments);
+  }
 
-      // LOCALES
+  inherit(TouchInput, Input, {
+      handler: function MTEhandler(ev) {
+          var type = TOUCH_INPUT_MAP[ev.type];
+          var touches = getTouches.call(this, ev, type);
+          if (!touches) {
+              return;
+          }
 
-      var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
-      function localeWeekdays (m) {
-          return this._weekdays[m.day()];
+          this.callback(this.manager, type, {
+              pointers: touches[0],
+              changedPointers: touches[1],
+              pointerType: INPUT_TYPE_TOUCH,
+              srcEvent: ev
+          });
       }
+  });
 
-      var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
-      function localeWeekdaysShort (m) {
-          return this._weekdaysShort[m.day()];
-      }
+  /**
+   * @this {TouchInput}
+   * @param {Object} ev
+   * @param {Number} type flag
+   * @returns {undefined|Array} [all, changed]
+   */
+  function getTouches(ev, type) {
+      var allTouches = toArray(ev.touches);
+      var targetIds = this.targetIds;
 
-      var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
-      function localeWeekdaysMin (m) {
-          return this._weekdaysMin[m.day()];
+      // when there is only one touch, the process can be simplified
+      if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
+          targetIds[allTouches[0].identifier] = true;
+          return [allTouches, allTouches];
       }
 
-      function localeWeekdaysParse (weekdayName) {
-          var i, mom, regex;
+      var i,
+          targetTouches,
+          changedTouches = toArray(ev.changedTouches),
+          changedTargetTouches = [],
+          target = this.target;
 
-          if (!this._weekdaysParse) {
-              this._weekdaysParse = [];
-          }
+      // get target touches from touches
+      targetTouches = allTouches.filter(function(touch) {
+          return hasParent(touch.target, target);
+      });
 
-          for (i = 0; i < 7; i++) {
-              // make the regex if we don't have it already
-              if (!this._weekdaysParse[i]) {
-                  mom = local__createLocal([2000, 1]).day(i);
-                  regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
-                  this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
-              }
-              // test the regex
-              if (this._weekdaysParse[i].test(weekdayName)) {
-                  return i;
-              }
+      // collect touches
+      if (type === INPUT_START) {
+          i = 0;
+          while (i < targetTouches.length) {
+              targetIds[targetTouches[i].identifier] = true;
+              i++;
           }
       }
 
-      // MOMENTS
-
-      function getSetDayOfWeek (input) {
-          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;
+      // filter changed touches to only contain touches that exist in the collected target ids
+      i = 0;
+      while (i < changedTouches.length) {
+          if (targetIds[changedTouches[i].identifier]) {
+              changedTargetTouches.push(changedTouches[i]);
           }
-      }
 
-      function getSetLocaleDayOfWeek (input) {
-          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
-          return input == null ? weekday : this.add(input - weekday, 'd');
-      }
-
-      function getSetISODayOfWeek (input) {
-          // 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.
-          return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
+          // cleanup removed touches
+          if (type & (INPUT_END | INPUT_CANCEL)) {
+              delete targetIds[changedTouches[i].identifier];
+          }
+          i++;
       }
 
-      addFormatToken('H', ['HH', 2], 0, 'hour');
-      addFormatToken('h', ['hh', 2], 0, function () {
-          return this.hours() % 12 || 12;
-      });
-
-      function meridiem (token, lowercase) {
-          addFormatToken(token, 0, 0, function () {
-              return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
-          });
+      if (!changedTargetTouches.length) {
+          return;
       }
 
-      meridiem('a', true);
-      meridiem('A', false);
-
-      // ALIASES
+      return [
+          // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
+          uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),
+          changedTargetTouches
+      ];
+  }
 
-      addUnitAlias('hour', 'h');
+  /**
+   * Combined touch and mouse input
+   *
+   * Touch has a higher priority then mouse, and while touching no mouse events are allowed.
+   * This because touch devices also emit mouse events while doing a touch.
+   *
+   * @constructor
+   * @extends Input
+   */
+  function TouchMouseInput() {
+      Input.apply(this, arguments);
 
-      // PARSING
+      var handler = bindFn(this.handler, this);
+      this.touch = new TouchInput(this.manager, handler);
+      this.mouse = new MouseInput(this.manager, handler);
+  }
 
-      function matchMeridiem (isStrict, locale) {
-          return locale._meridiemParse;
-      }
+  inherit(TouchMouseInput, Input, {
+      /**
+       * handle mouse and touch events
+       * @param {Hammer} manager
+       * @param {String} inputEvent
+       * @param {Object} inputData
+       */
+      handler: function TMEhandler(manager, inputEvent, inputData) {
+          var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),
+              isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);
 
-      addRegexToken('a',  matchMeridiem);
-      addRegexToken('A',  matchMeridiem);
-      addRegexToken('H',  match1to2);
-      addRegexToken('h',  match1to2);
-      addRegexToken('HH', match1to2, match2);
-      addRegexToken('hh', match1to2, match2);
+          // when we're in a touch event, so  block all upcoming mouse events
+          // most mobile browser also emit mouseevents, right after touchstart
+          if (isTouch) {
+              this.mouse.allow = false;
+          } else if (isMouse && !this.mouse.allow) {
+              return;
+          }
 
-      addParseToken(['H', 'HH'], HOUR);
-      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);
-          config._pf.bigHour = true;
-      });
+          // reset the allowMouse when we're done
+          if (inputEvent & (INPUT_END | INPUT_CANCEL)) {
+              this.mouse.allow = true;
+          }
 
-      // LOCALES
+          this.callback(manager, inputEvent, inputData);
+      },
 
-      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');
+      /**
+       * remove the event listeners
+       */
+      destroy: function destroy() {
+          this.touch.destroy();
+          this.mouse.destroy();
       }
+  });
 
-      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
-      function localeMeridiem (hours, minutes, isLower) {
-          if (hours > 11) {
-              return isLower ? 'pm' : 'PM';
-          } else {
-              return isLower ? 'am' : 'AM';
-          }
-      }
+  var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
+  var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
 
+  // magical touchAction value
+  var TOUCH_ACTION_COMPUTE = 'compute';
+  var TOUCH_ACTION_AUTO = 'auto';
+  var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
+  var TOUCH_ACTION_NONE = 'none';
+  var TOUCH_ACTION_PAN_X = 'pan-x';
+  var TOUCH_ACTION_PAN_Y = 'pan-y';
 
-      // MOMENTS
+  /**
+   * Touch Action
+   * sets the touchAction property or uses the js alternative
+   * @param {Manager} manager
+   * @param {String} value
+   * @constructor
+   */
+  function TouchAction(manager, value) {
+      this.manager = manager;
+      this.set(value);
+  }
 
-      // 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);
+  TouchAction.prototype = {
+      /**
+       * set the touchAction value on the element or enable the polyfill
+       * @param {String} value
+       */
+      set: function(value) {
+          // find out the touch-action by the event handlers
+          if (value == TOUCH_ACTION_COMPUTE) {
+              value = this.compute();
+          }
 
-      addFormatToken('m', ['mm', 2], 0, 'minute');
+          if (NATIVE_TOUCH_ACTION) {
+              this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
+          }
+          this.actions = value.toLowerCase().trim();
+      },
 
-      // ALIASES
+      /**
+       * just re-set the touchAction value
+       */
+      update: function() {
+          this.set(this.manager.options.touchAction);
+      },
 
-      addUnitAlias('minute', 'm');
+      /**
+       * compute the value for the touchAction property based on the recognizer's settings
+       * @returns {String} value
+       */
+      compute: function() {
+          var actions = [];
+          each(this.manager.recognizers, function(recognizer) {
+              if (boolOrFn(recognizer.options.enable, [recognizer])) {
+                  actions = actions.concat(recognizer.getTouchAction());
+              }
+          });
+          return cleanTouchActions(actions.join(' '));
+      },
 
-      // PARSING
+      /**
+       * this method is called on each input cycle and provides the preventing of the browser behavior
+       * @param {Object} input
+       */
+      preventDefaults: function(input) {
+          // not needed with native support for the touchAction property
+          if (NATIVE_TOUCH_ACTION) {
+              return;
+          }
 
-      addRegexToken('m',  match1to2);
-      addRegexToken('mm', match1to2, match2);
-      addParseToken(['m', 'mm'], MINUTE);
+          var srcEvent = input.srcEvent;
+          var direction = input.offsetDirection;
 
-      // MOMENTS
+          // if the touch action did prevented once this session
+          if (this.manager.session.prevented) {
+              srcEvent.preventDefault();
+              return;
+          }
 
-      var getSetMinute = makeGetSet('Minutes', false);
+          var actions = this.actions;
+          var hasNone = inStr(actions, TOUCH_ACTION_NONE);
+          var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
+          var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
 
-      addFormatToken('s', ['ss', 2], 0, 'second');
+          if (hasNone ||
+              (hasPanY && direction & DIRECTION_HORIZONTAL) ||
+              (hasPanX && direction & DIRECTION_VERTICAL)) {
+              return this.preventSrc(srcEvent);
+          }
+      },
 
-      // ALIASES
+      /**
+       * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
+       * @param {Object} srcEvent
+       */
+      preventSrc: function(srcEvent) {
+          this.manager.session.prevented = true;
+          srcEvent.preventDefault();
+      }
+  };
 
-      addUnitAlias('second', 's');
+  /**
+   * when the touchActions are collected they are not a valid value, so we need to clean things up. *
+   * @param {String} actions
+   * @returns {*}
+   */
+  function cleanTouchActions(actions) {
+      // none
+      if (inStr(actions, TOUCH_ACTION_NONE)) {
+          return TOUCH_ACTION_NONE;
+      }
 
-      // PARSING
+      var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
+      var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
 
-      addRegexToken('s',  match1to2);
-      addRegexToken('ss', match1to2, match2);
-      addParseToken(['s', 'ss'], SECOND);
+      // pan-x and pan-y can be combined
+      if (hasPanX && hasPanY) {
+          return TOUCH_ACTION_PAN_X + ' ' + TOUCH_ACTION_PAN_Y;
+      }
 
-      // MOMENTS
+      // pan-x OR pan-y
+      if (hasPanX || hasPanY) {
+          return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
+      }
 
-      var getSetSecond = makeGetSet('Seconds', false);
+      // manipulation
+      if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
+          return TOUCH_ACTION_MANIPULATION;
+      }
 
-      addFormatToken('S', 0, 0, function () {
-          return ~~(this.millisecond() / 100);
-      });
+      return TOUCH_ACTION_AUTO;
+  }
 
-      addFormatToken(0, ['SS', 2], 0, function () {
-          return ~~(this.millisecond() / 10);
-      });
+  /**
+   * Recognizer flow explained; *
+   * All recognizers have the initial state of POSSIBLE when a input session starts.
+   * The definition of a input session is from the first input until the last input, with all it's movement in it. *
+   * Example session for mouse-input: mousedown -> mousemove -> mouseup
+   *
+   * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
+   * which determines with state it should be.
+   *
+   * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
+   * POSSIBLE to give it another change on the next cycle.
+   *
+   *               Possible
+   *                  |
+   *            +-----+---------------+
+   *            |                     |
+   *      +-----+-----+               |
+   *      |           |               |
+   *   Failed      Cancelled          |
+   *                          +-------+------+
+   *                          |              |
+   *                      Recognized       Began
+   *                                         |
+   *                                      Changed
+   *                                         |
+   *                                  Ended/Recognized
+   */
+  var STATE_POSSIBLE = 1;
+  var STATE_BEGAN = 2;
+  var STATE_CHANGED = 4;
+  var STATE_ENDED = 8;
+  var STATE_RECOGNIZED = STATE_ENDED;
+  var STATE_CANCELLED = 16;
+  var STATE_FAILED = 32;
 
-      function millisecond__milliseconds (token) {
-          addFormatToken(0, [token, 3], 0, 'millisecond');
-      }
+  /**
+   * Recognizer
+   * Every recognizer needs to extend from this class.
+   * @constructor
+   * @param {Object} options
+   */
+  function Recognizer(options) {
+      this.id = uniqueId();
 
-      millisecond__milliseconds('SSS');
-      millisecond__milliseconds('SSSS');
+      this.manager = null;
+      this.options = merge(options || {}, this.defaults);
 
-      // ALIASES
+      // default is enable true
+      this.options.enable = ifUndefined(this.options.enable, true);
 
-      addUnitAlias('millisecond', 'ms');
+      this.state = STATE_POSSIBLE;
 
-      // PARSING
+      this.simultaneous = {};
+      this.requireFail = [];
+  }
 
-      addRegexToken('S',    match1to3, match1);
-      addRegexToken('SS',   match1to3, match2);
-      addRegexToken('SSS',  match1to3, match3);
-      addRegexToken('SSSS', matchUnsigned);
-      addParseToken(['S', 'SS', 'SSS', 'SSSS'], function (input, array) {
-          array[MILLISECOND] = toInt(('0.' + input) * 1000);
-      });
+  Recognizer.prototype = {
+      /**
+       * @virtual
+       * @type {Object}
+       */
+      defaults: {},
 
-      // MOMENTS
+      /**
+       * set options
+       * @param {Object} options
+       * @return {Recognizer}
+       */
+      set: function(options) {
+          extend(this.options, options);
 
-      var getSetMillisecond = makeGetSet('Milliseconds', false);
+          // also update the touchAction, in case something changed about the directions/enabled state
+          this.manager && this.manager.touchAction.update();
+          return this;
+      },
 
-      addFormatToken('z',  0, 0, 'zoneAbbr');
-      addFormatToken('zz', 0, 0, 'zoneName');
+      /**
+       * recognize simultaneous with an other recognizer.
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      recognizeWith: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
+              return this;
+          }
 
-      // MOMENTS
+          var simultaneous = this.simultaneous;
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          if (!simultaneous[otherRecognizer.id]) {
+              simultaneous[otherRecognizer.id] = otherRecognizer;
+              otherRecognizer.recognizeWith(this);
+          }
+          return this;
+      },
 
-      function getZoneAbbr () {
-          return this._isUTC ? 'UTC' : '';
-      }
+      /**
+       * drop the simultaneous link. it doesnt remove the link on the other recognizer.
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      dropRecognizeWith: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
+              return this;
+          }
 
-      function getZoneName () {
-          return this._isUTC ? 'Coordinated Universal Time' : '';
-      }
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          delete this.simultaneous[otherRecognizer.id];
+          return this;
+      },
 
-      var momentPrototype__proto = Moment.prototype;
+      /**
+       * recognizer can only run when an other is failing
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      requireFailure: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
+              return this;
+          }
 
-      momentPrototype__proto.add          = add_subtract__add;
-      momentPrototype__proto.calendar     = moment_calendar__calendar;
-      momentPrototype__proto.clone        = clone;
-      momentPrototype__proto.diff         = diff;
-      momentPrototype__proto.endOf        = endOf;
-      momentPrototype__proto.format       = format;
-      momentPrototype__proto.from         = from;
-      momentPrototype__proto.fromNow      = fromNow;
-      momentPrototype__proto.get          = getSet;
-      momentPrototype__proto.invalidAt    = invalidAt;
-      momentPrototype__proto.isAfter      = isAfter;
-      momentPrototype__proto.isBefore     = isBefore;
-      momentPrototype__proto.isBetween    = isBetween;
-      momentPrototype__proto.isSame       = isSame;
-      momentPrototype__proto.isValid      = moment_valid__isValid;
-      momentPrototype__proto.lang         = lang;
-      momentPrototype__proto.locale       = locale;
-      momentPrototype__proto.localeData   = localeData;
-      momentPrototype__proto.max          = prototypeMax;
-      momentPrototype__proto.min          = prototypeMin;
-      momentPrototype__proto.parsingFlags = parsingFlags;
-      momentPrototype__proto.set          = getSet;
-      momentPrototype__proto.startOf      = startOf;
-      momentPrototype__proto.subtract     = add_subtract__subtract;
-      momentPrototype__proto.toArray      = toArray;
-      momentPrototype__proto.toDate       = toDate;
-      momentPrototype__proto.toISOString  = moment_format__toISOString;
-      momentPrototype__proto.toJSON       = moment_format__toISOString;
-      momentPrototype__proto.toString     = toString;
-      momentPrototype__proto.unix         = unix;
-      momentPrototype__proto.valueOf      = to_type__valueOf;
+          var requireFail = this.requireFail;
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          if (inArray(requireFail, otherRecognizer) === -1) {
+              requireFail.push(otherRecognizer);
+              otherRecognizer.requireFailure(this);
+          }
+          return this;
+      },
 
-      // Year
-      momentPrototype__proto.year       = getSetYear;
-      momentPrototype__proto.isLeapYear = getIsLeapYear;
+      /**
+       * drop the requireFailure link. it does not remove the link on the other recognizer.
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      dropRequireFailure: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
+              return this;
+          }
 
-      // Week Year
-      momentPrototype__proto.weekYear    = getSetWeekYear;
-      momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          var index = inArray(this.requireFail, otherRecognizer);
+          if (index > -1) {
+              this.requireFail.splice(index, 1);
+          }
+          return this;
+      },
 
-      // Quarter
-      momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
+      /**
+       * has require failures boolean
+       * @returns {boolean}
+       */
+      hasRequireFailures: function() {
+          return this.requireFail.length > 0;
+      },
 
-      // Month
-      momentPrototype__proto.month       = getSetMonth;
-      momentPrototype__proto.daysInMonth = getDaysInMonth;
+      /**
+       * if the recognizer can recognize simultaneous with an other recognizer
+       * @param {Recognizer} otherRecognizer
+       * @returns {Boolean}
+       */
+      canRecognizeWith: function(otherRecognizer) {
+          return !!this.simultaneous[otherRecognizer.id];
+      },
 
-      // Week
-      momentPrototype__proto.week           = momentPrototype__proto.weeks        = getSetWeek;
-      momentPrototype__proto.isoWeek        = momentPrototype__proto.isoWeeks     = getSetISOWeek;
-      momentPrototype__proto.weeksInYear    = getWeeksInYear;
-      momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
+      /**
+       * You should use `tryEmit` instead of `emit` directly to check
+       * that all the needed recognizers has failed before emitting.
+       * @param {Object} input
+       */
+      emit: function(input) {
+          var self = this;
+          var state = this.state;
 
-      // Day
-      momentPrototype__proto.date       = getSetDayOfMonth;
-      momentPrototype__proto.day        = momentPrototype__proto.days             = getSetDayOfWeek;
-      momentPrototype__proto.weekday    = getSetLocaleDayOfWeek;
-      momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
-      momentPrototype__proto.dayOfYear  = getSetDayOfYear;
+          function emit(withState) {
+              self.manager.emit(self.options.event + (withState ? stateStr(state) : ''), input);
+          }
 
-      // Hour
-      momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
+          // 'panstart' and 'panmove'
+          if (state < STATE_ENDED) {
+              emit(true);
+          }
 
-      // Minute
-      momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
+          emit(); // simple 'eventName' events
 
-      // Second
-      momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
+          // panend and pancancel
+          if (state >= STATE_ENDED) {
+              emit(true);
+          }
+      },
 
-      // Millisecond
-      momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
+      /**
+       * Check that all the require failure recognizers has failed,
+       * if true, it emits a gesture event,
+       * otherwise, setup the state to FAILED.
+       * @param {Object} input
+       */
+      tryEmit: function(input) {
+          if (this.canEmit()) {
+              return this.emit(input);
+          }
+          // it's failing anyway
+          this.state = STATE_FAILED;
+      },
 
-      // Offset
-      momentPrototype__proto.utcOffset            = getSetOffset;
-      momentPrototype__proto.utc                  = setOffsetToUTC;
-      momentPrototype__proto.local                = setOffsetToLocal;
-      momentPrototype__proto.parseZone            = setOffsetToParsedOffset;
-      momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
-      momentPrototype__proto.isDST                = isDaylightSavingTime;
-      momentPrototype__proto.isDSTShifted         = isDaylightSavingTimeShifted;
-      momentPrototype__proto.isLocal              = isLocal;
-      momentPrototype__proto.isUtcOffset          = isUtcOffset;
-      momentPrototype__proto.isUtc                = isUtc;
-      momentPrototype__proto.isUTC                = isUtc;
+      /**
+       * can we emit?
+       * @returns {boolean}
+       */
+      canEmit: function() {
+          var i = 0;
+          while (i < this.requireFail.length) {
+              if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
+                  return false;
+              }
+              i++;
+          }
+          return true;
+      },
 
-      // Timezone
-      momentPrototype__proto.zoneAbbr = getZoneAbbr;
-      momentPrototype__proto.zoneName = getZoneName;
+      /**
+       * update the recognizer
+       * @param {Object} inputData
+       */
+      recognize: function(inputData) {
+          // make a new copy of the inputData
+          // so we can change the inputData without messing up the other recognizers
+          var inputDataClone = extend({}, inputData);
 
-      // Deprecations
-      momentPrototype__proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
-      momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
-      momentPrototype__proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
-      momentPrototype__proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
+          // is is enabled and allow recognizing?
+          if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
+              this.reset();
+              this.state = STATE_FAILED;
+              return;
+          }
 
-      var momentPrototype = momentPrototype__proto;
+          // reset when we've reached the end
+          if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
+              this.state = STATE_POSSIBLE;
+          }
 
-      function moment__createUnix (input) {
-          return local__createLocal(input * 1000);
-      }
+          this.state = this.process(inputDataClone);
 
-      function moment__createInZone () {
-          return local__createLocal.apply(null, arguments).parseZone();
-      }
+          // the recognizer has recognized a gesture
+          // so trigger an event
+          if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
+              this.tryEmit(inputDataClone);
+          }
+      },
 
-      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'
-      };
+      /**
+       * return the state of the recognizer
+       * the actual recognizing happens in this method
+       * @virtual
+       * @param {Object} inputData
+       * @returns {Const} STATE
+       */
+      process: function(inputData) { }, // jshint ignore:line
 
-      function locale_calendar__calendar (key, mom, now) {
-          var output = this._calendar[key];
-          return typeof output === 'function' ? output.call(mom, now) : output;
-      }
+      /**
+       * return the preferred touch-action
+       * @virtual
+       * @returns {Array}
+       */
+      getTouchAction: function() { },
 
-      var defaultLongDateFormat = {
-          LTS  : 'h:mm:ss A',
-          LT   : 'h:mm A',
-          L    : 'MM/DD/YYYY',
-          LL   : 'MMMM D, YYYY',
-          LLL  : 'MMMM D, YYYY LT',
-          LLLL : 'dddd, MMMM D, YYYY LT'
-      };
+      /**
+       * called when the gesture isn't allowed to recognize
+       * like when another is being recognized or it is disabled
+       * @virtual
+       */
+      reset: function() { }
+  };
 
-      function longDateFormat (key) {
-          var output = this._longDateFormat[key];
-          if (!output && this._longDateFormat[key.toUpperCase()]) {
-              output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {
-                  return val.slice(1);
-              });
-              this._longDateFormat[key] = output;
-          }
-          return output;
+  /**
+   * get a usable string, used as event postfix
+   * @param {Const} state
+   * @returns {String} state
+   */
+  function stateStr(state) {
+      if (state & STATE_CANCELLED) {
+          return 'cancel';
+      } else if (state & STATE_ENDED) {
+          return 'end';
+      } else if (state & STATE_CHANGED) {
+          return 'move';
+      } else if (state & STATE_BEGAN) {
+          return 'start';
       }
+      return '';
+  }
 
-      var defaultInvalidDate = 'Invalid date';
-
-      function invalidDate () {
-          return this._invalidDate;
+  /**
+   * direction cons to string
+   * @param {Const} direction
+   * @returns {String}
+   */
+  function directionStr(direction) {
+      if (direction == DIRECTION_DOWN) {
+          return 'down';
+      } else if (direction == DIRECTION_UP) {
+          return 'up';
+      } else if (direction == DIRECTION_LEFT) {
+          return 'left';
+      } else if (direction == DIRECTION_RIGHT) {
+          return 'right';
       }
+      return '';
+  }
 
-      var defaultOrdinal = '%d';
-      var defaultOrdinalParse = /\d{1,2}/;
-
-      function ordinal (number) {
-          return this._ordinal.replace('%d', number);
+  /**
+   * get a recognizer by name if it is bound to a manager
+   * @param {Recognizer|String} otherRecognizer
+   * @param {Recognizer} recognizer
+   * @returns {Recognizer}
+   */
+  function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
+      var manager = recognizer.manager;
+      if (manager) {
+          return manager.get(otherRecognizer);
       }
+      return otherRecognizer;
+  }
 
-      function preParsePostFormat (string) {
-          return string;
-      }
+  /**
+   * This recognizer is just used as a base for the simple attribute recognizers.
+   * @constructor
+   * @extends Recognizer
+   */
+  function AttrRecognizer() {
+      Recognizer.apply(this, arguments);
+  }
 
-      var defaultRelativeTime = {
-          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'
-      };
+  inherit(AttrRecognizer, Recognizer, {
+      /**
+       * @namespace
+       * @memberof AttrRecognizer
+       */
+      defaults: {
+          /**
+           * @type {Number}
+           * @default 1
+           */
+          pointers: 1
+      },
 
-      function relative__relativeTime (number, withoutSuffix, string, isFuture) {
-          var output = this._relativeTime[string];
-          return (typeof output === 'function') ?
-              output(number, withoutSuffix, string, isFuture) :
-              output.replace(/%d/i, number);
-      }
+      /**
+       * Used to check if it the recognizer receives valid input, like input.distance > 10.
+       * @memberof AttrRecognizer
+       * @param {Object} input
+       * @returns {Boolean} recognized
+       */
+      attrTest: function(input) {
+          var optionPointers = this.options.pointers;
+          return optionPointers === 0 || input.pointers.length === optionPointers;
+      },
 
-      function pastFuture (diff, output) {
-          var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
-          return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
-      }
+      /**
+       * Process the input and return the state for the recognizer
+       * @memberof AttrRecognizer
+       * @param {Object} input
+       * @returns {*} State
+       */
+      process: function(input) {
+          var state = this.state;
+          var eventType = input.eventType;
 
-      function locale_set__set (config) {
-          var prop, i;
-          for (i in config) {
-              prop = config[i];
-              if (typeof prop === 'function') {
-                  this[i] = prop;
-              } else {
-                  this['_' + i] = prop;
+          var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
+          var isValid = this.attrTest(input);
+
+          // on cancel input and we've recognized before, return STATE_CANCELLED
+          if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
+              return state | STATE_CANCELLED;
+          } else if (isRecognized || isValid) {
+              if (eventType & INPUT_END) {
+                  return state | STATE_ENDED;
+              } else if (!(state & STATE_BEGAN)) {
+                  return STATE_BEGAN;
               }
+              return state | STATE_CHANGED;
           }
-          // Lenient ordinal parsing accepts just a number in addition to
-          // number + (possibly) stuff coming from _ordinalParseLenient.
-          this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + /\d{1,2}/.source);
+          return STATE_FAILED;
       }
+  });
 
-      var prototype__proto = Locale.prototype;
-
-      prototype__proto._calendar       = defaultCalendar;
-      prototype__proto.calendar        = locale_calendar__calendar;
-      prototype__proto._longDateFormat = defaultLongDateFormat;
-      prototype__proto.longDateFormat  = longDateFormat;
-      prototype__proto._invalidDate    = defaultInvalidDate;
-      prototype__proto.invalidDate     = invalidDate;
-      prototype__proto._ordinal        = defaultOrdinal;
-      prototype__proto.ordinal         = ordinal;
-      prototype__proto._ordinalParse   = defaultOrdinalParse;
-      prototype__proto.preparse        = preParsePostFormat;
-      prototype__proto.postformat      = preParsePostFormat;
-      prototype__proto._relativeTime   = defaultRelativeTime;
-      prototype__proto.relativeTime    = relative__relativeTime;
-      prototype__proto.pastFuture      = pastFuture;
-      prototype__proto.set             = locale_set__set;
-
-      // Month
-      prototype__proto.months       =        localeMonths;
-      prototype__proto._months      = defaultLocaleMonths;
-      prototype__proto.monthsShort  =        localeMonthsShort;
-      prototype__proto._monthsShort = defaultLocaleMonthsShort;
-      prototype__proto.monthsParse  =        localeMonthsParse;
+  /**
+   * Pan
+   * Recognized when the pointer is down and moved in the allowed direction.
+   * @constructor
+   * @extends AttrRecognizer
+   */
+  function PanRecognizer() {
+      AttrRecognizer.apply(this, arguments);
 
-      // Week
-      prototype__proto.week = localeWeek;
-      prototype__proto._week = defaultLocaleWeek;
-      prototype__proto.firstDayOfYear = localeFirstDayOfYear;
-      prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
+      this.pX = null;
+      this.pY = null;
+  }
 
-      // Day of Week
-      prototype__proto.weekdays       =        localeWeekdays;
-      prototype__proto._weekdays      = defaultLocaleWeekdays;
-      prototype__proto.weekdaysMin    =        localeWeekdaysMin;
-      prototype__proto._weekdaysMin   = defaultLocaleWeekdaysMin;
-      prototype__proto.weekdaysShort  =        localeWeekdaysShort;
-      prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
-      prototype__proto.weekdaysParse  =        localeWeekdaysParse;
+  inherit(PanRecognizer, AttrRecognizer, {
+      /**
+       * @namespace
+       * @memberof PanRecognizer
+       */
+      defaults: {
+          event: 'pan',
+          threshold: 10,
+          pointers: 1,
+          direction: DIRECTION_ALL
+      },
 
-      // Hours
-      prototype__proto.isPM = localeIsPM;
-      prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
-      prototype__proto.meridiem = localeMeridiem;
+      getTouchAction: function() {
+          var direction = this.options.direction;
+          var actions = [];
+          if (direction & DIRECTION_HORIZONTAL) {
+              actions.push(TOUCH_ACTION_PAN_Y);
+          }
+          if (direction & DIRECTION_VERTICAL) {
+              actions.push(TOUCH_ACTION_PAN_X);
+          }
+          return actions;
+      },
 
-      function lists__get (format, index, field, setter) {
-          var locale = locale_locales__getLocale();
-          var utc = create_utc__createUTC().set(setter, index);
-          return locale[field](utc, format);
-      }
+      directionTest: function(input) {
+          var options = this.options;
+          var hasMoved = true;
+          var distance = input.distance;
+          var direction = input.direction;
+          var x = input.deltaX;
+          var y = input.deltaY;
 
-      function list (format, index, field, count, setter) {
-          if (typeof format === 'number') {
-              index = format;
-              format = undefined;
+          // lock to axis?
+          if (!(direction & options.direction)) {
+              if (options.direction & DIRECTION_HORIZONTAL) {
+                  direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
+                  hasMoved = x != this.pX;
+                  distance = Math.abs(input.deltaX);
+              } else {
+                  direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;
+                  hasMoved = y != this.pY;
+                  distance = Math.abs(input.deltaY);
+              }
           }
+          input.direction = direction;
+          return hasMoved && distance > options.threshold && direction & options.direction;
+      },
 
-          format = format || '';
+      attrTest: function(input) {
+          return AttrRecognizer.prototype.attrTest.call(this, input) &&
+              (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));
+      },
 
-          if (index != null) {
-              return lists__get(format, index, field, setter);
-          }
+      emit: function(input) {
+          this.pX = input.deltaX;
+          this.pY = input.deltaY;
 
-          var i;
-          var out = [];
-          for (i = 0; i < count; i++) {
-              out[i] = lists__get(format, i, field, setter);
+          var direction = directionStr(input.direction);
+          if (direction) {
+              this.manager.emit(this.options.event + direction, input);
           }
-          return out;
-      }
 
-      function lists__listMonths (format, index) {
-          return list(format, index, 'months', 12, 'month');
+          this._super.emit.call(this, input);
       }
+  });
 
-      function lists__listMonthsShort (format, index) {
-          return list(format, index, 'monthsShort', 12, 'month');
-      }
+  /**
+   * Pinch
+   * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
+   * @constructor
+   * @extends AttrRecognizer
+   */
+  function PinchRecognizer() {
+      AttrRecognizer.apply(this, arguments);
+  }
 
-      function lists__listWeekdays (format, index) {
-          return list(format, index, 'weekdays', 7, 'day');
-      }
+  inherit(PinchRecognizer, AttrRecognizer, {
+      /**
+       * @namespace
+       * @memberof PinchRecognizer
+       */
+      defaults: {
+          event: 'pinch',
+          threshold: 0,
+          pointers: 2
+      },
 
-      function lists__listWeekdaysShort (format, index) {
-          return list(format, index, 'weekdaysShort', 7, 'day');
-      }
+      getTouchAction: function() {
+          return [TOUCH_ACTION_NONE];
+      },
 
-      function lists__listWeekdaysMin (format, index) {
-          return list(format, index, 'weekdaysMin', 7, 'day');
-      }
+      attrTest: function(input) {
+          return this._super.attrTest.call(this, input) &&
+              (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
+      },
 
-      locale_locales__getSetGlobalLocale('en', {
-          ordinalParse: /\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;
+      emit: function(input) {
+          this._super.emit.call(this, input);
+          if (input.scale !== 1) {
+              var inOut = input.scale < 1 ? 'in' : 'out';
+              this.manager.emit(this.options.event + inOut, input);
           }
-      });
+      }
+  });
 
-      // Side effect imports
-      utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
-      utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
+  /**
+   * Press
+   * Recognized when the pointer is down for x ms without any movement.
+   * @constructor
+   * @extends Recognizer
+   */
+  function PressRecognizer() {
+      Recognizer.apply(this, arguments);
 
-      var mathAbs = Math.abs;
+      this._timer = null;
+      this._input = null;
+  }
 
-      function duration_abs__abs () {
-          var data           = this._data;
+  inherit(PressRecognizer, Recognizer, {
+      /**
+       * @namespace
+       * @memberof PressRecognizer
+       */
+      defaults: {
+          event: 'press',
+          pointers: 1,
+          time: 500, // minimal time of the pointer to be pressed
+          threshold: 5 // a minimal movement is ok, but keep it low
+      },
 
-          this._milliseconds = mathAbs(this._milliseconds);
-          this._days         = mathAbs(this._days);
-          this._months       = mathAbs(this._months);
+      getTouchAction: function() {
+          return [TOUCH_ACTION_AUTO];
+      },
 
-          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);
+      process: function(input) {
+          var options = this.options;
+          var validPointers = input.pointers.length === options.pointers;
+          var validMovement = input.distance < options.threshold;
+          var validTime = input.deltaTime > options.time;
 
-          return this;
-      }
+          this._input = input;
 
-      function duration_add_subtract__addSubtract (duration, input, value, direction) {
-          var other = create__createDuration(input, value);
+          // we only allow little movement
+          // and we've reached an end event, so a tap is possible
+          if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {
+              this.reset();
+          } else if (input.eventType & INPUT_START) {
+              this.reset();
+              this._timer = setTimeoutContext(function() {
+                  this.state = STATE_RECOGNIZED;
+                  this.tryEmit();
+              }, options.time, this);
+          } else if (input.eventType & INPUT_END) {
+              return STATE_RECOGNIZED;
+          }
+          return STATE_FAILED;
+      },
 
-          duration._milliseconds += direction * other._milliseconds;
-          duration._days         += direction * other._days;
-          duration._months       += direction * other._months;
+      reset: function() {
+          clearTimeout(this._timer);
+      },
 
-          return duration._bubble();
-      }
+      emit: function(input) {
+          if (this.state !== STATE_RECOGNIZED) {
+              return;
+          }
 
-      // supports only 2.0-style add(1, 's') or add(duration)
-      function duration_add_subtract__add (input, value) {
-          return duration_add_subtract__addSubtract(this, input, value, 1);
+          if (input && (input.eventType & INPUT_END)) {
+              this.manager.emit(this.options.event + 'up', input);
+          } else {
+              this._input.timeStamp = now();
+              this.manager.emit(this.options.event, this._input);
+          }
       }
+  });
 
-      // supports only 2.0-style subtract(1, 's') or subtract(duration)
-      function duration_add_subtract__subtract (input, value) {
-          return duration_add_subtract__addSubtract(this, input, value, -1);
-      }
+  /**
+   * Rotate
+   * Recognized when two or more pointer are moving in a circular motion.
+   * @constructor
+   * @extends AttrRecognizer
+   */
+  function RotateRecognizer() {
+      AttrRecognizer.apply(this, arguments);
+  }
 
-      function bubble () {
-          var milliseconds = this._milliseconds;
-          var days         = this._days;
-          var months       = this._months;
-          var data         = this._data;
-          var seconds, minutes, hours, years = 0;
+  inherit(RotateRecognizer, AttrRecognizer, {
+      /**
+       * @namespace
+       * @memberof RotateRecognizer
+       */
+      defaults: {
+          event: 'rotate',
+          threshold: 0,
+          pointers: 2
+      },
 
-          // The following code bubbles up values, see the tests for
-          // examples of what that means.
-          data.milliseconds = milliseconds % 1000;
+      getTouchAction: function() {
+          return [TOUCH_ACTION_NONE];
+      },
 
-          seconds           = absFloor(milliseconds / 1000);
-          data.seconds      = seconds % 60;
+      attrTest: function(input) {
+          return this._super.attrTest.call(this, input) &&
+              (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
+      }
+  });
 
-          minutes           = absFloor(seconds / 60);
-          data.minutes      = minutes % 60;
+  /**
+   * Swipe
+   * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
+   * @constructor
+   * @extends AttrRecognizer
+   */
+  function SwipeRecognizer() {
+      AttrRecognizer.apply(this, arguments);
+  }
 
-          hours             = absFloor(minutes / 60);
-          data.hours        = hours % 24;
+  inherit(SwipeRecognizer, AttrRecognizer, {
+      /**
+       * @namespace
+       * @memberof SwipeRecognizer
+       */
+      defaults: {
+          event: 'swipe',
+          threshold: 10,
+          velocity: 0.65,
+          direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
+          pointers: 1
+      },
 
-          days += absFloor(hours / 24);
+      getTouchAction: function() {
+          return PanRecognizer.prototype.getTouchAction.call(this);
+      },
 
-          // Accurately convert days to years, assume start from year 0.
-          years = absFloor(daysToYears(days));
-          days -= absFloor(yearsToDays(years));
+      attrTest: function(input) {
+          var direction = this.options.direction;
+          var velocity;
 
-          // 30 days to a month
-          // TODO (iskren): Use anchor date (like 1st Jan) to compute this.
-          months += absFloor(days / 30);
-          days   %= 30;
+          if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
+              velocity = input.velocity;
+          } else if (direction & DIRECTION_HORIZONTAL) {
+              velocity = input.velocityX;
+          } else if (direction & DIRECTION_VERTICAL) {
+              velocity = input.velocityY;
+          }
 
-          // 12 months -> 1 year
-          years  += absFloor(months / 12);
-          months %= 12;
+          return this._super.attrTest.call(this, input) &&
+              direction & input.direction &&
+              input.distance > this.options.threshold &&
+              abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
+      },
 
-          data.days   = days;
-          data.months = months;
-          data.years  = years;
+      emit: function(input) {
+          var direction = directionStr(input.direction);
+          if (direction) {
+              this.manager.emit(this.options.event + direction, input);
+          }
 
-          return this;
+          this.manager.emit(this.options.event, input);
       }
+  });
 
-      function daysToYears (days) {
-          // 400 years have 146097 days (taking into account leap year rules)
-          return days * 400 / 146097;
-      }
+  /**
+   * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
+   * between the given interval and position. The delay option can be used to recognize multi-taps without firing
+   * a single tap.
+   *
+   * The eventData from the emitted event contains the property `tapCount`, which contains the amount of
+   * multi-taps being recognized.
+   * @constructor
+   * @extends Recognizer
+   */
+  function TapRecognizer() {
+      Recognizer.apply(this, arguments);
 
-      function yearsToDays (years) {
-          // years * 365 + absFloor(years / 4) -
-          //     absFloor(years / 100) + absFloor(years / 400);
-          return years * 146097 / 400;
-      }
+      // previous time and center,
+      // used for tap counting
+      this.pTime = false;
+      this.pCenter = false;
 
-      function as (units) {
-          var days;
-          var months;
-          var milliseconds = this._milliseconds;
+      this._timer = null;
+      this._input = null;
+      this.count = 0;
+  }
 
-          units = normalizeUnits(units);
+  inherit(TapRecognizer, Recognizer, {
+      /**
+       * @namespace
+       * @memberof PinchRecognizer
+       */
+      defaults: {
+          event: 'tap',
+          pointers: 1,
+          taps: 1,
+          interval: 300, // max time between the multi-tap taps
+          time: 250, // max time of the pointer to be down (like finger on the screen)
+          threshold: 2, // a minimal movement is ok, but keep it low
+          posThreshold: 10 // a multi-tap can be a bit off the initial position
+      },
 
-          if (units === 'month' || units === 'year') {
-              days   = this._days   + milliseconds / 864e5;
-              months = this._months + daysToYears(days) * 12;
-              return units === 'month' ? months : months / 12;
-          } else {
-              // handle milliseconds separately because of floating point math errors (issue #1867)
-              days = this._days + Math.round(yearsToDays(this._months / 12));
-              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 * 24 * 60      + milliseconds / 6e4;
-                  case 'second' : return days * 24 * 60 * 60 + milliseconds / 1000;
-                  // Math.floor prevents floating point math errors here
-                  case 'millisecond': return Math.floor(days * 24 * 60 * 60 * 1000) + milliseconds;
-                  default: throw new Error('Unknown unit ' + units);
-              }
-          }
-      }
+      getTouchAction: function() {
+          return [TOUCH_ACTION_MANIPULATION];
+      },
 
-      // TODO: Use this.as('ms')?
-      function duration_as__valueOf () {
-          return (
-              this._milliseconds +
-              this._days * 864e5 +
-              (this._months % 12) * 2592e6 +
-              toInt(this._months / 12) * 31536e6
-          );
-      }
+      process: function(input) {
+          var options = this.options;
 
-      function makeAs (alias) {
-          return function () {
-              return this.as(alias);
-          };
-      }
+          var validPointers = input.pointers.length === options.pointers;
+          var validMovement = input.distance < options.threshold;
+          var validTouchTime = input.deltaTime < options.time;
 
-      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');
+          this.reset();
 
-      function duration_get__get (units) {
-          units = normalizeUnits(units);
-          return this[units + 's']();
-      }
+          if ((input.eventType & INPUT_START) && (this.count === 0)) {
+              return this.failTimeout();
+          }
 
-      function makeGetter(name) {
-          return function () {
-              return this._data[name];
-          };
-      }
+          // we only allow little movement
+          // and we've reached an end event, so a tap is possible
+          if (validMovement && validTouchTime && validPointers) {
+              if (input.eventType != INPUT_END) {
+                  return this.failTimeout();
+              }
 
-      var duration_get__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');
+              var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
+              var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
 
-      function weeks () {
-          return absFloor(this.days() / 7);
-      }
+              this.pTime = input.timeStamp;
+              this.pCenter = input.center;
 
-      var round = Math.round;
-      var thresholds = {
-          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
-      };
+              if (!validMultiTap || !validInterval) {
+                  this.count = 1;
+              } else {
+                  this.count += 1;
+              }
 
-      // 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);
-      }
+              this._input = input;
 
-      function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
-          var duration = create__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'));
+              // if tap count matches we have recognized it,
+              // else it has began recognizing...
+              var tapCount = this.count % options.taps;
+              if (tapCount === 0) {
+                  // no failing requirements, immediately trigger the tap event
+                  // or wait as long as the multitap interval to trigger
+                  if (!this.hasRequireFailures()) {
+                      return STATE_RECOGNIZED;
+                  } else {
+                      this._timer = setTimeoutContext(function() {
+                          this.state = STATE_RECOGNIZED;
+                          this.tryEmit();
+                      }, options.interval, this);
+                      return STATE_BEGAN;
+                  }
+              }
+          }
+          return STATE_FAILED;
+      },
 
-          var a = seconds < thresholds.s && ['s', 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];
+      failTimeout: function() {
+          this._timer = setTimeoutContext(function() {
+              this.state = STATE_FAILED;
+          }, this.options.interval, this);
+          return STATE_FAILED;
+      },
 
-          a[2] = withoutSuffix;
-          a[3] = +posNegDuration > 0;
-          a[4] = locale;
-          return substituteTimeAgo.apply(null, a);
-      }
+      reset: function() {
+          clearTimeout(this._timer);
+      },
 
-      // This function allows you to set a threshold for relative time strings
-      function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
-          if (thresholds[threshold] === undefined) {
-              return false;
-          }
-          if (limit === undefined) {
-              return thresholds[threshold];
+      emit: function() {
+          if (this.state == STATE_RECOGNIZED ) {
+              this._input.tapCount = this.count;
+              this.manager.emit(this.options.event, this._input);
           }
-          thresholds[threshold] = limit;
-          return true;
       }
+  });
 
-      function humanize (withSuffix) {
-          var locale = this.localeData();
-          var output = duration_humanize__relativeTime(this, !withSuffix, locale);
-
-          if (withSuffix) {
-              output = locale.pastFuture(+this, output);
-          }
+  /**
+   * Simple way to create an manager with a default set of recognizers.
+   * @param {HTMLElement} element
+   * @param {Object} [options]
+   * @constructor
+   */
+  function Hammer(element, options) {
+      options = options || {};
+      options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
+      return new Manager(element, options);
+  }
 
-          return locale.postformat(output);
-      }
+  /**
+   * @const {string}
+   */
+  Hammer.VERSION = '2.0.4';
 
-      var iso_string__abs = Math.abs;
+  /**
+   * default settings
+   * @namespace
+   */
+  Hammer.defaults = {
+      /**
+       * set if DOM events are being triggered.
+       * But this is slower and unused by simple implementations, so disabled by default.
+       * @type {Boolean}
+       * @default false
+       */
+      domEvents: false,
 
-      function iso_string__toISOString() {
-          // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
-          var Y = iso_string__abs(this.years());
-          var M = iso_string__abs(this.months());
-          var D = iso_string__abs(this.days());
-          var h = iso_string__abs(this.hours());
-          var m = iso_string__abs(this.minutes());
-          var s = iso_string__abs(this.seconds() + this.milliseconds() / 1000);
-          var total = this.asSeconds();
+      /**
+       * The value for the touchAction property/fallback.
+       * When set to `compute` it will magically set the correct value based on the added recognizers.
+       * @type {String}
+       * @default compute
+       */
+      touchAction: TOUCH_ACTION_COMPUTE,
 
-          if (!total) {
-              // this is the same as C#'s (Noda) and python (isodate)...
-              // but not other JS (goog.date)
-              return 'P0D';
-          }
+      /**
+       * @type {Boolean}
+       * @default true
+       */
+      enable: true,
 
-          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' : '');
-      }
+      /**
+       * EXPERIMENTAL FEATURE -- can be removed/changed
+       * Change the parent input target element.
+       * If Null, then it is being set the to main element.
+       * @type {Null|EventTarget}
+       * @default null
+       */
+      inputTarget: null,
 
-      var duration_prototype__proto = Duration.prototype;
+      /**
+       * force an input class
+       * @type {Null|Function}
+       * @default null
+       */
+      inputClass: null,
 
-      duration_prototype__proto.abs            = duration_abs__abs;
-      duration_prototype__proto.add            = duration_add_subtract__add;
-      duration_prototype__proto.subtract       = duration_add_subtract__subtract;
-      duration_prototype__proto.as             = as;
-      duration_prototype__proto.asMilliseconds = asMilliseconds;
-      duration_prototype__proto.asSeconds      = asSeconds;
-      duration_prototype__proto.asMinutes      = asMinutes;
-      duration_prototype__proto.asHours        = asHours;
-      duration_prototype__proto.asDays         = asDays;
-      duration_prototype__proto.asWeeks        = asWeeks;
-      duration_prototype__proto.asMonths       = asMonths;
-      duration_prototype__proto.asYears        = asYears;
-      duration_prototype__proto.valueOf        = duration_as__valueOf;
-      duration_prototype__proto._bubble        = bubble;
-      duration_prototype__proto.get            = duration_get__get;
-      duration_prototype__proto.milliseconds   = duration_get__milliseconds;
-      duration_prototype__proto.seconds        = seconds;
-      duration_prototype__proto.minutes        = minutes;
-      duration_prototype__proto.hours          = hours;
-      duration_prototype__proto.days           = days;
-      duration_prototype__proto.weeks          = weeks;
-      duration_prototype__proto.months         = months;
-      duration_prototype__proto.years          = years;
-      duration_prototype__proto.humanize       = humanize;
-      duration_prototype__proto.toISOString    = iso_string__toISOString;
-      duration_prototype__proto.toString       = iso_string__toISOString;
-      duration_prototype__proto.toJSON         = iso_string__toISOString;
-      duration_prototype__proto.locale         = locale;
-      duration_prototype__proto.localeData     = localeData;
+      /**
+       * Default recognizer setup when calling `Hammer()`
+       * When creating a new Manager these will be skipped.
+       * @type {Array}
+       */
+      preset: [
+          // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
+          [RotateRecognizer, { enable: false }],
+          [PinchRecognizer, { enable: false }, ['rotate']],
+          [SwipeRecognizer,{ direction: DIRECTION_HORIZONTAL }],
+          [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ['swipe']],
+          [TapRecognizer],
+          [TapRecognizer, { event: 'doubletap', taps: 2 }, ['tap']],
+          [PressRecognizer]
+      ],
 
-      // Deprecations
-      duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
-      duration_prototype__proto.lang = lang;
+      /**
+       * Some CSS properties can be used to improve the working of Hammer.
+       * Add them to this method and they will be set when creating a new Manager.
+       * @namespace
+       */
+      cssProps: {
+          /**
+           * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
+           * @type {String}
+           * @default 'none'
+           */
+          userSelect: 'none',
 
-      // Side effect imports
+          /**
+           * Disable the Windows Phone grippers when pressing an element.
+           * @type {String}
+           * @default 'none'
+           */
+          touchSelect: 'none',
 
-      addFormatToken('X', 0, 0, 'unix');
-      addFormatToken('x', 0, 0, 'valueOf');
+          /**
+           * Disables the default callout shown when you touch and hold a touch target.
+           * On iOS, when you touch and hold a touch target such as a link, Safari displays
+           * a callout containing information about the link. This property allows you to disable that callout.
+           * @type {String}
+           * @default 'none'
+           */
+          touchCallout: 'none',
 
-      // PARSING
+          /**
+           * Specifies whether zooming is enabled. Used by IE10>
+           * @type {String}
+           * @default 'none'
+           */
+          contentZooming: 'none',
 
-      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));
-      });
+          /**
+           * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
+           * @type {String}
+           * @default 'none'
+           */
+          userDrag: 'none',
 
-      // Side effect imports
+          /**
+           * Overrides the highlight color shown when the user taps a link or a JavaScript
+           * clickable element in iOS. This property obeys the alpha value, if specified.
+           * @type {String}
+           * @default 'rgba(0,0,0,0)'
+           */
+          tapHighlightColor: 'rgba(0,0,0,0)'
+      }
+  };
 
+  var STOP = 1;
+  var FORCED_STOP = 2;
 
-      utils_hooks__hooks.version = '2.10.2';
+  /**
+   * Manager
+   * @param {HTMLElement} element
+   * @param {Object} [options]
+   * @constructor
+   */
+  function Manager(element, options) {
+      options = options || {};
 
-      setHookCallback(local__createLocal);
+      this.options = merge(options, Hammer.defaults);
+      this.options.inputTarget = this.options.inputTarget || element;
 
-      utils_hooks__hooks.fn                    = momentPrototype;
-      utils_hooks__hooks.min                   = min;
-      utils_hooks__hooks.max                   = max;
-      utils_hooks__hooks.utc                   = create_utc__createUTC;
-      utils_hooks__hooks.unix                  = moment__createUnix;
-      utils_hooks__hooks.months                = lists__listMonths;
-      utils_hooks__hooks.isDate                = isDate;
-      utils_hooks__hooks.locale                = locale_locales__getSetGlobalLocale;
-      utils_hooks__hooks.invalid               = valid__createInvalid;
-      utils_hooks__hooks.duration              = create__createDuration;
-      utils_hooks__hooks.isMoment              = isMoment;
-      utils_hooks__hooks.weekdays              = lists__listWeekdays;
-      utils_hooks__hooks.parseZone             = moment__createInZone;
-      utils_hooks__hooks.localeData            = locale_locales__getLocale;
-      utils_hooks__hooks.isDuration            = isDuration;
-      utils_hooks__hooks.monthsShort           = lists__listMonthsShort;
-      utils_hooks__hooks.weekdaysMin           = lists__listWeekdaysMin;
-      utils_hooks__hooks.defineLocale          = defineLocale;
-      utils_hooks__hooks.weekdaysShort         = lists__listWeekdaysShort;
-      utils_hooks__hooks.normalizeUnits        = normalizeUnits;
-      utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
+      this.handlers = {};
+      this.session = {};
+      this.recognizers = [];
 
-      var _moment = utils_hooks__hooks;
+      this.element = element;
+      this.input = createInputInstance(this);
+      this.touchAction = new TouchAction(this, this.options.touchAction);
 
-      return _moment;
+      toggleCssProps(this, true);
 
-  }));
-  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(108)(module)))
+      each(options.recognizers, function(item) {
+          var recognizer = this.add(new (item[0])(item[1]));
+          item[2] && recognizer.recognizeWith(item[2]);
+          item[3] && recognizer.requireFailure(item[3]);
+      }, this);
+  }
 
-/***/ },
-/* 72 */
-/***/ function(module, exports, __webpack_require__) {
+  Manager.prototype = {
+      /**
+       * set options
+       * @param {Object} options
+       * @returns {Manager}
+       */
+      set: function(options) {
+          extend(this.options, options);
 
-  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';
+          // Options that need a little more setup
+          if (options.touchAction) {
+              this.touchAction.update();
+          }
+          if (options.inputTarget) {
+              // Clean up existing event listeners and reinitialize
+              this.input.destroy();
+              this.input.target = options.inputTarget;
+              this.input.init();
+          }
+          return this;
+      },
 
-  (function (factory) {
-    if (true) {
-      // AMD. Register as an anonymous module.
-      !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-    } else if (typeof exports === 'object') {
-      // Node. Does not work with strict CommonJS, but
-      // only CommonJS-like environments that support module.exports,
-      // like Node.
-      module.exports = factory();
-    } else {
-      // Browser globals (root is window)
-      window.propagating = factory();
-    }
-  }(function () {
-    var _firstTarget = null; // singleton, will contain the target element where the touch event started
-    var _processing = false; // singleton, true when a touch event is being handled
+      /**
+       * stop recognizing for this session.
+       * This session will be discarded, when a new [input]start event is fired.
+       * When forced, the recognizer cycle is stopped immediately.
+       * @param {Boolean} [force]
+       */
+      stop: function(force) {
+          this.session.stopped = force ? FORCED_STOP : STOP;
+      },
 
-    /**
-     * Extend an Hammer.js instance with event propagation.
-     *
-     * Features:
-     * - Events emitted by hammer will propagate in order from child to parent
-     *   elements.
-     * - Events are extended with a function `event.stopPropagation()` to stop
-     *   propagation to parent elements.
-     * - An option `preventDefault` to stop all default browser behavior.
-     *
-     * Usage:
-     *   var hammer = propagatingHammer(new Hammer(element));
-     *   var hammer = propagatingHammer(new Hammer(element), {preventDefault: true});
-     *
-     * @param {Hammer.Manager} hammer   An hammer instance.
-     * @param {Object} [options]        Available options:
-     *                                  - `preventDefault: true | 'mouse' | 'touch' | 'pen'`.
-     *                                    Enforce preventing the default browser behavior.
-     *                                    Cannot be set to `false`.
-     * @return {Hammer.Manager} Returns the same hammer instance with extended
-     *                          functionality
-     */
-    return function propagating(hammer, options) {
-      if (options && options.preventDefault === false) {
-        throw new Error('Only supports preventDefault == true');
-      }
-      var _options = options || {
-        preventDefault: false
-      };
+      /**
+       * run the recognizers!
+       * called by the inputHandler function on every movement of the pointers (touches)
+       * it walks through all the recognizers and tries to detect the gesture that is being made
+       * @param {Object} inputData
+       */
+      recognize: function(inputData) {
+          var session = this.session;
+          if (session.stopped) {
+              return;
+          }
 
-      if (hammer.Manager) {
-        // This looks like the Hammer constructor.
-        // Overload the constructors with our own.
-        var Hammer = hammer;
+          // run the touch-action polyfill
+          this.touchAction.preventDefaults(inputData);
 
-        var PropagatingHammer = function(element, options) {
-          return propagating(new Hammer(element, options), _options);
-        };
-        Hammer.extend(PropagatingHammer, Hammer);
-        PropagatingHammer.Manager = function (element, options) {
-          return propagating(new Hammer.Manager(element, options), _options);
-        };
+          var recognizer;
+          var recognizers = this.recognizers;
 
-        return PropagatingHammer;
-      }
+          // this holds the recognizer that is being recognized.
+          // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
+          // if no recognizer is detecting a thing, it is set to `null`
+          var curRecognizer = session.curRecognizer;
 
-      // attach to DOM element
-      var element = hammer.element;
-      element.hammer = hammer;
+          // reset when the last recognizer is recognized
+          // or when we're in a new session
+          if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
+              curRecognizer = session.curRecognizer = null;
+          }
 
-      // move the original functions that we will wrap
-      hammer._on = hammer.on;
-      hammer._off = hammer.off;
-      hammer._emit = hammer.emit;
-      hammer._destroy = hammer.destroy;
+          var i = 0;
+          while (i < recognizers.length) {
+              recognizer = recognizers[i];
 
-      /** @type {Object.<String, Array.<function>>} */
-      hammer._handlers = {};
+              // find out if we are allowed try to recognize the input for this one.
+              // 1.   allow if the session is NOT forced stopped (see the .stop() method)
+              // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
+              //      that is being recognized.
+              // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
+              //      this can be setup with the `recognizeWith()` method on the recognizer.
+              if (session.stopped !== FORCED_STOP && ( // 1
+                      !curRecognizer || recognizer == curRecognizer || // 2
+                      recognizer.canRecognizeWith(curRecognizer))) { // 3
+                  recognizer.recognize(inputData);
+              } else {
+                  recognizer.reset();
+              }
 
-      // register an event to catch the start of a gesture and store the
-      // target in a singleton
-      hammer._on('hammer.input', function (event) {
-        if (_options.preventDefault === true || (_options.preventDefault === event.pointerType)) {
-          event.preventDefault();
-        }
-        if (event.isFirst) {
-          _firstTarget = event.target;
-          _processing = true;
-        }
-        if (event.isFinal) {
-          _processing = false;
-        }
-      });
+              // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
+              // current active recognizer. but only if we don't already have an active recognizer
+              if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
+                  curRecognizer = session.curRecognizer = recognizer;
+              }
+              i++;
+          }
+      },
 
       /**
-       * Register a handler for one or multiple events
-       * @param {String} events    A space separated string with events
-       * @param {function} handler A callback function, called as handler(event)
-       * @returns {Hammer.Manager} Returns the hammer instance
+       * get a recognizer by its event name.
+       * @param {Recognizer|String} recognizer
+       * @returns {Recognizer|Null}
        */
-      hammer.on = function (events, handler) {
-        // register the handler
-        split(events).forEach(function (event) {
-          var _handlers = hammer._handlers[event];
-          if (!_handlers) {
-            hammer._handlers[event] = _handlers = [];
-
-            // register the static, propagated handler
-            hammer._on(event, propagatedHandler);
+      get: function(recognizer) {
+          if (recognizer instanceof Recognizer) {
+              return recognizer;
           }
-          _handlers.push(handler);
-        });
 
-        return hammer;
-      };
+          var recognizers = this.recognizers;
+          for (var i = 0; i < recognizers.length; i++) {
+              if (recognizers[i].options.event == recognizer) {
+                  return recognizers[i];
+              }
+          }
+          return null;
+      },
 
       /**
-       * Unregister a handler for one or multiple events
-       * @param {String} events      A space separated string with events
-       * @param {function} [handler] Optional. The registered handler. If not
-       *                             provided, all handlers for given events
-       *                             are removed.
-       * @returns {Hammer.Manager}   Returns the hammer instance
+       * add a recognizer to the manager
+       * existing recognizers with the same event name will be removed
+       * @param {Recognizer} recognizer
+       * @returns {Recognizer|Manager}
        */
-      hammer.off = function (events, handler) {
-        // unregister the handler
-        split(events).forEach(function (event) {
-          var _handlers = hammer._handlers[event];
-          if (_handlers) {
-            _handlers = handler ? _handlers.filter(function (h) {
-              return h !== handler;
-            }) : [];
+      add: function(recognizer) {
+          if (invokeArrayArg(recognizer, 'add', this)) {
+              return this;
+          }
 
-            if (_handlers.length > 0) {
-              hammer._handlers[event] = _handlers;
-            }
-            else {
-              // remove static, propagated handler
-              hammer._off(event, propagatedHandler);
-              delete hammer._handlers[event];
-            }
+          // remove existing
+          var existing = this.get(recognizer.options.event);
+          if (existing) {
+              this.remove(existing);
           }
-        });
 
-        return hammer;
-      };
+          this.recognizers.push(recognizer);
+          recognizer.manager = this;
+
+          this.touchAction.update();
+          return recognizer;
+      },
 
       /**
-       * Emit to the event listeners
-       * @param {string} eventType
-       * @param {Event} event
+       * remove a recognizer by name or instance
+       * @param {Recognizer|String} recognizer
+       * @returns {Manager}
        */
-      hammer.emit = function(eventType, event) {
-        if (!_processing) {
-          _firstTarget = event.target;
-        }
-        hammer._emit(eventType, event);
-      };
+      remove: function(recognizer) {
+          if (invokeArrayArg(recognizer, 'remove', this)) {
+              return this;
+          }
 
-      hammer.destroy = function () {
-        // Detach from DOM element
-        var element = hammer.element;
-        delete element.hammer;
+          var recognizers = this.recognizers;
+          recognizer = this.get(recognizer);
+          recognizers.splice(inArray(recognizers, recognizer), 1);
 
-        // clear all handlers
-        hammer._handlers = {};
+          this.touchAction.update();
+          return this;
+      },
 
-        // call original hammer destroy
-        hammer._destroy();
-      };
+      /**
+       * bind event
+       * @param {String} events
+       * @param {Function} handler
+       * @returns {EventEmitter} this
+       */
+      on: function(events, handler) {
+          var handlers = this.handlers;
+          each(splitStr(events), function(event) {
+              handlers[event] = handlers[event] || [];
+              handlers[event].push(handler);
+          });
+          return this;
+      },
 
-      // split a string with space separated words
-      function split(events) {
-        return events.match(/[^ ]+/g);
-      }
+      /**
+       * unbind event, leave emit blank to remove all handlers
+       * @param {String} events
+       * @param {Function} [handler]
+       * @returns {EventEmitter} this
+       */
+      off: function(events, handler) {
+          var handlers = this.handlers;
+          each(splitStr(events), function(event) {
+              if (!handler) {
+                  delete handlers[event];
+              } else {
+                  handlers[event].splice(inArray(handlers[event], handler), 1);
+              }
+          });
+          return this;
+      },
 
       /**
-       * A static event handler, applying event propagation.
-       * @param {Object} event
+       * emit event to the listeners
+       * @param {String} event
+       * @param {Object} data
        */
-      function propagatedHandler(event) {
-        // let only a single hammer instance handle this event
-        if (event.type !== 'hammer.input') {
-          // it is possible that the same srcEvent is used with multiple hammer events,
-          // we keep track on which events are handled in an object _handled
-          if (!event.srcEvent._handled) {
-            event.srcEvent._handled = {};
+      emit: function(event, data) {
+          // we also want to trigger dom events
+          if (this.options.domEvents) {
+              triggerDomEvent(event, data);
           }
 
-          if (event.srcEvent._handled[event.type]) {
-            return;
-          }
-          else {
-            event.srcEvent._handled[event.type] = true;
+          // no handlers, so skip it all
+          var handlers = this.handlers[event] && this.handlers[event].slice();
+          if (!handlers || !handlers.length) {
+              return;
           }
-        }
 
-        // attach a stopPropagation function to the event
-        var stopped = false;
-        event.stopPropagation = function () {
-          stopped = true;
-        };
-
-        // attach firstTarget property to the event
-        event.firstTarget = _firstTarget;
+          data.type = event;
+          data.preventDefault = function() {
+              data.srcEvent.preventDefault();
+          };
 
-        // propagate over all elements (until stopped)
-        var elem = _firstTarget;
-        while (elem && !stopped) {
-          var _handlers = elem.hammer && elem.hammer._handlers[event.type];
-          if (_handlers) {
-            for (var i = 0; i < _handlers.length && !stopped; i++) {
-              _handlers[i](event);
-            }
+          var i = 0;
+          while (i < handlers.length) {
+              handlers[i](data);
+              i++;
           }
+      },
 
-          elem = elem.parentNode;
-        }
+      /**
+       * destroy the manager and unbinds all events
+       * it doesn't unbind dom events, that is the user own responsibility
+       */
+      destroy: function() {
+          this.element && toggleCssProps(this, false);
+
+          this.handlers = {};
+          this.session = {};
+          this.input.destroy();
+          this.element = null;
       }
+  };
 
-      return hammer;
-    };
-  }));
+  /**
+   * add/remove the css properties as defined in manager.options.cssProps
+   * @param {Manager} manager
+   * @param {Boolean} add
+   */
+  function toggleCssProps(manager, add) {
+      var element = manager.element;
+      each(manager.options.cssProps, function(value, name) {
+          element.style[prefixed(element.style, name)] = add ? value : '';
+      });
+  }
+
+  /**
+   * trigger dom event
+   * @param {String} event
+   * @param {Object} data
+   */
+  function triggerDomEvent(event, data) {
+      var gestureEvent = document.createEvent('Event');
+      gestureEvent.initEvent(event, true, true);
+      gestureEvent.gesture = data;
+      data.target.dispatchEvent(gestureEvent);
+  }
+
+  extend(Hammer, {
+      INPUT_START: INPUT_START,
+      INPUT_MOVE: INPUT_MOVE,
+      INPUT_END: INPUT_END,
+      INPUT_CANCEL: INPUT_CANCEL,
+
+      STATE_POSSIBLE: STATE_POSSIBLE,
+      STATE_BEGAN: STATE_BEGAN,
+      STATE_CHANGED: STATE_CHANGED,
+      STATE_ENDED: STATE_ENDED,
+      STATE_RECOGNIZED: STATE_RECOGNIZED,
+      STATE_CANCELLED: STATE_CANCELLED,
+      STATE_FAILED: STATE_FAILED,
+
+      DIRECTION_NONE: DIRECTION_NONE,
+      DIRECTION_LEFT: DIRECTION_LEFT,
+      DIRECTION_RIGHT: DIRECTION_RIGHT,
+      DIRECTION_UP: DIRECTION_UP,
+      DIRECTION_DOWN: DIRECTION_DOWN,
+      DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
+      DIRECTION_VERTICAL: DIRECTION_VERTICAL,
+      DIRECTION_ALL: DIRECTION_ALL,
+
+      Manager: Manager,
+      Input: Input,
+      TouchAction: TouchAction,
+
+      TouchInput: TouchInput,
+      MouseInput: MouseInput,
+      PointerEventInput: PointerEventInput,
+      TouchMouseInput: TouchMouseInput,
+      SingleTouchInput: SingleTouchInput,
+
+      Recognizer: Recognizer,
+      AttrRecognizer: AttrRecognizer,
+      Tap: TapRecognizer,
+      Pan: PanRecognizer,
+      Swipe: SwipeRecognizer,
+      Pinch: PinchRecognizer,
+      Rotate: RotateRecognizer,
+      Press: PressRecognizer,
+
+      on: addEventListeners,
+      off: removeEventListeners,
+      each: each,
+      merge: merge,
+      extend: extend,
+      inherit: inherit,
+      bindFn: bindFn,
+      prefixed: prefixed
+  });
+
+  if ("function" == TYPE_FUNCTION && __webpack_require__(91)) {
+      !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
+          return Hammer;
+      }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  } else if (typeof module != 'undefined' && module.exports) {
+      module.exports = Hammer;
+  } else {
+      window[exportName] = Hammer;
+  }
+
+  })(window, document, 'Hammer');
 
 
 /***/ },
@@ -33924,7 +33923,7 @@ return /******/ (function(modules) { // webpackBootstrap
   function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
 
   var Hammer = __webpack_require__(41);
-  var hammerUtil = __webpack_require__(48);
+  var hammerUtil = __webpack_require__(49);
   var util = __webpack_require__(1);
 
   var ColorPicker = (function () {
@@ -34509,63 +34508,63 @@ return /******/ (function(modules) { // webpackBootstrap
 
   var _sharedLabel2 = _interopRequireDefault(_sharedLabel);
 
-  var _nodesShapesBox = __webpack_require__(90);
+  var _nodesShapesBox = __webpack_require__(92);
 
   var _nodesShapesBox2 = _interopRequireDefault(_nodesShapesBox);
 
-  var _nodesShapesCircle = __webpack_require__(91);
+  var _nodesShapesCircle = __webpack_require__(93);
 
   var _nodesShapesCircle2 = _interopRequireDefault(_nodesShapesCircle);
 
-  var _nodesShapesCircularImage = __webpack_require__(92);
+  var _nodesShapesCircularImage = __webpack_require__(94);
 
   var _nodesShapesCircularImage2 = _interopRequireDefault(_nodesShapesCircularImage);
 
-  var _nodesShapesDatabase = __webpack_require__(93);
+  var _nodesShapesDatabase = __webpack_require__(95);
 
   var _nodesShapesDatabase2 = _interopRequireDefault(_nodesShapesDatabase);
 
-  var _nodesShapesDiamond = __webpack_require__(94);
+  var _nodesShapesDiamond = __webpack_require__(96);
 
   var _nodesShapesDiamond2 = _interopRequireDefault(_nodesShapesDiamond);
 
-  var _nodesShapesDot = __webpack_require__(95);
+  var _nodesShapesDot = __webpack_require__(97);
 
   var _nodesShapesDot2 = _interopRequireDefault(_nodesShapesDot);
 
-  var _nodesShapesEllipse = __webpack_require__(96);
+  var _nodesShapesEllipse = __webpack_require__(98);
 
   var _nodesShapesEllipse2 = _interopRequireDefault(_nodesShapesEllipse);
 
-  var _nodesShapesIcon = __webpack_require__(97);
+  var _nodesShapesIcon = __webpack_require__(99);
 
   var _nodesShapesIcon2 = _interopRequireDefault(_nodesShapesIcon);
 
-  var _nodesShapesImage = __webpack_require__(98);
+  var _nodesShapesImage = __webpack_require__(100);
 
   var _nodesShapesImage2 = _interopRequireDefault(_nodesShapesImage);
 
-  var _nodesShapesSquare = __webpack_require__(99);
+  var _nodesShapesSquare = __webpack_require__(101);
 
   var _nodesShapesSquare2 = _interopRequireDefault(_nodesShapesSquare);
 
-  var _nodesShapesStar = __webpack_require__(100);
+  var _nodesShapesStar = __webpack_require__(102);
 
   var _nodesShapesStar2 = _interopRequireDefault(_nodesShapesStar);
 
-  var _nodesShapesText = __webpack_require__(101);
+  var _nodesShapesText = __webpack_require__(103);
 
   var _nodesShapesText2 = _interopRequireDefault(_nodesShapesText);
 
-  var _nodesShapesTriangle = __webpack_require__(102);
+  var _nodesShapesTriangle = __webpack_require__(104);
 
   var _nodesShapesTriangle2 = _interopRequireDefault(_nodesShapesTriangle);
 
-  var _nodesShapesTriangleDown = __webpack_require__(103);
+  var _nodesShapesTriangleDown = __webpack_require__(105);
 
   var _nodesShapesTriangleDown2 = _interopRequireDefault(_nodesShapesTriangleDown);
 
-  var _sharedValidator = __webpack_require__(45);
+  var _sharedValidator = __webpack_require__(46);
 
   var _sharedValidator2 = _interopRequireDefault(_sharedValidator);
 
@@ -35328,15 +35327,15 @@ return /******/ (function(modules) { // webpackBootstrap
 
   var _sharedLabel2 = _interopRequireDefault(_sharedLabel);
 
-  var _edgesBezierEdgeDynamic = __webpack_require__(104);
+  var _edgesBezierEdgeDynamic = __webpack_require__(106);
 
   var _edgesBezierEdgeDynamic2 = _interopRequireDefault(_edgesBezierEdgeDynamic);
 
-  var _edgesBezierEdgeStatic = __webpack_require__(105);
+  var _edgesBezierEdgeStatic = __webpack_require__(107);
 
   var _edgesBezierEdgeStatic2 = _interopRequireDefault(_edgesBezierEdgeStatic);
 
-  var _edgesStraightEdge = __webpack_require__(106);
+  var _edgesStraightEdge = __webpack_require__(108);
 
   var _edgesStraightEdge2 = _interopRequireDefault(_edgesStraightEdge);
 
@@ -37023,8 +37022,8 @@ return /******/ (function(modules) { // webpackBootstrap
 
   var util = __webpack_require__(1);
   var Hammer = __webpack_require__(41);
-  var hammerUtil = __webpack_require__(48);
-  var keycharm = __webpack_require__(89);
+  var hammerUtil = __webpack_require__(49);
+  var keycharm = __webpack_require__(88);
 
   var NavigationHandler = (function () {
     function NavigationHandler(body, canvas) {
@@ -37406,19 +37405,6 @@ return /******/ (function(modules) { // webpackBootstrap
 
 /***/ },
 /* 88 */
-/***/ function(module, exports, __webpack_require__) {
-
-  function webpackContext(req) {
-  	throw new Error("Cannot find module '" + req + "'.");
-  }
-  webpackContext.keys = function() { return []; };
-  webpackContext.resolve = webpackContext;
-  module.exports = webpackContext;
-  webpackContext.id = 88;
-
-
-/***/ },
-/* 89 */
 /***/ function(module, exports, __webpack_require__) {
 
   var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;"use strict";
@@ -37615,8 +37601,45 @@ return /******/ (function(modules) { // webpackBootstrap
 
 
 
+/***/ },
+/* 89 */
+/***/ function(module, exports, __webpack_require__) {
+
+  function webpackContext(req) {
+  	throw new Error("Cannot find module '" + req + "'.");
+  }
+  webpackContext.keys = function() { return []; };
+  webpackContext.resolve = webpackContext;
+  module.exports = webpackContext;
+  webpackContext.id = 89;
+
+
 /***/ },
 /* 90 */
+/***/ function(module, exports, __webpack_require__) {
+
+  module.exports = function(module) {
+  	if(!module.webpackPolyfill) {
+  		module.deprecate = function() {};
+  		module.paths = [];
+  		// module.parent = undefined by default
+  		module.children = [];
+  		module.webpackPolyfill = 1;
+  	}
+  	return module;
+  }
+
+
+/***/ },
+/* 91 */
+/***/ function(module, exports, __webpack_require__) {
+
+  /* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;
+
+  /* WEBPACK VAR INJECTION */}.call(exports, {}))
+
+/***/ },
+/* 92 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -37724,7 +37747,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 91 */
+/* 93 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -37817,452 +37840,452 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 92 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
-
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-
-  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
-      property = _x2,
-      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
-
-  var _utilCircleImageBase = __webpack_require__(110);
-
-  var _utilCircleImageBase2 = _interopRequireDefault(_utilCircleImageBase);
-
-  'use strict';
-
-  var CircularImage = (function (_CircleImageBase) {
-    function CircularImage(options, body, labelModule, imageObj) {
-      _classCallCheck(this, CircularImage);
-
-      _get(Object.getPrototypeOf(CircularImage.prototype), 'constructor', this).call(this, options, body, labelModule);
-      this.imageObj = imageObj;
-      this._swapToImageResizeWhenImageLoaded = true;
-    }
-
-    _inherits(CircularImage, _CircleImageBase);
-
-    _createClass(CircularImage, [{
-      key: 'resize',
-      value: function resize() {
-        if (this.imageObj.src === undefined || this.imageObj.width === undefined || this.imageObj.height === undefined) {
-          if (!this.width) {
-            var diameter = this.options.size * 2;
-            this.width = diameter;
-            this.height = diameter;
-            this._swapToImageResizeWhenImageLoaded = true;
-          }
-        } else {
-          if (this._swapToImageResizeWhenImageLoaded) {
-            this.width = undefined;
-            this.height = undefined;
-            this._swapToImageResizeWhenImageLoaded = false;
-          }
-          this._resizeImage();
-        }
-      }
-    }, {
-      key: 'draw',
-      value: function draw(ctx, x, y, selected, hover) {
-        this.resize();
-
-        this.left = x - this.width / 2;
-        this.top = y - this.height / 2;
-
-        var size = Math.min(0.5 * this.height, 0.5 * this.width);
-        this._drawRawCircle(ctx, x, y, selected, hover, size);
-
-        ctx.save();
-        ctx.circle(x, y, size);
-        ctx.stroke();
-        ctx.clip();
-
-        this._drawImageAtPosition(ctx);
-
-        ctx.restore();
-
-        this._drawImageLabel(ctx, x, y, selected);
-
-        this.updateBoundingBox(x, y);
-      }
-    }, {
-      key: 'updateBoundingBox',
-      value: function updateBoundingBox(x, y) {
-        this.boundingBox.top = y - this.options.size;
-        this.boundingBox.left = x - this.options.size;
-        this.boundingBox.right = x + this.options.size;
-        this.boundingBox.bottom = y + this.options.size;
-        this.boundingBox.left = Math.min(this.boundingBox.left, this.labelModule.size.left);
-        this.boundingBox.right = Math.max(this.boundingBox.right, this.labelModule.size.left + this.labelModule.size.width);
-        this.boundingBox.bottom = Math.max(this.boundingBox.bottom, this.boundingBox.bottom + this.labelOffset);
-      }
-    }, {
-      key: 'distanceToBorder',
-      value: function distanceToBorder(ctx, angle) {
-        this.resize(ctx);
-        return this._distanceToBorder(angle);
-      }
-    }]);
-
-    return CircularImage;
-  })(_utilCircleImageBase2['default']);
-
-  exports['default'] = CircularImage;
-  module.exports = exports['default'];
-
-/***/ },
-/* 93 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
-
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-
-  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
-      property = _x2,
-      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
-
-  var _utilNodeBase = __webpack_require__(109);
-
-  var _utilNodeBase2 = _interopRequireDefault(_utilNodeBase);
-
-  'use strict';
-
-  var Database = (function (_NodeBase) {
-    function Database(options, body, labelModule) {
-      _classCallCheck(this, Database);
-
-      _get(Object.getPrototypeOf(Database.prototype), 'constructor', this).call(this, options, body, labelModule);
-    }
-
-    _inherits(Database, _NodeBase);
-
-    _createClass(Database, [{
-      key: 'resize',
-      value: function resize(ctx, selected) {
-        if (this.width === undefined) {
-          var margin = 5;
-          var textSize = this.labelModule.getTextSize(ctx, selected);
-          var size = textSize.width + 2 * margin;
-          this.width = size;
-          this.height = size;
-        }
-      }
-    }, {
-      key: 'draw',
-      value: function draw(ctx, x, y, selected, hover) {
-        this.resize(ctx, selected);
-        this.left = x - this.width / 2;
-        this.top = y - this.height / 2;
-
-        var borderWidth = this.options.borderWidth;
-        var selectionLineWidth = this.options.borderWidthSelected || 2 * this.options.borderWidth;
-
-        ctx.strokeStyle = selected ? this.options.color.highlight.border : hover ? this.options.color.hover.border : this.options.color.border;
-        ctx.lineWidth = this.selected ? selectionLineWidth : borderWidth;
-        ctx.lineWidth *= this.networkScaleInv;
-        ctx.lineWidth = Math.min(this.width, ctx.lineWidth);
-
-        ctx.fillStyle = selected ? this.options.color.highlight.background : hover ? this.options.color.hover.background : this.options.color.background;
-        ctx.database(x - this.width / 2, y - this.height * 0.5, this.width, this.height);
-
-        // draw shadow if enabled
-        this.enableShadow(ctx);
-        ctx.fill();
-
-        // disable shadows for other elements.
-        this.disableShadow(ctx);
-
-        ctx.stroke();
-
-        this.updateBoundingBox(x, y);
-
-        this.labelModule.draw(ctx, x, y, selected);
-      }
-    }, {
-      key: 'updateBoundingBox',
-      value: function updateBoundingBox(x, y) {
-        this.left = x - this.width * 0.5;
-        this.top = y - this.height * 0.5;
-
-        this.boundingBox.left = this.left;
-        this.boundingBox.top = this.top;
-        this.boundingBox.bottom = this.top + this.height;
-        this.boundingBox.right = this.left + this.width;
-      }
-    }, {
-      key: 'distanceToBorder',
-      value: function distanceToBorder(ctx, angle) {
-        this.resize(ctx);
-        var a = this.width / 2;
-        var b = this.height / 2;
-        var w = Math.sin(angle) * a;
-        var h = Math.cos(angle) * b;
-        return a * b / Math.sqrt(w * w + h * h);
-      }
-    }]);
-
-    return Database;
-  })(_utilNodeBase2['default']);
-
-  exports['default'] = Database;
-  module.exports = exports['default'];
-
-/***/ },
-/* 94 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
-
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-
-  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
-      property = _x2,
-      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
-
-  var _utilShapeBase = __webpack_require__(111);
-
-  var _utilShapeBase2 = _interopRequireDefault(_utilShapeBase);
-
-  'use strict';
-
-  var Diamond = (function (_ShapeBase) {
-    function Diamond(options, body, labelModule) {
-      _classCallCheck(this, Diamond);
-
-      _get(Object.getPrototypeOf(Diamond.prototype), 'constructor', this).call(this, options, body, labelModule);
-    }
-
-    _inherits(Diamond, _ShapeBase);
-
-    _createClass(Diamond, [{
-      key: 'resize',
-      value: function resize(ctx) {
-        this._resizeShape();
-      }
-    }, {
-      key: 'draw',
-      value: function draw(ctx, x, y, selected, hover) {
-        this._drawShape(ctx, 'diamond', 4, x, y, selected, hover);
-      }
-    }, {
-      key: 'distanceToBorder',
-      value: function distanceToBorder(ctx, angle) {
-        return this._distanceToBorder(angle);
-      }
-    }]);
-
-    return Diamond;
-  })(_utilShapeBase2['default']);
-
-  exports['default'] = Diamond;
-  module.exports = exports['default'];
-
-/***/ },
-/* 95 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
-
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-
-  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
-      property = _x2,
-      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
-
-  var _utilShapeBase = __webpack_require__(111);
-
-  var _utilShapeBase2 = _interopRequireDefault(_utilShapeBase);
-
-  'use strict';
-
-  var Dot = (function (_ShapeBase) {
-    function Dot(options, body, labelModule) {
-      _classCallCheck(this, Dot);
-
-      _get(Object.getPrototypeOf(Dot.prototype), 'constructor', this).call(this, options, body, labelModule);
-    }
-
-    _inherits(Dot, _ShapeBase);
-
-    _createClass(Dot, [{
-      key: 'resize',
-      value: function resize(ctx) {
-        this._resizeShape();
-      }
-    }, {
-      key: 'draw',
-      value: function draw(ctx, x, y, selected, hover) {
-        this._drawShape(ctx, 'circle', 2, x, y, selected, hover);
-      }
-    }, {
-      key: 'distanceToBorder',
-      value: function distanceToBorder(ctx, angle) {
-        return this.options.size + this.options.borderWidth;
-      }
-    }]);
-
-    return Dot;
-  })(_utilShapeBase2['default']);
-
-  exports['default'] = Dot;
-  module.exports = exports['default'];
-
-/***/ },
-/* 96 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
-
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-
-  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
-      property = _x2,
-      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
-
-  var _utilNodeBase = __webpack_require__(109);
-
-  var _utilNodeBase2 = _interopRequireDefault(_utilNodeBase);
-
-  'use strict';
-
-  var Ellipse = (function (_NodeBase) {
-    function Ellipse(options, body, labelModule) {
-      _classCallCheck(this, Ellipse);
-
-      _get(Object.getPrototypeOf(Ellipse.prototype), 'constructor', this).call(this, options, body, labelModule);
-    }
-
-    _inherits(Ellipse, _NodeBase);
-
-    _createClass(Ellipse, [{
-      key: 'resize',
-      value: function resize(ctx, selected) {
-        if (this.width === undefined) {
-          var textSize = this.labelModule.getTextSize(ctx, selected);
-
-          this.width = textSize.width * 1.5;
-          this.height = textSize.height * 2;
-          if (this.width < this.height) {
-            this.width = this.height;
-          }
-        }
-      }
-    }, {
-      key: 'draw',
-      value: function draw(ctx, x, y, selected, hover) {
-        this.resize(ctx, selected);
-        this.left = x - this.width * 0.5;
-        this.top = y - this.height * 0.5;
-
-        var borderWidth = this.options.borderWidth;
-        var selectionLineWidth = this.options.borderWidthSelected || 2 * this.options.borderWidth;
-
-        ctx.strokeStyle = selected ? this.options.color.highlight.border : hover ? this.options.color.hover.border : this.options.color.border;
-
-        ctx.lineWidth = selected ? selectionLineWidth : borderWidth;
-        ctx.lineWidth /= this.body.view.scale;
-        ctx.lineWidth = Math.min(this.width, ctx.lineWidth);
-
-        ctx.fillStyle = selected ? this.options.color.highlight.background : hover ? this.options.color.hover.background : this.options.color.background;
-        ctx.ellipse(this.left, this.top, this.width, this.height);
-
-        // draw shadow if enabled
-        this.enableShadow(ctx);
-        ctx.fill();
-
-        // disable shadows for other elements.
-        this.disableShadow(ctx);
-
-        ctx.stroke();
-
-        this.updateBoundingBox(x, y);
-        this.labelModule.draw(ctx, x, y, selected);
-      }
-    }, {
-      key: 'updateBoundingBox',
-      value: function updateBoundingBox(x, y) {
-        this.left = x - this.width * 0.5;
-        this.top = y - this.height * 0.5;
-
-        this.boundingBox.left = this.left;
-        this.boundingBox.top = this.top;
-        this.boundingBox.bottom = this.top + this.height;
-        this.boundingBox.right = this.left + this.width;
-      }
-    }, {
-      key: 'distanceToBorder',
-      value: function distanceToBorder(ctx, angle) {
-        this.resize(ctx);
-        var a = this.width * 0.5;
-        var b = this.height * 0.5;
-        var w = Math.sin(angle) * a;
-        var h = Math.cos(angle) * b;
-        return a * b / Math.sqrt(w * w + h * h);
-      }
-    }]);
-
-    return Ellipse;
-  })(_utilNodeBase2['default']);
-
-  exports['default'] = Ellipse;
-  module.exports = exports['default'];
-
-/***/ },
-/* 97 */
+/* 94 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
+      property = _x2,
+      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+  var _utilCircleImageBase = __webpack_require__(110);
+
+  var _utilCircleImageBase2 = _interopRequireDefault(_utilCircleImageBase);
+
+  'use strict';
+
+  var CircularImage = (function (_CircleImageBase) {
+    function CircularImage(options, body, labelModule, imageObj) {
+      _classCallCheck(this, CircularImage);
+
+      _get(Object.getPrototypeOf(CircularImage.prototype), 'constructor', this).call(this, options, body, labelModule);
+      this.imageObj = imageObj;
+      this._swapToImageResizeWhenImageLoaded = true;
+    }
+
+    _inherits(CircularImage, _CircleImageBase);
+
+    _createClass(CircularImage, [{
+      key: 'resize',
+      value: function resize() {
+        if (this.imageObj.src === undefined || this.imageObj.width === undefined || this.imageObj.height === undefined) {
+          if (!this.width) {
+            var diameter = this.options.size * 2;
+            this.width = diameter;
+            this.height = diameter;
+            this._swapToImageResizeWhenImageLoaded = true;
+          }
+        } else {
+          if (this._swapToImageResizeWhenImageLoaded) {
+            this.width = undefined;
+            this.height = undefined;
+            this._swapToImageResizeWhenImageLoaded = false;
+          }
+          this._resizeImage();
+        }
+      }
+    }, {
+      key: 'draw',
+      value: function draw(ctx, x, y, selected, hover) {
+        this.resize();
+
+        this.left = x - this.width / 2;
+        this.top = y - this.height / 2;
+
+        var size = Math.min(0.5 * this.height, 0.5 * this.width);
+        this._drawRawCircle(ctx, x, y, selected, hover, size);
+
+        ctx.save();
+        ctx.circle(x, y, size);
+        ctx.stroke();
+        ctx.clip();
+
+        this._drawImageAtPosition(ctx);
+
+        ctx.restore();
+
+        this._drawImageLabel(ctx, x, y, selected);
+
+        this.updateBoundingBox(x, y);
+      }
+    }, {
+      key: 'updateBoundingBox',
+      value: function updateBoundingBox(x, y) {
+        this.boundingBox.top = y - this.options.size;
+        this.boundingBox.left = x - this.options.size;
+        this.boundingBox.right = x + this.options.size;
+        this.boundingBox.bottom = y + this.options.size;
+        this.boundingBox.left = Math.min(this.boundingBox.left, this.labelModule.size.left);
+        this.boundingBox.right = Math.max(this.boundingBox.right, this.labelModule.size.left + this.labelModule.size.width);
+        this.boundingBox.bottom = Math.max(this.boundingBox.bottom, this.boundingBox.bottom + this.labelOffset);
+      }
+    }, {
+      key: 'distanceToBorder',
+      value: function distanceToBorder(ctx, angle) {
+        this.resize(ctx);
+        return this._distanceToBorder(angle);
+      }
+    }]);
+
+    return CircularImage;
+  })(_utilCircleImageBase2['default']);
+
+  exports['default'] = CircularImage;
+  module.exports = exports['default'];
+
+/***/ },
+/* 95 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
+      property = _x2,
+      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+  var _utilNodeBase = __webpack_require__(109);
+
+  var _utilNodeBase2 = _interopRequireDefault(_utilNodeBase);
+
+  'use strict';
+
+  var Database = (function (_NodeBase) {
+    function Database(options, body, labelModule) {
+      _classCallCheck(this, Database);
+
+      _get(Object.getPrototypeOf(Database.prototype), 'constructor', this).call(this, options, body, labelModule);
+    }
+
+    _inherits(Database, _NodeBase);
+
+    _createClass(Database, [{
+      key: 'resize',
+      value: function resize(ctx, selected) {
+        if (this.width === undefined) {
+          var margin = 5;
+          var textSize = this.labelModule.getTextSize(ctx, selected);
+          var size = textSize.width + 2 * margin;
+          this.width = size;
+          this.height = size;
+        }
+      }
+    }, {
+      key: 'draw',
+      value: function draw(ctx, x, y, selected, hover) {
+        this.resize(ctx, selected);
+        this.left = x - this.width / 2;
+        this.top = y - this.height / 2;
+
+        var borderWidth = this.options.borderWidth;
+        var selectionLineWidth = this.options.borderWidthSelected || 2 * this.options.borderWidth;
+
+        ctx.strokeStyle = selected ? this.options.color.highlight.border : hover ? this.options.color.hover.border : this.options.color.border;
+        ctx.lineWidth = this.selected ? selectionLineWidth : borderWidth;
+        ctx.lineWidth *= this.networkScaleInv;
+        ctx.lineWidth = Math.min(this.width, ctx.lineWidth);
+
+        ctx.fillStyle = selected ? this.options.color.highlight.background : hover ? this.options.color.hover.background : this.options.color.background;
+        ctx.database(x - this.width / 2, y - this.height * 0.5, this.width, this.height);
+
+        // draw shadow if enabled
+        this.enableShadow(ctx);
+        ctx.fill();
+
+        // disable shadows for other elements.
+        this.disableShadow(ctx);
+
+        ctx.stroke();
+
+        this.updateBoundingBox(x, y);
+
+        this.labelModule.draw(ctx, x, y, selected);
+      }
+    }, {
+      key: 'updateBoundingBox',
+      value: function updateBoundingBox(x, y) {
+        this.left = x - this.width * 0.5;
+        this.top = y - this.height * 0.5;
+
+        this.boundingBox.left = this.left;
+        this.boundingBox.top = this.top;
+        this.boundingBox.bottom = this.top + this.height;
+        this.boundingBox.right = this.left + this.width;
+      }
+    }, {
+      key: 'distanceToBorder',
+      value: function distanceToBorder(ctx, angle) {
+        this.resize(ctx);
+        var a = this.width / 2;
+        var b = this.height / 2;
+        var w = Math.sin(angle) * a;
+        var h = Math.cos(angle) * b;
+        return a * b / Math.sqrt(w * w + h * h);
+      }
+    }]);
+
+    return Database;
+  })(_utilNodeBase2['default']);
+
+  exports['default'] = Database;
+  module.exports = exports['default'];
+
+/***/ },
+/* 96 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
+      property = _x2,
+      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+  var _utilShapeBase = __webpack_require__(111);
+
+  var _utilShapeBase2 = _interopRequireDefault(_utilShapeBase);
+
+  'use strict';
+
+  var Diamond = (function (_ShapeBase) {
+    function Diamond(options, body, labelModule) {
+      _classCallCheck(this, Diamond);
+
+      _get(Object.getPrototypeOf(Diamond.prototype), 'constructor', this).call(this, options, body, labelModule);
+    }
+
+    _inherits(Diamond, _ShapeBase);
+
+    _createClass(Diamond, [{
+      key: 'resize',
+      value: function resize(ctx) {
+        this._resizeShape();
+      }
+    }, {
+      key: 'draw',
+      value: function draw(ctx, x, y, selected, hover) {
+        this._drawShape(ctx, 'diamond', 4, x, y, selected, hover);
+      }
+    }, {
+      key: 'distanceToBorder',
+      value: function distanceToBorder(ctx, angle) {
+        return this._distanceToBorder(angle);
+      }
+    }]);
+
+    return Diamond;
+  })(_utilShapeBase2['default']);
+
+  exports['default'] = Diamond;
+  module.exports = exports['default'];
+
+/***/ },
+/* 97 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
+      property = _x2,
+      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+  var _utilShapeBase = __webpack_require__(111);
+
+  var _utilShapeBase2 = _interopRequireDefault(_utilShapeBase);
+
+  'use strict';
+
+  var Dot = (function (_ShapeBase) {
+    function Dot(options, body, labelModule) {
+      _classCallCheck(this, Dot);
+
+      _get(Object.getPrototypeOf(Dot.prototype), 'constructor', this).call(this, options, body, labelModule);
+    }
+
+    _inherits(Dot, _ShapeBase);
+
+    _createClass(Dot, [{
+      key: 'resize',
+      value: function resize(ctx) {
+        this._resizeShape();
+      }
+    }, {
+      key: 'draw',
+      value: function draw(ctx, x, y, selected, hover) {
+        this._drawShape(ctx, 'circle', 2, x, y, selected, hover);
+      }
+    }, {
+      key: 'distanceToBorder',
+      value: function distanceToBorder(ctx, angle) {
+        return this.options.size + this.options.borderWidth;
+      }
+    }]);
+
+    return Dot;
+  })(_utilShapeBase2['default']);
+
+  exports['default'] = Dot;
+  module.exports = exports['default'];
+
+/***/ },
+/* 98 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { desc = parent = getter = undefined; _again = false; var object = _x,
+      property = _x2,
+      receiver = _x3; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+  var _utilNodeBase = __webpack_require__(109);
+
+  var _utilNodeBase2 = _interopRequireDefault(_utilNodeBase);
+
+  'use strict';
+
+  var Ellipse = (function (_NodeBase) {
+    function Ellipse(options, body, labelModule) {
+      _classCallCheck(this, Ellipse);
+
+      _get(Object.getPrototypeOf(Ellipse.prototype), 'constructor', this).call(this, options, body, labelModule);
+    }
+
+    _inherits(Ellipse, _NodeBase);
+
+    _createClass(Ellipse, [{
+      key: 'resize',
+      value: function resize(ctx, selected) {
+        if (this.width === undefined) {
+          var textSize = this.labelModule.getTextSize(ctx, selected);
+
+          this.width = textSize.width * 1.5;
+          this.height = textSize.height * 2;
+          if (this.width < this.height) {
+            this.width = this.height;
+          }
+        }
+      }
+    }, {
+      key: 'draw',
+      value: function draw(ctx, x, y, selected, hover) {
+        this.resize(ctx, selected);
+        this.left = x - this.width * 0.5;
+        this.top = y - this.height * 0.5;
+
+        var borderWidth = this.options.borderWidth;
+        var selectionLineWidth = this.options.borderWidthSelected || 2 * this.options.borderWidth;
+
+        ctx.strokeStyle = selected ? this.options.color.highlight.border : hover ? this.options.color.hover.border : this.options.color.border;
+
+        ctx.lineWidth = selected ? selectionLineWidth : borderWidth;
+        ctx.lineWidth /= this.body.view.scale;
+        ctx.lineWidth = Math.min(this.width, ctx.lineWidth);
+
+        ctx.fillStyle = selected ? this.options.color.highlight.background : hover ? this.options.color.hover.background : this.options.color.background;
+        ctx.ellipse(this.left, this.top, this.width, this.height);
+
+        // draw shadow if enabled
+        this.enableShadow(ctx);
+        ctx.fill();
+
+        // disable shadows for other elements.
+        this.disableShadow(ctx);
+
+        ctx.stroke();
+
+        this.updateBoundingBox(x, y);
+        this.labelModule.draw(ctx, x, y, selected);
+      }
+    }, {
+      key: 'updateBoundingBox',
+      value: function updateBoundingBox(x, y) {
+        this.left = x - this.width * 0.5;
+        this.top = y - this.height * 0.5;
+
+        this.boundingBox.left = this.left;
+        this.boundingBox.top = this.top;
+        this.boundingBox.bottom = this.top + this.height;
+        this.boundingBox.right = this.left + this.width;
+      }
+    }, {
+      key: 'distanceToBorder',
+      value: function distanceToBorder(ctx, angle) {
+        this.resize(ctx);
+        var a = this.width * 0.5;
+        var b = this.height * 0.5;
+        var w = Math.sin(angle) * a;
+        var h = Math.cos(angle) * b;
+        return a * b / Math.sqrt(w * w + h * h);
+      }
+    }]);
+
+    return Ellipse;
+  })(_utilNodeBase2['default']);
+
+  exports['default'] = Ellipse;
+  module.exports = exports['default'];
+
+/***/ },
+/* 99 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38381,7 +38404,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 98 */
+/* 100 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38472,7 +38495,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 99 */
+/* 101 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38533,7 +38556,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 100 */
+/* 102 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38593,7 +38616,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 101 */
+/* 103 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38681,7 +38704,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 102 */
+/* 104 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38741,7 +38764,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 103 */
+/* 105 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38801,7 +38824,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 104 */
+/* 106 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -38959,7 +38982,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 105 */
+/* 107 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -39225,7 +39248,7 @@ return /******/ (function(modules) { // webpackBootstrap
   module.exports = exports['default'];
 
 /***/ },
-/* 106 */
+/* 108 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -39336,30 +39359,6 @@ return /******/ (function(modules) { // webpackBootstrap
   exports['default'] = StraightEdge;
   module.exports = exports['default'];
 
-/***/ },
-/* 107 */
-/***/ function(module, exports, __webpack_require__) {
-
-  /* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;
-
-  /* WEBPACK VAR INJECTION */}.call(exports, {}))
-
-/***/ },
-/* 108 */
-/***/ function(module, exports, __webpack_require__) {
-
-  module.exports = function(module) {
-  	if(!module.webpackPolyfill) {
-  		module.deprecate = function() {};
-  		module.paths = [];
-  		// module.parent = undefined by default
-  		module.children = [];
-  		module.webpackPolyfill = 1;
-  	}
-  	return module;
-  }
-
-
 /***/ },
 /* 109 */
 /***/ function(module, exports, __webpack_require__) {
diff --git a/lib/timeline/component/GraphGroup.js b/lib/timeline/component/GraphGroup.js
index 4a8cfc11..3cc78c4e 100644
--- a/lib/timeline/component/GraphGroup.js
+++ b/lib/timeline/component/GraphGroup.js
@@ -168,8 +168,8 @@ GraphGroup.prototype.drawIcon = function(x, y, JSONcontainer, SVGcontainer, icon
 
     var offset = Math.round((iconWidth - (2 * barWidth))/3);
 
-    DOMutil.drawBar(x + 0.5*barWidth + offset    , y + fillHeight - bar1Height - 1, barWidth, bar1Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer);
-    DOMutil.drawBar(x + 1.5*barWidth + offset + 2, y + fillHeight - bar2Height - 1, barWidth, bar2Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer);
+    DOMutil.drawBar(x + 0.5*barWidth + offset    , y + fillHeight - bar1Height - 1, barWidth, bar1Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer, this.style);
+    DOMutil.drawBar(x + 1.5*barWidth + offset + 2, y + fillHeight - bar2Height - 1, barWidth, bar2Height, this.className + ' vis-bar', JSONcontainer, SVGcontainer, this.style);
   }
 };