initial commit

node_modules/propagating-hammerjs/HISTORY.md

@@ -0,0 +1,94 @@
+# History
+
+## 2020-10-14, version 1.5.0
+
+- Add ESM support. Thanks @mojoaxel.
+
+
+## 2019-07-27, version 1.4.7
+
+- Upgraded to `hammerjs@2.0.8`. Thanks @mojoaxel.
+
+
+## 2016-03-05, version 1.4.6
+
+- Fixed #6: stopPropagation not binding to the original event.
+
+
+## 2016-01-13, version 1.4.5
+
+- Made `propagating-hammerjs` more robust against removing/attaching a DOM
+  element in the DOM whilst executing a touch event of the DOM element itself.
+
+
+## 2016-01-04, version 1.4.4
+
+- Upgraded to Hammer.js v2.0.6.
+  - Replaced usage of `Hammer.extend` with `Hammer.assign`.
+- Fixed not working in case of multiple instances of propagating-hammerjs on
+  the same DOM element. Thanks @jsdw.
+
+
+## 2015-06-04, version 1.4.3
+
+- Fixed `dragend` events not being emitted correctly in case of multiple
+  nested handlers.
+
+
+## 2015-06-02, version 1.4.2
+
+- Fixed not being able to overload options when having overridden the global
+  Hammer instance.
+
+
+## 2015-04-20, version 1.4.1
+
+- Fixed not being able to handle both a tap and double tap.
+
+
+## 2015-04-17, version 1.4.0
+
+- Extended the option `preventDefault` with values `'mouse'`, `'touch'`,
+  and `'pen'` to prevent default behavior for a specific type of device.
+
+
+## 2015-04-14, version 1.3.0
+
+- Created an option `preventDefault` to enforce preventing the default browser
+  behavior.
+- Fixed propagation not being handled correctly when the mouse pointer is
+  being dragged outside the parent div.
+
+
+## 2015-02-09, version 1.2.2
+
+- Fixed #2, the `emit` method not working.
+
+
+## 2015-01-29, version 1.2.1
+
+- Removed using top level `this`, attaching `propagating` immediately to
+  `window instead`.
+
+
+## 2015-01-05, version 1.2.0
+
+- Added an event property `event.firstTarget`, always containing the element
+  where a gesture started.
+- Fixed the `hammer.input` event blocking the emit of real events.
+- Fixed `panend` not being emitted when `pan` was used too.
+
+
+## 2015-01-02, version 1.1.1
+
+- Fixed the module not working via commonjs.
+
+
+## 2014-12-30, version 1.1.0
+
+- Added support for applying `propagating` to the Hammer constructor.
+
+
+## 2014-12-30, version 1.0.0
+
+- Initial, fully functional release.

node_modules/propagating-hammerjs/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2020 Jos de Jong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

node_modules/propagating-hammerjs/README.md

@@ -0,0 +1,172 @@
+# propagating-hammerjs
+
+Extend [hammer.js](https://github.com/hammerjs/hammer.js) v2 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.
+- Events are extended with a property `event.firstTarget` containing the
+  element where a gesture started.
+- Supports changing and rearranging the HTML DOM on the fly.
+- Load via commonjs, AMD, or as a plain old JavaScript file.
+
+## Install
+
+```sh
+npm install propagating-hammerjs
+```
+
+## Load
+
+### Browser
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="https://unpkg.com/hammerjs@latest/hammer.js"></script>
+  <script src="https://unpkg.com/propagating-hammerjs@latest/propagating.js"></script>
+  <script>
+    function init() {
+      var hammer = propagating(new Hammer(element));
+    }
+  </script>
+</head>
+<body>
+</body>
+</html>
+```
+
+### Commonjs (e.g. Node.js, Browserify)
+
+```js
+var Hammer = require('hammerjs');
+var propagating = require('propagating-hammerjs');
+
+function init() {
+  var hammer = propagating(new Hammer(element));
+}
+```
+
+### ESM (e.g. ES6, typescript)
+
+```typescript
+import Hammer from 'hammerjs';
+import propagating from 'propagating-hammerjs';
+
+function init() {
+  const hammer = propagating(new Hammer(element));
+}
+```
+
+## Use
+
+To extend individual hammer.js instances with event propagation:
+
+```js
+var hammer = propagating(new Hammer(element));
+```
+
+To extend the global hammer.js constructor
+
+```js
+Hammer = propagating(Hammer);
+```
+
+## Examples
+
+Here a basic usage example.
+More examples are available in the folder [/examples](./examples/).
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="node_modules/hammerjs/hammer.js"></script>
+  <script src="propagating.js"></script>
+  <style>
+    div     {border: 1px solid black;}
+    #parent {width: 400px; height: 400px; background: lightgreen;}
+    #child  {width: 200px; height: 200px; background: yellow; margin: 10px;}
+  </style>
+</head>
+<body>
+
+<div id="parent">
+  parent
+  <div id="child">
+    child
+  </div>
+</div>
+
+<script>
+  var parent = document.getElementById('parent');
+  var hammer1 = propagating(new Hammer(parent))
+      .on('tap', function (event) {
+        alert('tap on parent');
+      });
+
+  var child = document.getElementById('child');
+  var hammer2 = propagating(new Hammer(child))
+      .on('tap', function (event) {
+        alert('tap on child');
+
+        // stop propagation from child to parent
+        event.stopPropagation();
+      });
+</script>
+</body>
+</html>
+```
+
+## API
+
+Construction:
+
+```typescript
+propagating(hammer: Hammer.Manager, options?: {
+  preventDefault?: true | 'mouse' | 'touch' | 'pen'
+}): Hammer.Manager
+```
+
+### parameters
+
+- `hammer: Hammer.Manager` An hammer instance or the global hammer constructor.
+
+- `options: Object` An optional object with options. Available options:
+
+  - `preventDefault: true | 'mouse' | 'touch' | 'pen'`. Optional.
+    Enforce preventing the default browser behavior. Cannot be set to `false`.
+
+### returns
+
+Returns the same hammer instance with extended functionality.
+
+### events
+
+The emitted [hammer.js events](http://hammerjs.github.io/api/#event-object) are
+extended with:
+
+- `event.stopPropagation()`
+
+  If called, the event will not further propagate the elements parents.
+
+- `event.firstTarget`
+
+  Contains the HTML element where a gesture started (where as `event.target`
+  contains the element where the pointer is right now).
+
+## Develop
+
+To generate the UMD bundle for commonjs and browser, run:
+
+```sh
+npm run build
+```
+
+## License
+
+MIT

node_modules/propagating-hammerjs/examples/basic.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Basic usage</title>
+  <script src="../node_modules/hammerjs/hammer.js"></script>
+  <script src="../propagating.js"></script>
+  <style>
+    div     {border: 1px solid black;}
+    #parent {width: 400px; height: 400px; background: lightgreen;}
+    #child  {width: 200px; height: 200px; background: yellow; margin: 10px;}
+  </style>
+</head>
+<body>
+
+<p>
+  Tap on child or parent. The child will stop propagation of the event.
+</p>
+
+<div id="parent">
+  parent
+  <div id="child">
+    child
+  </div>
+</div>
+
+<script>
+  var parent = document.getElementById('parent');
+  var hammer1 = propagating(new Hammer(parent))
+      .on('tap', function (event) {
+        alert('tap on parent');
+      });
+
+  var child = document.getElementById('child');
+  var hammer2 = propagating(new Hammer(child))
+      .on('tap', function (event) {
+        alert('tap on child');
+
+        // stop propagation from child to parent
+        event.stopPropagation();
+      });
+</script>
+</body>
+</html>

node_modules/propagating-hammerjs/examples/extensive.html

@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Extensive usage example</title>
+  <script src="../node_modules/hammerjs/hammer.js"></script>
+  <script src="../propagating.js"></script>
+  <style>
+    #parent {
+      width: 600px;
+      height: 500px;
+      background: lightyellow;
+      border: 1px solid orange;
+    }
+
+    #child1,
+    #child2 {
+      width: 400px;
+      height: 200px;
+      background: lightgreen;
+      border: 1px solid green;
+      margin: 10px;
+    }
+
+    #grandchild1,
+    #grandchild2 {
+      width: 200px;
+      height: 100px;
+      background: lightblue;
+      border: 1px solid blue;
+      margin: 10px;
+    }
+  </style>
+</head>
+<body>
+<p>Extend hammer.js with event propagation.</p>
+<ul>
+  <li>Tapping or panning <code>grandchild1</code> will propagate to <code>child1</code> and then <code>parent1</code>.</li>
+  <li>Tapping or panning <code>grandchild2</code> will propagate to <code>child2</code>, which stops propagation and does not reach <code>parent</code>.</li>
+</ul>
+<p>See output in the developer console, check the order of events.</p>
+
+<div id="parent">
+  parent
+  <div id="child1">
+    child1
+    <div id="grandchild1">
+      grandchild1
+    </div>
+  </div>
+  <div id="child2">
+    child2 (stops propagation)
+    <div id="grandchild2">
+      grandchild2
+    </div>
+  </div>
+</div>
+
+<script>
+  var parent = document.getElementById('parent');
+  var child1 = document.getElementById('child1');
+  var child2 = document.getElementById('child2');
+  var grandchild1 = document.getElementById('grandchild1');
+  var grandchild2 = document.getElementById('grandchild2');
+
+  var hammers = {};
+
+  hammers['parent'] = propagating(new Hammer(parent))
+      .on('tap', function (event) {
+        console.log('tap parent');
+      })
+      .on('pan', function (event) {
+        console.log('pan parent');
+      });
+
+  hammers['child1'] = propagating(new Hammer(child1))
+      .on('tap', function (event) {
+        console.log('tap child1');
+      })
+      .on('pan', function (event) {
+        console.log('pan child1');
+      });
+
+  hammers['grandchild1'] = propagating(new Hammer(grandchild1))
+      .on('tap', function (event) {
+        console.log('tap grandchild1');
+      })
+      .on('pan', function (event) {
+        console.log('pan grandchild1')
+      });
+
+  hammers['child2'] = propagating(new Hammer(child2))
+      .on('tap', function (event) {
+        console.log('tap child2');
+        event.stopPropagation();
+      })
+      .on('pan', function (event) {
+        console.log('pan child2');
+        event.stopPropagation();
+      });
+
+  hammers['grandchild2'] = propagating(new Hammer(grandchild2))
+      .on('tap', function (event) {
+        console.log('tap grandchild2');
+      })
+      .on('pan', function (event) {
+        console.log('pan grandchild2');
+      });
+
+//  hammerParent.on('hammer.input', function (event) {
+//        console.log('hammer.input', event);
+//      });
+
+  function destroy() {
+    Object.keys(hammers).forEach(function (name) {
+      hammers[name].destroy();
+    });
+    hammers = [];
+  }
+</script>
+</body>
+</html>

node_modules/propagating-hammerjs/examples/firstTarget.html

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Use event.firstTarget</title>
+  <script src="../node_modules/hammerjs/hammer.js"></script>
+  <script src="../propagating.js"></script>
+  <style>
+    div     {border: 1px solid black;}
+    #parent {width: 600px; height: 400px; background: lightgreen;}
+    #child  {width: 400px; height: 200px; background: yellow; margin: 10px;}
+  </style>
+</head>
+<body>
+
+<p>
+  Pan the child element, and check out <code>event.target</code> and <code>event.firstTarget</code>.
+</p>
+<ul>
+  <li id="firstTarget">First target:</li>
+  <li id="target">Target:</li>
+</ul>
+<div id="parent">
+  parent
+  <div id="child">
+    child
+  </div>
+</div>
+
+<script>
+  // replace the global Hammer constructor with a propagated one, such that
+  // hammer.js instances automatically have event propagation.
+  Hammer = propagating(Hammer, {
+    preventDefault: true
+  });
+
+  var parent = document.getElementById('parent');
+  var hammer1 = new Hammer(parent)
+      .on('pan', function (event) {
+        console.log('pan on parent', event);
+      });
+
+  var child = document.getElementById('child');
+  var hammer2 = new Hammer(child)
+      .on('pan', function (event) {
+        console.log('pan on child', event);
+
+        document.getElementById('firstTarget').innerHTML = 'First target: ' + event.firstTarget.id;
+        document.getElementById('target').innerHTML = 'Target: ' + event.target.id;
+      })
+      .on('panstart', function (event) {
+        console.log('panstart on child', event);
+      })
+      .on('panend', function (event) {
+        console.log('panend on child', event);
+      });
+</script>
+</body>
+</html>

node_modules/propagating-hammerjs/examples/global.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Replace global hammer.js constructor</title>
+  <script src="../node_modules/hammerjs/hammer.js"></script>
+  <script src="../propagating.js"></script>
+  <style>
+    div     {border: 1px solid black;}
+    #parent {width: 400px; height: 400px; background: lightgreen;}
+    #child  {width: 200px; height: 200px; background: yellow; margin: 10px;}
+  </style>
+</head>
+<body>
+
+<p>
+  Tap on child or parent. The child will stop propagation of the event.
+</p>
+
+<div id="parent">
+  parent
+  <div id="child">
+    child
+  </div>
+</div>
+
+<script>
+  // replace the global Hammer constructor with a propagated one, such that
+  // hammer.js instances automatically have event propagation.
+  Hammer = propagating(Hammer);
+
+  var parent = document.getElementById('parent');
+  var hammer1 = new Hammer(parent)
+      .on('tap', function (event) {
+        alert('tap on parent');
+      });
+
+  var child = document.getElementById('child');
+  var hammer2 = new Hammer(child)
+      .on('tap', function (event) {
+        alert('tap on child');
+
+        // stop propagation from child to parent
+        event.stopPropagation();
+      });
+</script>
+</body>
+</html>

node_modules/propagating-hammerjs/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "propagating-hammerjs",
+  "version": "1.5.0",
+  "description": "Extend hammer.js with event propagation",
+  "main": "propagating.js",
+  "module": "./src/propagating.js",
+  "files": [
+    "examples",
+    "src",
+    "HISTORY.md",
+    "LICENSE",
+    "README.md",
+    "propagating.js"
+  ],
+  "scripts": {
+    "build": "rollup ./src/propagating.js --file propagating.js --format umd --output.name propagating",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/josdejong/propagating-hammerjs.git"
+  },
+  "keywords": [
+    "hammerjs",
+    "touch",
+    "gestures",
+    "event",
+    "propagation"
+  ],
+  "author": "Jos de Jong",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/josdejong/propagating-hammerjs/issues"
+  },
+  "homepage": "https://github.com/josdejong/propagating-hammerjs",
+  "devDependencies": {
+    "rollup": "^2.29.0"
+  },
+  "dependencies": {
+    "hammerjs": "^2.0.8"
+  }
+}

node_modules/propagating-hammerjs/propagating.js

@@ -0,0 +1,224 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.propagating = factory());
+}(this, (function () { 'use strict';
+
+  var _firstTarget = null; // singleton, will contain the target element where the touch event started
+
+  /**
+   * 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 | false | '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
+   */
+  function propagating(hammer, options) {
+    var _options = options || {
+      preventDefault: false
+    };
+
+    if (hammer.Manager) {
+      // This looks like the Hammer constructor.
+      // Overload the constructors with our own.
+      var Hammer = hammer;
+
+      var PropagatingHammer = function(element, options) {
+        var o = Object.create(_options);
+        if (options) Hammer.assign(o, options);
+        return propagating(new Hammer(element, o), o);
+      };
+      Hammer.assign(PropagatingHammer, Hammer);
+
+      PropagatingHammer.Manager = function (element, options) {
+        var o = Object.create(_options);
+        if (options) Hammer.assign(o, options);
+        return propagating(new Hammer.Manager(element, o), o);
+      };
+
+      return PropagatingHammer;
+    }
+
+    // create a wrapper object which will override the functions
+    // `on`, `off`, `destroy`, and `emit` of the hammer instance
+    var wrapper = Object.create(hammer);
+
+    // attach to DOM element
+    var element = hammer.element;
+
+    if(!element.hammer) element.hammer = [];
+    element.hammer.push(wrapper);
+
+    // 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;
+      }
+    });
+
+    /** @type {Object.<String, Array.<function>>} */
+    wrapper._handlers = {};
+
+    /**
+     * 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
+     */
+    wrapper.on = function (events, handler) {
+      // register the handler
+      split(events).forEach(function (event) {
+        var _handlers = wrapper._handlers[event];
+        if (!_handlers) {
+          wrapper._handlers[event] = _handlers = [];
+
+          // register the static, propagated handler
+          hammer.on(event, propagatedHandler);
+        }
+        _handlers.push(handler);
+      });
+
+      return wrapper;
+    };
+
+    /**
+     * 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
+     */
+    wrapper.off = function (events, handler) {
+      // unregister the handler
+      split(events).forEach(function (event) {
+        var _handlers = wrapper._handlers[event];
+        if (_handlers) {
+          _handlers = handler ? _handlers.filter(function (h) {
+            return h !== handler;
+          }) : [];
+
+          if (_handlers.length > 0) {
+            wrapper._handlers[event] = _handlers;
+          }
+          else {
+            // remove static, propagated handler
+            hammer.off(event, propagatedHandler);
+            delete wrapper._handlers[event];
+          }
+        }
+      });
+
+      return wrapper;
+    };
+
+    /**
+     * Emit to the event listeners
+     * @param {string} eventType
+     * @param {Event} event
+     */
+    wrapper.emit = function(eventType, event) {
+      _firstTarget = event.target;
+      hammer.emit(eventType, event);
+    };
+
+    wrapper.destroy = function () {
+      // Detach from DOM element
+      var hammers = hammer.element.hammer;
+      var idx = hammers.indexOf(wrapper);
+      if(idx !== -1) hammers.splice(idx,1);
+      if(!hammers.length) delete hammer.element.hammer;
+
+      // clear all handlers
+      wrapper._handlers = {};
+
+      // call original hammer destroy
+      hammer.destroy();
+    };
+
+    // split a string with space separated words
+    function split(events) {
+      return events.match(/[^ ]+/g);
+    }
+
+    /**
+     * 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 = {};
+        }
+
+        if (event.srcEvent._handled[event.type]) {
+          return;
+        }
+        else {
+          event.srcEvent._handled[event.type] = true;
+        }
+      }
+
+      // attach a stopPropagation function to the event
+      var stopped = false;
+      event.stopPropagation = function () {
+        stopped = true;
+      };
+
+      //wrap the srcEvent's stopPropagation to also stop hammer propagation:
+      var srcStop = event.srcEvent.stopPropagation.bind(event.srcEvent);
+      if(typeof srcStop == "function") {
+        event.srcEvent.stopPropagation = function(){
+          srcStop();
+          event.stopPropagation();
+        };
+      }
+
+      // attach firstTarget property to the event
+      event.firstTarget = _firstTarget;
+
+      // propagate over all elements (until stopped)
+      var elem = _firstTarget;
+      while (elem && !stopped) {
+        var elemHammer = elem.hammer;
+        if(elemHammer){
+          var _handlers;
+          for(var k = 0; k < elemHammer.length; k++){
+            _handlers = elemHammer[k]._handlers[event.type];
+            if(_handlers) for (var i = 0; i < _handlers.length && !stopped; i++) {
+              _handlers[i](event);
+            }
+          }
+        }
+        elem = elem.parentNode;
+      }
+    }
+
+    return wrapper;
+  }
+
+  return propagating;
+
+})));

node_modules/propagating-hammerjs/src/propagating.js

@@ -0,0 +1,216 @@
+'use strict';
+
+var _firstTarget = null; // singleton, will contain the target element where the touch event started
+
+/**
+ * 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 | false | '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
+ */
+export default function propagating(hammer, options) {
+  var _options = options || {
+    preventDefault: false
+  };
+
+  if (hammer.Manager) {
+    // This looks like the Hammer constructor.
+    // Overload the constructors with our own.
+    var Hammer = hammer;
+
+    var PropagatingHammer = function(element, options) {
+      var o = Object.create(_options);
+      if (options) Hammer.assign(o, options);
+      return propagating(new Hammer(element, o), o);
+    };
+    Hammer.assign(PropagatingHammer, Hammer);
+
+    PropagatingHammer.Manager = function (element, options) {
+      var o = Object.create(_options);
+      if (options) Hammer.assign(o, options);
+      return propagating(new Hammer.Manager(element, o), o);
+    };
+
+    return PropagatingHammer;
+  }
+
+  // create a wrapper object which will override the functions
+  // `on`, `off`, `destroy`, and `emit` of the hammer instance
+  var wrapper = Object.create(hammer);
+
+  // attach to DOM element
+  var element = hammer.element;
+
+  if(!element.hammer) element.hammer = [];
+  element.hammer.push(wrapper);
+
+  // 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;
+    }
+  });
+
+  /** @type {Object.<String, Array.<function>>} */
+  wrapper._handlers = {};
+
+  /**
+   * 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
+   */
+  wrapper.on = function (events, handler) {
+    // register the handler
+    split(events).forEach(function (event) {
+      var _handlers = wrapper._handlers[event];
+      if (!_handlers) {
+        wrapper._handlers[event] = _handlers = [];
+
+        // register the static, propagated handler
+        hammer.on(event, propagatedHandler);
+      }
+      _handlers.push(handler);
+    });
+
+    return wrapper;
+  };
+
+  /**
+   * 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
+   */
+  wrapper.off = function (events, handler) {
+    // unregister the handler
+    split(events).forEach(function (event) {
+      var _handlers = wrapper._handlers[event];
+      if (_handlers) {
+        _handlers = handler ? _handlers.filter(function (h) {
+          return h !== handler;
+        }) : [];
+
+        if (_handlers.length > 0) {
+          wrapper._handlers[event] = _handlers;
+        }
+        else {
+          // remove static, propagated handler
+          hammer.off(event, propagatedHandler);
+          delete wrapper._handlers[event];
+        }
+      }
+    });
+
+    return wrapper;
+  };
+
+  /**
+   * Emit to the event listeners
+   * @param {string} eventType
+   * @param {Event} event
+   */
+  wrapper.emit = function(eventType, event) {
+    _firstTarget = event.target;
+    hammer.emit(eventType, event);
+  };
+
+  wrapper.destroy = function () {
+    // Detach from DOM element
+    var hammers = hammer.element.hammer;
+    var idx = hammers.indexOf(wrapper);
+    if(idx !== -1) hammers.splice(idx,1);
+    if(!hammers.length) delete hammer.element.hammer;
+
+    // clear all handlers
+    wrapper._handlers = {};
+
+    // call original hammer destroy
+    hammer.destroy();
+  };
+
+  // split a string with space separated words
+  function split(events) {
+    return events.match(/[^ ]+/g);
+  }
+
+  /**
+   * 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 = {};
+      }
+
+      if (event.srcEvent._handled[event.type]) {
+        return;
+      }
+      else {
+        event.srcEvent._handled[event.type] = true;
+      }
+    }
+
+    // attach a stopPropagation function to the event
+    var stopped = false;
+    event.stopPropagation = function () {
+      stopped = true;
+    };
+
+    //wrap the srcEvent's stopPropagation to also stop hammer propagation:
+    var srcStop = event.srcEvent.stopPropagation.bind(event.srcEvent);
+    if(typeof srcStop == "function") {
+      event.srcEvent.stopPropagation = function(){
+        srcStop();
+        event.stopPropagation();
+      };
+    }
+
+    // attach firstTarget property to the event
+    event.firstTarget = _firstTarget;
+
+    // propagate over all elements (until stopped)
+    var elem = _firstTarget;
+    while (elem && !stopped) {
+      var elemHammer = elem.hammer;
+      if(elemHammer){
+        var _handlers;
+        for(var k = 0; k < elemHammer.length; k++){
+          _handlers = elemHammer[k]._handlers[event.type];
+          if(_handlers) for (var i = 0; i < _handlers.length && !stopped; i++) {
+            _handlers[i](event);
+          }
+        }
+      }
+      elem = elem.parentNode;
+    }
+  }
+
+  return wrapper;
+};