Ajout de la flatlist de villes

2 years ago · 0720bed21c
parent 2868424314
commit 0720bed21c
1142 changed files with 85992 additions and 34845 deletions
--- a/iut-expo-starter/App.tsx
+++ b/iut-expo-starter/App.tsx
@ -1,18 +1,19 @@
 import { StatusBar } from 'expo-status-bar';
-import { StyleSheet, Text, View } from 'react-native';
+import { SafeAreaView, StyleSheet, Text, View } from 'react-native';
+import CityList from './CityList';
+import { useSafeAreaInsets, SafeAreaProvider } from 'react-native-safe-area-context';

 export default function App() {
  return (
-    <View style={styles.container}>
-      <Text>Open up App.tsx to start working on your app!</Text>
-      <StatusBar style="auto" />
-    </View>
+    <SafeAreaProvider style={styles.container}>
+      <CityList/>
+    </SafeAreaProvider>
  );
 }

 const styles = StyleSheet.create({
  container: {
-    flex: 1,
+    height: "100%",
    backgroundColor: '#fff',
    alignItems: 'center',
    justifyContent: 'center',
--- a/iut-expo-starter/CityList.tsx
+++ b/iut-expo-starter/CityList.tsx
@ -1,9 +1,28 @@
-import { View } from "react-native"
+import { View, Text, StyleSheet } from "react-native"
+import { FlatList } from "react-native-gesture-handler"
+import { CITIES_DATA, City } from "./data/stub"
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+

 export default function CityList(props: any){
-    return (
-        <View>
+    const insets = useSafeAreaInsets();
+    const statusBarHeight = insets.top;

+    return (
+        <View style={{alignItems: "center", marginTop: statusBarHeight}}>
+            <FlatList
+            data={CITIES_DATA}
+            keyExtractor={item =>item.name}
+            renderItem={({item}) => <Text>{item.name}</Text>}
+            style={{width: "100%", alignSelf: "center"}} 
+            />
        </View>
    )
 }
+
+
+const leStyle = StyleSheet.create({
+    container: {
+        alignItems: 'center',
+    },
+});
--- a/iut-expo-starter/node_modules/.bin/resolve
+++ b/iut-expo-starter/node_modules/.bin/resolve
@ -1 +0,0 @@
-../resolve/bin/resolve
--- a/iut-expo-starter/node_modules/.bin/which
+++ b/iut-expo-starter/node_modules/.bin/which
@ -1 +0,0 @@
-../which/bin/which
--- a/iut-expo-starter/node_modules/.package-lock.json
+++ b/iut-expo-starter/node_modules/.package-lock.json
--- a/iut-expo-starter/node_modules/.yarn-integrity
+++ b/iut-expo-starter/node_modules/.yarn-integrity
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/.babelrc
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/.babelrc
@ -0,0 +1,16 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "loose": true,
+        "modules": false
+      }
+    ]
+  ],
+  "plugins": [
+    "babel-plugin-no-side-effect-class-properties",
+    ["@babel/plugin-proposal-class-properties", {"loose": true}],
+    "@babel/plugin-transform-object-assign"
+  ]
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/.bowerrc
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/.bowerrc
@ -0,0 +1,3 @@
+{
+  "json": "bower.json"
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/.editorconfig
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/.editorconfig
@ -0,0 +1,20 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+
+[*.js]
+indent_style = space
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/.jscsrc
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/.jscsrc
@ -0,0 +1,10 @@
+{
+  "preset": "ember-suave",
+  "excludeFiles": [
+    "tests/**/assets",
+    "node_modules/**"
+  ],
+  "disallowConstOutsideModuleScope": false,
+  "requireArrowFunctions": true,
+  "disallowEmptyBlocks": false
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/.jshintrc
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/.jshintrc
@ -0,0 +1,42 @@
+{
+  "maxerr": 100,
+  "freeze": true,
+  "node": false,
+  "indent": 2,
+  "predef": [
+    "document",
+    "window"
+  ],
+  "browser": true,
+  "boss": true,
+  "curly": true,
+  "debug": false,
+  "devel": true,
+  "eqeqeq": true,
+  "expr": true,
+  "validthis": true,
+  "evil": true,
+  "forin": false,
+  "immed": false,
+  "laxbreak": false,
+  "newcap": true,
+  "noarg": true,
+  "node": true,
+  "noempty": false,
+  "nonew": false,
+  "nomen": false,
+  "onevar": false,
+  "plusplus": false,
+  "regexp": false,
+  "undef": true,
+  "sub": true,
+  "strict": false,
+  "white": false,
+  "eqnull": true,
+  "esversion": 6,
+  "unused": true,
+  "-W116": true,
+  "-W080": true,
+  "-W038": true,
+  "proto": true
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/.travis.yml
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/.travis.yml
@ -0,0 +1,8 @@
+language: node_js
+node_js:
+  - "6.3.0"
+
+sudo: false
+
+script:
+  - npm run test
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/CHANGELOG.md
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/CHANGELOG.md
@ -0,0 +1,66 @@
+# Changelog
+
+### 2.0.8, 2016-04-22
+
+##### Manager
+- Added check to ensure that the required parameters are present ([#908](https://github.com/hammerjs/hammer.js/issues/908), [085d3a8](https://github.com/hammer.js/hammerjs/commit/085d3a87eab8674c45e9d3a14c4ca44ad7b97e26))
+- Fixed restoration of Hammer.defaults.cssProps on destory ([#904theregttr5ki](https://github.com/hammerjs/hammer.js/issues/904), [7d0e60f](https://github.com/hammer.js/hammerjs/commit/7d0e60f6743517db3c05a38e966fb9fb5052fa03))
+
+##### Input
+- Fixed de-duping of mouse events on mouse touch combo devices ([#917](https://github.com/hammer.js/hammer.js/issues/917), [#863](https://github.com/hammerjs/hammer.js/issues/863), [bfeb89a](https://github.com/hammerjs/hammerjs/commit/bfeb89a77f778c527f771150d1e9687bd318ce8d))
+
+##### Touch-action
+- Added support map for specific values of touch-action ([#952](https://github.com/hammer.js/hammer.js/issues/952), [fbe9fd7](https://github.com/hammerjs/hammer.js/commit/fbe9fd775fe8cb3d43faa9428bfa56b61b16edc7))
+
+### 2.0.6, 2015-12-23
+- Add Assign method and deprecate merge and extend ([#895](https://github.com/hammerjs/hammer.js/pull/895)[fc01eae](https://github.com/hammerjs/hammer.js/commit/fc01eaea678acc430c664eb374555fbe3d403bdd))
+- Expose Hammer on window or self if either is defined to avoid issues when AMD is present but not used. ( [356f795](https://github.com/hammerjs/hammer.js/commit/356f7955b01f3679c29d6c45931679256b45036e))
+- Add support for PointerEvent instead of MSPointerEvent if supported. ([#754](https://github.com/hammerjs/hammer.js/issues/754), [439c7a6](https://github.com/hammerjs/hammer.js/commit/439c7a6c46978ab387b4b8289399e904d1c49535))
+- Fixed moz-prefix, prefix should be Moz not moz. ([3ea47f3](https://github.com/hammerjs/hammer.js/commit/3ea47f3aebadc9d3bb6bf52bc8402cad135ef8a9))
+- Removed non-existant recognizer ([f1c2d3b](https://github.com/hammerjs/hammer.js/commit/f1c2d3bf05f530ae092ecfc2335fceeff0e9eec9))
+- Fixed config leaking between instances([189098f](https://github.com/hammerjs/hammer.js/commit/189098ff7736f6ed2fce9a3d3e1f5a3afee085ba))
+- Fixed gaps in gesture configs and update tests to match ([70c2902](https://github.com/hammerjs/hammer.js/commit/70c2902d773a750e92ce8c423f8a4165c07eab97))
+- Fixed Manager off method ([#768](https://github.com/hammerjs/hammer.js/issues/768), [da49a27](https://github.com/hammerjs/hammer.js/commit/da49a2730779ecc3b4dd147cc418a0df7c70fad9))
+- Added compatibility with requirejs optimizer namespaces ( [70075f2](https://github.com/hammerjs/hammer.js/commit/70075f2df1b855f7c6d8d3caac49b9276b88c8d6))
+- Made touchaction test zoomable ( [50264a7](https://github.com/hammerjs/hammer.js/commit/50264a70251ca88bbaf7b666401e527eee616de5))
+- Fixed preventing default when for `pan-x pan-y` case ( [95eaafa](https://github.com/hammerjs/hammer.js/commit/95eaafadad27bd1b25d20cf976811a451922f1c4))
+- Fixed incorrect touch action pan direction ( [a81da57](https://github.com/hammerjs/hammer.js/commit/a81da57a82ebf37e695e7c443e4e2715e7f32856))
+- Fixed combined pan-x pan-y to resolve to none ( [fdae07b](https://github.com/hammerjs/hammer.js/commit/fdae07bc2ba3c90aad28da6791b3d5df627bc612))
+- Fixed inverted touch-action for pan recognizer ([#728](https://github.com/hammerjs/hammer.js/issues/728), [605bd3b](https://github.com/hammerjs/hammer.js/commit/605bd3beca780be91dd43f9da8b809d155a43d1a))
+- Fixed dependency on non standard touch list ordering ([#610](https://github.com/hammerjs/hammer.js/issues/610), [#791](https://github.com/hammerjs/hammer.js/issues/791), [287720a](https://github.com/hammerjs/hammer.js/commit/287720a6e5067e7f28be8b8b3b266d22905361c4))
+- Fixed swipe to not trigger after multitouch gesture ([#640](https://github.com/hammerjs/hammer.js/issues/640), [711d8a1](https://github.com/hammerjs/hammer.js/commit/711d8a1df1aa5057ecb536454a36257e3c0d6d91))
+- Fixed swipe recognizer to use overall gesture direction and velocity ( [963fe69](https://github.com/hammerjs/hammer.js/commit/963fe697515273fee508414bc29e2656465cea55))
+- Fixed getDirection returning reversed direction ( [e40dcde](https://github.com/hammerjs/hammer.js/commit/e40dcde43bdac7a74c8ce5c05a4f62121089cd91))
+- Fixed detection of tap when multi touch gestures are present ( [c46cbba](https://github.com/hammerjs/hammer.js/commit/c46cbba1c2cbbf874b59913416858d9dae297e64))
+- Fixed incorrect event order ([#824](https://github.com/hammerjs/hammer.js/issues/824), [92f2d76](https://github.com/hammerjs/hammer.js/commit/92f2d76188480d967e738a19cd508d0b94a31329))
+- Fixed leaking options between recognizer instances ([#813](https://github.com/hammerjs/hammer.js/issues/813), [af32c9b](https://github.com/hammerjs/hammer.js/commit/af32c9bace3f04bb34bee852ff56a33cc8fc27cd))
+- Fixed detection when element has no style attribute ( [5ca6d8c](https://github.com/hammerjs/hammer.js/commit/5ca6d8cbead02c71929a8073e95ddf98e11c0e06))
+
+### 2.0.4, 2014-09-28
+- Fix IE pointer issue. [#665](https://github.com/hammerjs/hammer.js/pull/665)
+- Fix multi-touch at different elements. [#668](https://github.com/hammerjs/hammer.js/pull/668)
+- Added experimental [single-user Touch input handler](src/input/singletouch.js). This to improve performance/ux when only a single user has to be supported. Plans are to release 2.1 with this as default, and a settings to enable the multi-user handler.
+
+### 2.0.3, 2014-09-10
+- Manager.set improvements. 
+- Fix requireFailure() call in Manager.options.recognizers. 
+- Make DIRECTION_ALL for pan and swipe gestures less blocking.
+- Fix Swipe recognizer threshold option.
+- Expose the Input classes.
+- Added the option `inputClass` to set the used input handler.
+
+### 2.0.2, 2014-07-26
+- Improved mouse and pointer-events input, now able to move outside the window.
+- Added the export name (`Hammer`) as an argument to the wrapper.
+- Add the option *experimental* `inputTarget` to change the element that receives the events.
+- Improved performance when only one touch being active.
+- Fixed the jumping deltaXY bug when going from single to multi-touch.
+- Improved velocity calculations.
+
+### 2.0.1, 2014-07-15
+- Fix issue when no document.body is available
+- Added pressup event for the press recognizer
+- Removed alternative for Object.create
+
+### 2.0.0, 2014-07-11
+- Full rewrite of the library.
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/CONTRIBUTING.md
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/CONTRIBUTING.md
@ -0,0 +1,41 @@
+# Contributing to Hammer.js
+
+Looking to contribute something to Hammer.js? **Here's how you can help.**
+
+
+## Reporting issues
+
+We only accept issues that are bug reports or feature requests. Bugs must be
+isolated and reproducible problems that can be fixed within the Hammer.js.
+Please read the following guidelines before opening any issue.
+
+1. [**Read the documentation**](https://hammerjs.github.io)
+
+2. **Search for existing issues.** We get a lot of duplicate issues, and you'd
+help us out a lot by first checking if someone else has reported the same issue.
+Moreover, the issue may have already been resolved with a fix available. Also
+take a look if your problem is explained at the Wiki.
+
+3. **Create an isolated and reproducible test case.** Be sure the problem exists
+in Hammer's code with a reduced test case that should be included in each bug
+report.
+
+4. **Include a live example.** Make use of jsFiddle or jsBin to share your
+isolated test cases. Also, a screen capture would work, with tools like LICEcap.
+
+5. **Share as much information as possible.** Include operating system and
+version, browser and version, version of Hammer.js, customized or vanilla build,
+etc. where appropriate. Also include steps to reproduce the bug.
+
+## Pull requests
+
+1. Changes must be done in `/src` files, never just the compiled files. Also, don't 
+commit the compiled files.
+
+2. Try not to pollute your pull request with unintended changes. Keep them simple
+and small
+
+3. Try to share which browsers your code has been tested in before submitting a
+pull request
+
+4. Write tests for your code, these can be found in `/tests`.
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/LICENSE.md
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/LICENSE.md
@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present NAVER Corp.
+Copyright (C) 2011-2017 by Jorik Tangelder (Eight Media)
+
+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.
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/README.md
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/README.md
@ -0,0 +1,141 @@
+# [hammer.js][hammerjs-url]  [![NPM Version][npm-image]][npm-url]  [![NPM Downloads][downloads-image]][downloads-url]  [![Build Status][travis-image]][travis-url]
+> A JavaScript library for detecting touch gestures.
+
+## What is this repository?
+
+It seems like that `hammer.js` repository is no more activated. 
+  - [Is this library still actively maintained?](https://github.com/hammerjs/hammer.js/issues/1197)
+
+But our library ([egjs](https://naver.github.io/egjs/)) has deep dependency to hammer.js for touch interaction.
+And some pending issues were critical for us to make more light size, compatible with node.js , resolve module crash on umd envrioment.
+
+So we solved following issues that are not resolved in original hammer.js
+
+* [Support for hammer.js in node.js](https://github.com/naver/hammer.js/issues/3)
+  - [Make hammerjs server friendly](https://github.com/hammerjs/hammer.js/issues/1060)
+  - [Hammer.js fails in node since window is undefined](https://github.com/hammerjs/hammer.js/issues/930)
+* [Support ES Module for Tree Shaking](https://github.com/naver/hammer.js/issues/12)
+* [Change the priority of define and exports for umd](https://github.com/naver/hammer.js/issues/11)
+* [Polymer/shadow-dom compatibility](https://github.com/naver/hammer.js/issues/21)
+
+We would maintain this repository to fix remain bugs and enhance it until original repository activates.
+
+
+## Installation
+### NPM
+```sh
+npm install --save @egjs/hammerjs
+```
+
+**or**
+
+### Yarn
+```sh
+yarn add @egjs/hammerjs
+```
+
+**or**
+
+### CDN
+[https://cdnjs.com/libraries/hammer.js/](https://cdnjs.com/libraries/hammer.js/)
+
+> We did not provide CDN yet. leave the link to original hammerjs as is.
+
+## Usage
+hammer.js has a quick start option for gestures it already recognizes.
+```js
+// Get a reference to an element.
+var square = document.querySelector('.square');
+
+// Create an instance of Hammer with the reference.
+var hammer = new Hammer(square);
+
+// Subscribe to a quick start event: press, tap, or doubletap.
+// For a full list of quick start events, read the documentation.
+hammer.on('press', function(e) {
+  e.target.classList.toggle('expand');
+  console.log("You're pressing me!");
+  console.log(e);
+});
+```
+
+If you want to recognize your own gestures, such as `tripletap`, then you'll have to use these steps:
+```js
+// Get a reference to an element.
+var square = document.querySelector('.square');
+
+// Create a manager to manage the element.
+var manager = new Hammer.Manager(square);
+
+// Create a recognizer.
+var TripleTap = new Hammer.Tap({
+  event: 'tripletap',
+  taps: 3
+});
+
+// Add the recognizer to the manager.
+manager.add(TripleTap);
+
+// Subscribe to the event.
+manager.on('tripletap', function(e) {
+  e.target.classList.toggle('expand');
+  console.log("You're triple tapping me!");
+  console.log(e);
+});
+```
+
+
+## Examples
+- [tap][tap]
+- [double tap][double-tap]
+- [press][press]
+- [swipe][swipe]
+
+
+## Documentation
+For further information regarding hammer.js, please read our [documentation][hammerjs-url].
+
+
+## Contributions  [![Github Issues][issues-image]][issues-url]  [![Github PRs][pulls-image]][pulls-url]  [![Slack][slack-image]][slack-url]
+Feel encouraged to report issues or submit pull requests. When you're ready to do either, read our [contribution guidelines][contribution-guidelines]. If you're looking for another form of contribution, we love help answering questions on our [slack channel][slack-url].
+
+
+## License
+[MIT][license]
+
+[hammerjs-url]: http://hammerjs.github.io
+[hammerjs-url]: http://hammerjs.github.io
+
+[npm-image]: https://img.shields.io/npm/v/@egjs/hammerjs.svg
+[npm-url]: https://npmjs.org/package/@egjs/hammerjs
+
+[travis-image]: https://img.shields.io/travis/stream-utils/raw-body/master.svg
+[travis-url]: https://travis-ci.org/hammerjs/hammer.js
+
+[downloads-image]: https://img.shields.io/npm/dm/@egjs/hammerjs.svg
+[downloads-url]: https://npmjs.org/package/@egjs/hammerjs
+
+
+<!-- Examples -->
+[tap]: https://codepen.io/choskim/pen/WZggmg
+[double-tap]: https://codepen.io/choskim/pen/vezzwZ
+[press]: https://codepen.io/choskim/pen/RLYebL
+[pan]: ''
+[swipe]: https://codepen.io/choskim/pen/rGZqxa
+[pinch]: ''
+[rotate]: ''
+
+
+<!-- Contributions -->
+[issues-image]: https://img.shields.io/github/issues/hammerjs/hammer.js.svg
+[issues-url]: https://github.com/hammerjs/hammer.js/issues
+
+[pulls-image]: https://img.shields.io/github/issues-pr/hammerjs/hammer.js.svg
+[pulls-url]: https://github.com/hammerjs/hammer.js/pulls
+
+[slack-image]: https://hammerjs.herokuapp.com/badge.svg
+[slack-url]: https://hammerjs.herokuapp.com/
+
+[contribution-guidelines]: ./CONTRIBUTING.md
+
+[license]: ./LICENSE.md
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/banner.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/banner.js
@ -0,0 +1,9 @@
+var pkg = require("./package.json");
+var date = new Date();
+
+module.exports = `/*! ${pkg.title || pkg.name} - v${pkg.version} - ${[ date.getFullYear(), ('0' + (date.getMonth() + 1)).slice(-2), ('0' + date.getDate()).slice(-2)].join('-')}
+ * ${pkg.homepage}
+ *
+ * Forked By Naver egjs
+ * Copyright (c) hammerjs
+ * Licensed under the ${pkg.license} license */`;
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/bower.json
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/bower.json
@ -0,0 +1,16 @@
+{
+    "name": "hammerjs",
+    "license": "MIT",
+    "main": "hammer.js",
+    "ignore": [
+        "tests",
+        "src",
+        ".bowerrc",
+        ".gitignore",
+        ".jscsrc",
+        ".jshintrc",
+        ".travis.yml",
+        "component.json",
+        "package.json"
+    ]
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/changelog.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/changelog.js
@ -0,0 +1,71 @@
+var changelog = require( "changelogplease" );
+var gittags = require( "git-tags" ).get( function( error, tags ) {
+	if ( error ) {
+		throw error
+	}
+	console.log( tags[ 2 ] + ".." + tags[ 0 ] );
+	var exclude = [ "Merge", "Whitespace", "Fixup", "Cleanup", "Formatting", "Ignore" ];
+	changelog( {
+		ticketUrl: "https://github.com/hammerjs/hammer.js/issues/{id}",
+		commitUrl: "https://github.com/hammerjs/hammerjs/commit/{id}",
+		sort: false,
+		repo: "./",
+		committish: tags[ 2 ] + ".." + tags[ 0 ]
+	}, function( error, log ) {
+		if ( error ) {
+			throw error;
+		}
+		log = parseLog( log );
+		console.log( log );
+	} );
+	function parseLog( log ) {
+		var lines = log.split( "\n" );
+		var newLog = [];
+		var log = [];
+		var currentComponent;
+
+		
+		lines.shift();
+		lines.forEach( function( line ) {
+			var newLine = parseLine( line );
+			if ( newLine ) {
+				log.push( line );
+			}
+		} );
+		var log = log.join( "\n" );
+		return log.replace( /\*/g, "-" ).replace( /__TICKETREF__,/g, "" );
+	}
+	function parseLine( line ) {
+		var parts = getParts( line );
+
+		if ( exclude.indexOf( parts.component ) > -1 ) {
+			return false;
+		}
+		return parts;
+	}
+	function getParts( line ) {
+		var parts = line.split( ":" );
+		var component = "";
+		var message;
+		var commits = line.match( /\{\{([A-Za-z0-9 ]){0,99}\}\}/ )
+
+		if ( parts.length > 1 && parts[ 0 ].length <= 20 ) {
+			component = parts[ 0 ];
+			parts.shift();
+			message = parts.join( ":" );
+		} else {
+			parts = line.split( " " );
+			component = parts[ 1 ];
+			parts.shift();
+			message = parts.join( " " );
+		}
+
+		if ( component ) {
+			component = component.replace( /\* |,/, "" );
+		}
+		return {
+			component: component,
+			message: message
+		};
+	}
+} );
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/component.json
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/component.json
@ -0,0 +1,8 @@
+{
+    "name": "hammerjs",
+    "version": "2.0.6",
+    "main": "hammer.js",
+    "scripts": [
+      "hammer.js"
+    ]
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.esm.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.esm.js
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.esm.js.map
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.esm.js.map
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.js
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.js.map
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.js.map
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.min.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.min.js
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.min.js.map
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/dist/hammer.min.js.map
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/package.json
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/package.json
@ -0,0 +1,75 @@
+{
+	"name": "@egjs/hammerjs",
+	"title": "Hammer.JS",
+	"description": "A javascript library for multi-touch gestures",
+	"version": "2.0.17",
+	"homepage": "http://naver.github.io/egjs",
+	"license": "MIT",
+	"keywords": [
+		"touch",
+		"gestures"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/naver/hammer.js.git"
+	},
+	"bugs": {
+		"url": "https://github.com/naver/hammer.js/issues"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.0.0",
+		"@babel/core": "^7.0.1",
+		"@babel/plugin-proposal-class-properties": "^7.0.0",
+		"@babel/plugin-transform-object-assign": "^7.0.0",
+		"@babel/preset-env": "^7.0.0",
+		"babel-plugin-no-side-effect-class-properties": "0.0.4",
+		"bannerize": "^1.0.2",
+		"blanket": "^1.2.3",
+		"changelogplease": "^1.2.0",
+		"ember-suave": "^4.0.0",
+		"git-tags": "^0.2.4",
+		"hammer-simulator": "git://github.com/hammerjs/simulator#master",
+		"jquery": "^3.1.0",
+		"jquery-hammerjs": "2.0.x",
+		"jscs": "^3.0.7",
+		"jshint": "^2.9.2",
+		"jshint-stylish": "^2.2.0",
+		"lodash-compat": "^3.10.2",
+		"node-qunit-phantomjs": "^1.4.0",
+		"print-sizes": "^0.1.0",
+		"qunitjs": "^2.0.0",
+		"rollup": "^0.66.0",
+		"rollup-plugin-analyzer": "^2.1.0",
+		"rollup-plugin-babel": "^4.0.3",
+		"rollup-plugin-replace": "^2.1.0",
+		"rollup-plugin-uglify": "^6.0.0",
+		"run-when-changed": "^1.2.0",
+		"serve": "^1.4.0",
+		"uglify-js": "^2.7.0"
+	},
+	"engines": {
+		"node": ">=0.8.0"
+	},
+	"scripts": {
+		"build": "npm run rollup && npm run test:node && npm run printsizes",
+		"printsizes": "print-sizes ./dist --exclude=\\.map",
+		"testbuild": "rollup -c ./testrollup.config.js",
+		"bannerize": "bannerize hammer.js hammer.min.js",
+		"connect": "serve -p 8000 ./",
+		"rollup": "rollup -c",
+		"jshint": "jshint src/**/*.js tests/unit/*.js tests/unit/gestures/*.js --config .jshintrc --verbose --reporter=node_modules/jshint-stylish",
+		"jscs": " jscs src/**/*.js tests/unit/*.js tests/unit/gestures/*.js --config=./.jscsrc",
+		"qunit": "phantomjs node_modules/qunit-phantomjs-runner/runner-list.js tests/unit/index.html 15",
+		"watch": "run-when-changed --watch 'src/**/*.js' --watch 'tests/unit/*.js' --watch 'tests/unit/gestures/*.js' --exec 'npm run watch-tasks'",
+		"watch-tasks": "npm run rollup && npm run string-replace && npm run uglify && npm run jshint && npm run jscs",
+		"test": "npm run build && npm run qunit",
+		"test:node": "node ./dist/hammer.js"
+	},
+	"sideEffects": false,
+	"module": "dist/hammer.esm.js",
+	"main": "dist/hammer.js",
+	"types": "src/hammer.d.ts",
+	"dependencies": {
+		"@types/hammerjs": "^2.0.36"
+	}
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/replace.config.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/replace.config.js
@ -0,0 +1,7 @@
+const version = require("./package.json").version;
+
+module.exports = {
+	files: "./dist/*.js",
+	from: /#__VERSION__#/g,
+	to: version,
+};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/rollup.config.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/rollup.config.js
@ -0,0 +1,65 @@
+import babel from "rollup-plugin-babel";
+import { uglify } from "rollup-plugin-uglify";
+import replace from "rollup-plugin-replace";
+
+const banner = require("./banner");
+const version = require("./package.json").version;
+const replaceVersion = replace({"#__VERSION__#": version, delimiters: ["", ""]});
+
+export default [
+	{
+		input: "src/index.js",
+		plugins: [babel({ exclude: "node_modules/**" }), replaceVersion],
+		output: {
+			banner: banner,
+			format: "es",
+			freeze: false,
+			exprots: "named",
+			interop: false,
+			sourcemap: true,
+			file: "./dist/hammer.esm.js",
+		},
+	},
+	{
+		input: "src/hammer.js",
+		plugins: [babel({ exclude: "node_modules/**" }), replaceVersion],
+		output: {
+			banner: banner,
+			format: "umd",
+			name: "Hammer",
+			exports: "default",
+			freeze: false,
+			interop: false,
+			sourcemap: true,
+			file: "./dist/hammer.js",
+		},
+	},
+	{
+		input: "src/hammer.js",
+		plugins: [babel({ exclude: "node_modules/**" }), replaceVersion, uglify({
+			sourcemap: true,
+			output: {
+				comments: function (node, comment) {
+					const text = comment.value;
+					const type = comment.type;
+
+					if (type === "comment2") {
+						// multiline comment
+						return /Naver/.test(text);
+					}
+					return false;
+				},
+			},
+		})],
+		output: {
+			banner: banner,
+			format: "umd",
+			name: "Hammer",
+			exports: "default",
+			freeze: false,
+			interop: false,
+			sourcemap: true,
+			file: "./dist/hammer.min.js",
+		},
+	},
+];
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/browser.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/browser.js
@ -0,0 +1,13 @@
+/* eslint-disable no-new-func, no-nested-ternary */
+
+let win;
+
+if (typeof window === "undefined") {
+	// window is undefined in node.js
+	win = {};
+} else {
+	win = window;
+}
+/* eslint-enable no-new-func, no-nested-ternary */
+
+export {win as window};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/defaults.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/defaults.js
@ -0,0 +1,129 @@
+import { TOUCH_ACTION_COMPUTE } from "./touchactionjs/touchaction-Consts";
+import TapRecognizer from "./recognizers/tap";
+import PanRecognizer from "./recognizers/pan";
+import SwipeRecognizer from "./recognizers/swipe";
+import PinchRecognizer from "./recognizers/pinch";
+import RotateRecognizer from "./recognizers/rotate";
+import PressRecognizer from "./recognizers/press";
+import {DIRECTION_HORIZONTAL} from "./inputjs/input-consts";
+
+export default {
+	/**
+	 * @private
+	 * 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,
+
+	/**
+	 * @private
+	 * 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,
+
+	/**
+	 * @private
+	 * @type {Boolean}
+	 * @default true
+	 */
+	enable: true,
+
+	/**
+	 * @private
+	 * 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,
+
+	/**
+	 * @private
+	 * force an input class
+	 * @type {Null|Function}
+	 * @default null
+	 */
+	inputClass: null,
+
+	/**
+	 * @private
+	 * 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: {
+		/**
+		 * @private
+		 * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
+		 * @type {String}
+		 * @default 'none'
+		 */
+		userSelect: "none",
+
+		/**
+		 * @private
+		 * Disable the Windows Phone grippers when pressing an element.
+		 * @type {String}
+		 * @default 'none'
+		 */
+		touchSelect: "none",
+
+		/**
+		 * @private
+		 * 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",
+
+		/**
+		 * @private
+		 * Specifies whether zooming is enabled. Used by IE10>
+		 * @type {String}
+		 * @default 'none'
+		 */
+		contentZooming: "none",
+
+		/**
+		 * @private
+		 * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
+		 * @type {String}
+		 * @default 'none'
+		 */
+		userDrag: "none",
+
+		/**
+		 * @private
+		 * 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)",
+	},
+};
+
+/**
+ * @private
+ * Default recognizer setup when calling `Hammer()`
+ * When creating a new Manager these will be skipped.
+ * This is separated with other defaults because of tree-shaking.
+ * @type {Array}
+ */
+export const preset = [
+  [RotateRecognizer, { enable: false }],
+  [PinchRecognizer, { enable: false }, ['rotate']],
+  [SwipeRecognizer, { direction: DIRECTION_HORIZONTAL }],
+  [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ['swipe']],
+  [TapRecognizer],
+  [TapRecognizer, { event: 'doubletap', taps: 2 }, ['tap']],
+  [PressRecognizer]
+];
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/hammer.d.ts
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/hammer.d.ts
@ -0,0 +1,50 @@
+import * as Hammer from "hammerjs";
+
+export default Hammer;
+export {
+  INPUT_START,
+	INPUT_MOVE,
+	INPUT_END,
+	INPUT_CANCEL,
+	STATE_POSSIBLE,
+	STATE_BEGAN,
+	STATE_CHANGED,
+	STATE_ENDED,
+	STATE_RECOGNIZED,
+	STATE_CANCELLED,
+	STATE_FAILED,
+
+	DIRECTION_NONE,
+	DIRECTION_LEFT,
+	DIRECTION_RIGHT,
+	DIRECTION_UP,
+	DIRECTION_DOWN,
+	DIRECTION_HORIZONTAL,
+	DIRECTION_VERTICAL,
+	DIRECTION_ALL,
+	Manager,
+	Input,
+	TouchAction,
+	TouchInput,
+	MouseInput,
+	PointerEventInput,
+	TouchMouseInput,
+	SingleTouchInput,
+	Recognizer,
+	AttrRecognizer,
+	Tap,
+	Pan,
+	Swipe,
+	Pinch,
+	Rotate,
+	Press,
+	on,
+	off,
+	each,
+	merge,
+	extend,
+	inherit,
+	bindFn,
+	prefixed,
+	defaults,
+} from "hammerjs";
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/hammer.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/hammer.js
@ -0,0 +1,136 @@
+import Manager from "./manager";
+import defaults, { preset } from "./defaults";
+import assign from './utils/assign';
+import {
+  INPUT_START,
+  INPUT_MOVE,
+  INPUT_END,
+  INPUT_CANCEL,
+  DIRECTION_NONE,
+  DIRECTION_LEFT,
+  DIRECTION_RIGHT,
+  DIRECTION_UP,
+  DIRECTION_DOWN,
+  DIRECTION_HORIZONTAL,
+  DIRECTION_VERTICAL,
+  DIRECTION_ALL,
+} from "./inputjs/input-consts";
+import {
+  STATE_POSSIBLE,
+  STATE_BEGAN,
+  STATE_CHANGED,
+  STATE_ENDED,
+  STATE_RECOGNIZED,
+  STATE_CANCELLED,
+  STATE_FAILED,
+} from "./recognizerjs/recognizer-consts";
+
+import Input from "./inputjs/input-constructor";
+import TouchAction from "./touchactionjs/touchaction-constructor";
+import TouchInput from "./input/touch";
+import MouseInput from "./input/mouse";
+import PointerEventInput from "./input/pointerevent";
+import SingleTouchInput from "./input/singletouch";
+import TouchMouseInput from "./input/touchmouse";
+
+import Recognizer from "./recognizerjs/recognizer-constructor";
+import AttrRecognizer from "./recognizers/attribute";
+import TapRecognizer from "./recognizers/tap";
+import PanRecognizer from "./recognizers/pan";
+import SwipeRecognizer from "./recognizers/swipe";
+import PinchRecognizer from "./recognizers/pinch";
+import RotateRecognizer from "./recognizers/rotate";
+import PressRecognizer from "./recognizers/press";
+
+import addEventListeners from "./utils/add-event-listeners";
+import removeEventListeners from "./utils/remove-event-listeners";
+import each from "./utils/each";
+import merge from "./utils/merge";
+import extend from "./utils/extend";
+import inherit from "./utils/inherit";
+import bindFn from "./utils/bind-fn";
+import prefixed from "./utils/prefixed";
+import toArray from "./utils/to-array";
+import uniqueArray from "./utils/unique-array";
+import splitStr from "./utils/split-str";
+import inArray from "./utils/in-array";
+import boolOrFn from "./utils/bool-or-fn";
+import hasParent from "./utils/has-parent";
+/**
+ * @private
+ * Simple way to create a manager with a default set of recognizers.
+ * @param {HTMLElement} element
+ * @param {Object} [options]
+ * @constructor
+ */
+export default class Hammer {
+	/**
+   * @private
+   * @const {string}
+   */
+	static VERSION = "#__VERSION__#";
+	static DIRECTION_ALL = DIRECTION_ALL;
+	static DIRECTION_DOWN = DIRECTION_DOWN;
+	static DIRECTION_LEFT = DIRECTION_LEFT;
+	static DIRECTION_RIGHT = DIRECTION_RIGHT;
+	static DIRECTION_UP = DIRECTION_UP;
+	static DIRECTION_HORIZONTAL = DIRECTION_HORIZONTAL;
+	static DIRECTION_VERTICAL = DIRECTION_VERTICAL;
+	static DIRECTION_NONE = DIRECTION_NONE;
+	static DIRECTION_DOWN = DIRECTION_DOWN;
+	static INPUT_START = INPUT_START;
+	static INPUT_MOVE = INPUT_MOVE;
+  static INPUT_END = INPUT_END;
+	static INPUT_CANCEL = INPUT_CANCEL;
+	static STATE_POSSIBLE = STATE_POSSIBLE;
+	static STATE_BEGAN = STATE_BEGAN;
+	static STATE_CHANGED = STATE_CHANGED;
+	static STATE_ENDED = STATE_ENDED;
+	static STATE_RECOGNIZED = STATE_RECOGNIZED;
+	static STATE_CANCELLED = STATE_CANCELLED;
+	static STATE_FAILED = STATE_FAILED;
+	static Manager = Manager;
+	static Input = Input;
+	static TouchAction = TouchAction;
+	static TouchInput = TouchInput;
+	static MouseInput = MouseInput;
+	static PointerEventInput = PointerEventInput;
+	static TouchMouseInput = TouchMouseInput;
+	static SingleTouchInput = SingleTouchInput;
+	static Recognizer = Recognizer;
+	static AttrRecognizer = AttrRecognizer;
+	static Tap = TapRecognizer;
+	static Pan = PanRecognizer;
+	static Swipe = SwipeRecognizer;
+	static Pinch = PinchRecognizer;
+	static Rotate = RotateRecognizer;
+	static Press = PressRecognizer;
+	static on = addEventListeners;
+	static off = removeEventListeners;
+	static each = each;
+	static merge = merge;
+	static extend = extend;
+	static bindFn = bindFn;
+	static assign = assign;
+	static inherit = inherit;
+	static bindFn = bindFn;
+	static prefixed = prefixed;
+	static toArray = toArray;
+	static inArray = inArray;
+	static uniqueArray = uniqueArray;
+	static splitStr = splitStr;
+	static boolOrFn = boolOrFn;
+	static hasParent = hasParent;
+	static addEventListeners = addEventListeners;
+	static removeEventListeners = removeEventListeners;
+	static defaults = assign({}, defaults, { preset });
+	constructor(element, options = {}) {
+		return new Manager(element, {
+			recognizers: [
+        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
+        ...preset
+			],
+			...options,
+		});
+	}
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/index.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/index.js
@ -0,0 +1,123 @@
+
+import Hammer from "./hammer";
+import assign from "./utils/assign";
+
+import {
+  INPUT_START,
+  INPUT_MOVE,
+  INPUT_END,
+  INPUT_CANCEL,
+  DIRECTION_NONE,
+  DIRECTION_LEFT,
+  DIRECTION_RIGHT,
+  DIRECTION_UP,
+  DIRECTION_DOWN,
+  DIRECTION_HORIZONTAL,
+  DIRECTION_VERTICAL,
+  DIRECTION_ALL,
+} from "./inputjs/input-consts";
+import {
+  STATE_POSSIBLE,
+  STATE_BEGAN,
+  STATE_CHANGED,
+  STATE_ENDED,
+  STATE_RECOGNIZED,
+  STATE_CANCELLED,
+  STATE_FAILED,
+} from "./recognizerjs/recognizer-consts";
+
+import Manager from "./manager";
+import Input from "./inputjs/input-constructor";
+import TouchAction from "./touchactionjs/touchaction-constructor";
+import TouchInput from "./input/touch";
+import MouseInput from "./input/mouse";
+import PointerEventInput from "./input/pointerevent";
+import SingleTouchInput from "./input/singletouch";
+import TouchMouseInput from "./input/touchmouse";
+
+import Recognizer from "./recognizerjs/recognizer-constructor";
+import AttrRecognizer from "./recognizers/attribute";
+import TapRecognizer from "./recognizers/tap";
+import PanRecognizer from "./recognizers/pan";
+import SwipeRecognizer from "./recognizers/swipe";
+import PinchRecognizer from "./recognizers/pinch";
+import RotateRecognizer from "./recognizers/rotate";
+import PressRecognizer from "./recognizers/press";
+
+import addEventListeners from "./utils/add-event-listeners";
+import removeEventListeners from "./utils/remove-event-listeners";
+import each from "./utils/each";
+import merge from "./utils/merge";
+import extend from "./utils/extend";
+import inherit from "./utils/inherit";
+import bindFn from "./utils/bind-fn";
+import prefixed from "./utils/prefixed";
+import toArray from "./utils/to-array";
+import uniqueArray from "./utils/unique-array";
+import splitStr from "./utils/split-str";
+import inArray from "./utils/in-array";
+import boolOrFn from "./utils/bool-or-fn";
+import hasParent from "./utils/has-parent";
+
+// this prevents errors when Hammer is loaded in the presence of an AMD
+//  style loader but by script tag, not by the loader.
+
+const defaults = Hammer.defaults;
+
+export {
+  Hammer as default,
+  INPUT_START,
+  INPUT_MOVE,
+  INPUT_END,
+  INPUT_CANCEL,
+  STATE_POSSIBLE,
+  STATE_BEGAN,
+  STATE_CHANGED,
+  STATE_ENDED,
+  STATE_RECOGNIZED,
+  STATE_CANCELLED,
+  STATE_FAILED,
+
+  DIRECTION_NONE,
+  DIRECTION_LEFT,
+  DIRECTION_RIGHT,
+  DIRECTION_UP,
+  DIRECTION_DOWN,
+  DIRECTION_HORIZONTAL,
+  DIRECTION_VERTICAL,
+  DIRECTION_ALL,
+  Manager,
+  Input,
+  TouchAction,
+  TouchInput,
+  MouseInput,
+  PointerEventInput,
+  TouchMouseInput,
+  SingleTouchInput,
+  Recognizer,
+  AttrRecognizer,
+  TapRecognizer as Tap,
+  PanRecognizer as Pan,
+  SwipeRecognizer as Swipe,
+  PinchRecognizer as Pinch,
+  RotateRecognizer as Rotate,
+  PressRecognizer as Press,
+  addEventListeners as on,
+  removeEventListeners as off,
+  each,
+  merge,
+  extend,
+  assign,
+  inherit,
+  bindFn,
+  prefixed,
+  toArray,
+  inArray,
+  uniqueArray,
+  splitStr,
+  boolOrFn,
+  hasParent,
+  addEventListeners,
+  removeEventListeners,
+  defaults,
+};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/mouse.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/mouse.js
@ -0,0 +1,67 @@
+import {
+    INPUT_START,
+    INPUT_MOVE,
+    INPUT_END,
+    INPUT_TYPE_MOUSE
+} from '../inputjs/input-consts';
+import Input from '../inputjs/input-constructor';
+
+const MOUSE_INPUT_MAP = {
+  mousedown: INPUT_START,
+  mousemove: INPUT_MOVE,
+  mouseup: INPUT_END
+};
+
+const MOUSE_ELEMENT_EVENTS = 'mousedown';
+const MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
+
+/**
+ * @private
+ * Mouse events input
+ * @constructor
+ * @extends Input
+ */
+export default class MouseInput extends Input {
+  constructor() {
+    var proto = MouseInput.prototype;
+    proto.evEl = MOUSE_ELEMENT_EVENTS;
+    proto.evWin = MOUSE_WINDOW_EVENTS;
+
+    super(...arguments);
+    this.pressed = false; // mousedown state
+  }
+
+  /**
+   * @private
+   * handle mouse events
+   * @param {Object} ev
+   */
+  handler(ev) {
+    let eventType = MOUSE_INPUT_MAP[ev.type];
+
+    // on start we want to have the left mouse button down
+    if (eventType & INPUT_START && ev.button === 0) {
+      this.pressed = true;
+    }
+
+    if (eventType & INPUT_MOVE && ev.which !== 1) {
+      eventType = INPUT_END;
+    }
+
+    // mouse must be down
+    if (!this.pressed) {
+      return;
+    }
+
+    if (eventType & INPUT_END) {
+      this.pressed = false;
+    }
+
+    this.callback(this.manager, eventType, {
+      pointers: [ev],
+      changedPointers: [ev],
+      pointerType: INPUT_TYPE_MOUSE,
+      srcEvent: ev
+    });
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/pointerevent.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/pointerevent.js
@ -0,0 +1,104 @@
+import {
+    INPUT_START,
+    INPUT_END,
+    INPUT_CANCEL,
+    INPUT_MOVE,
+    INPUT_TYPE_TOUCH,
+    INPUT_TYPE_MOUSE,
+    INPUT_TYPE_PEN,
+    INPUT_TYPE_KINECT
+} from '../inputjs/input-consts';
+import {window} from "../browser";
+import Input from '../inputjs/input-constructor';
+import inArray from '../utils/in-array';
+
+const POINTER_INPUT_MAP = {
+  pointerdown: INPUT_START,
+  pointermove: INPUT_MOVE,
+  pointerup: INPUT_END,
+  pointercancel: INPUT_CANCEL,
+  pointerout: INPUT_CANCEL
+};
+
+// in IE10 the pointer types is defined as an enum
+const 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
+};
+
+let POINTER_ELEMENT_EVENTS = 'pointerdown';
+let POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';
+
+// IE10 has prefixed support, and case-sensitive
+if (window.MSPointerEvent && !window.PointerEvent) {
+  POINTER_ELEMENT_EVENTS = 'MSPointerDown';
+  POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
+}
+
+/**
+ * @private
+ * Pointer events input
+ * @constructor
+ * @extends Input
+ */
+export default class PointerEventInput extends Input {
+  constructor() {
+    var proto = PointerEventInput.prototype;
+
+    proto.evEl = POINTER_ELEMENT_EVENTS;
+    proto.evWin = POINTER_WINDOW_EVENTS;
+    super(...arguments);
+    this.store = (this.manager.session.pointerEvents = []);
+  }
+
+  /**
+   * @private
+   * handle mouse events
+   * @param {Object} ev
+   */
+  handler(ev) {
+    let { store } = this;
+    let removePointer = false;
+
+    let eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
+    let eventType = POINTER_INPUT_MAP[eventTypeNormalized];
+    let pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
+
+    let isTouch = (pointerType === INPUT_TYPE_TOUCH);
+
+    // get index of the event in the store
+    let storeIndex = inArray(store, ev.pointerId, 'pointerId');
+
+    // 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;
+    }
+
+    // it not found, so the pointer hasn't been down (so it's probably a hover)
+    if (storeIndex < 0) {
+      return;
+    }
+
+    // update the event in the store
+    store[storeIndex] = ev;
+
+    this.callback(this.manager, eventType, {
+      pointers: store,
+      changedPointers: [ev],
+      pointerType,
+      srcEvent: ev
+    });
+
+    if (removePointer) {
+      // remove from the store
+      store.splice(storeIndex, 1);
+    }
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/singletouch.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/singletouch.js
@ -0,0 +1,82 @@
+import {
+    INPUT_START,
+    INPUT_MOVE,
+    INPUT_END,
+    INPUT_CANCEL,
+    INPUT_TYPE_TOUCH
+} from '../inputjs/input-consts';
+import Input from '../inputjs/input-constructor';
+import toArray from '../utils/to-array';
+import uniqueArray from '../utils/unique-array';
+
+const SINGLE_TOUCH_INPUT_MAP = {
+  touchstart: INPUT_START,
+  touchmove: INPUT_MOVE,
+  touchend: INPUT_END,
+  touchcancel: INPUT_CANCEL
+};
+
+const SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
+const SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
+
+/**
+ * @private
+ * Touch events input
+ * @constructor
+ * @extends Input
+ */
+export default class SingleTouchInput extends Input {
+  constructor() {
+    var proto = SingleTouchInput.prototype;
+    proto.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
+    proto.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
+
+    super(...arguments);
+    this.started = false;
+  }
+
+  handler(ev) {
+    let type = SINGLE_TOUCH_INPUT_MAP[ev.type];
+
+    // should we handle the touch events?
+    if (type === INPUT_START) {
+      this.started = true;
+    }
+
+    if (!this.started) {
+      return;
+    }
+
+    let touches = normalizeSingleTouches.call(this, ev, type);
+
+    // when done, reset the started state
+    if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
+      this.started = false;
+    }
+
+    this.callback(this.manager, type, {
+      pointers: touches[0],
+      changedPointers: touches[1],
+      pointerType: INPUT_TYPE_TOUCH,
+      srcEvent: ev
+    });
+  }
+}
+
+/**
+ * @private
+ * @this {TouchInput}
+ * @param {Object} ev
+ * @param {Number} type flag
+ * @returns {undefined|Array} [all, changed]
+ */
+function normalizeSingleTouches(ev, type) {
+  let all = toArray(ev.touches);
+  let changed = toArray(ev.changedTouches);
+
+  if (type & (INPUT_END | INPUT_CANCEL)) {
+    all = uniqueArray(all.concat(changed), 'identifier', true);
+  }
+
+  return [all, changed];
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/touch.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/touch.js
@ -0,0 +1,111 @@
+import {
+  INPUT_START,
+  INPUT_MOVE,
+  INPUT_END,
+  INPUT_CANCEL,
+  INPUT_TYPE_TOUCH
+} from '../inputjs/input-consts';
+import Input from '../inputjs/input-constructor';
+import toArray from '../utils/to-array';
+import hasParent from '../utils/has-parent';
+import uniqueArray from '../utils/unique-array';
+
+const TOUCH_INPUT_MAP = {
+  touchstart: INPUT_START,
+  touchmove: INPUT_MOVE,
+  touchend: INPUT_END,
+  touchcancel: INPUT_CANCEL
+};
+
+const TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
+
+/**
+ * @private
+ * Multi-user touch events input
+ * @constructor
+ * @extends Input
+ */
+export default class TouchInput extends Input {
+  constructor() {
+    TouchInput.prototype.evTarget = TOUCH_TARGET_EVENTS;
+    super(...arguments);
+    this.targetIds = {};
+    // this.evTarget = TOUCH_TARGET_EVENTS;
+  }
+  handler(ev) {
+    let type = TOUCH_INPUT_MAP[ev.type];
+    let touches = getTouches.call(this, ev, type);
+    if (!touches) {
+      return;
+    }
+
+    this.callback(this.manager, type, {
+      pointers: touches[0],
+      changedPointers: touches[1],
+      pointerType: INPUT_TYPE_TOUCH,
+      srcEvent: ev
+    });
+  }
+}
+
+/**
+ * @private
+ * @this {TouchInput}
+ * @param {Object} ev
+ * @param {Number} type flag
+ * @returns {undefined|Array} [all, changed]
+ */
+function getTouches(ev, type) {
+  let allTouches = toArray(ev.touches);
+  let { targetIds } = this;
+
+  // 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];
+  }
+
+  let i;
+  let targetTouches;
+  let changedTouches = toArray(ev.changedTouches);
+  let changedTargetTouches = [];
+  let { target } = this;
+
+  // get target touches from touches
+  targetTouches = allTouches.filter((touch) => {
+    return hasParent(touch.target, target);
+  });
+
+  // collect touches
+  if (type === INPUT_START) {
+    i = 0;
+    while (i < targetTouches.length) {
+      targetIds[targetTouches[i].identifier] = true;
+      i++;
+    }
+  }
+
+  // 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]);
+    }
+
+    // cleanup removed touches
+    if (type & (INPUT_END | INPUT_CANCEL)) {
+      delete targetIds[changedTouches[i].identifier];
+    }
+    i++;
+  }
+
+  if (!changedTargetTouches.length) {
+    return;
+  }
+
+  return [
+    // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
+    uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),
+    changedTargetTouches
+  ];
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/touchmouse.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/input/touchmouse.js
@ -0,0 +1,117 @@
+import Input from "../inputjs/input-constructor";
+import TouchInput from "./touch";
+import MouseInput from "./mouse";
+import {
+	INPUT_START,
+	INPUT_END,
+	INPUT_CANCEL,
+	INPUT_TYPE_TOUCH,
+	INPUT_TYPE_MOUSE,
+} from "../inputjs/input-consts";
+
+/**
+ * @private
+ * 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
+ */
+
+const DEDUP_TIMEOUT = 2500;
+const DEDUP_DISTANCE = 25;
+
+function setLastTouch(eventData) {
+	const { changedPointers: [touch] } = eventData;
+
+	if (touch.identifier === this.primaryTouch) {
+		const lastTouch = { x: touch.clientX, y: touch.clientY };
+		const lts = this.lastTouches;
+
+		this.lastTouches.push(lastTouch);
+
+
+		const removeLastTouch = function() {
+			const i = lts.indexOf(lastTouch);
+
+			if (i > -1) {
+				lts.splice(i, 1);
+			}
+		};
+
+		setTimeout(removeLastTouch, DEDUP_TIMEOUT);
+	}
+}
+
+
+function recordTouches(eventType, eventData) {
+	if (eventType & INPUT_START) {
+		this.primaryTouch = eventData.changedPointers[0].identifier;
+		setLastTouch.call(this, eventData);
+	} else if (eventType & (INPUT_END | INPUT_CANCEL)) {
+		setLastTouch.call(this, eventData);
+	}
+}
+function isSyntheticEvent(eventData) {
+	const x = eventData.srcEvent.clientX;
+	const y = eventData.srcEvent.clientY;
+
+	for (let i = 0; i < this.lastTouches.length; i++) {
+		const t = this.lastTouches[i];
+		const dx = Math.abs(x - t.x);
+		const dy = Math.abs(y - t.y);
+
+		if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
+			return true;
+		}
+	}
+	return false;
+}
+
+
+export default class TouchMouseInput extends Input {
+	constructor(manager, callback) {
+		super(manager, callback);
+
+		this.touch = new TouchInput(this.manager, this.handler);
+		this.mouse = new MouseInput(this.manager, this.handler);
+		this.primaryTouch = null;
+		this.lastTouches = [];
+	}
+
+	/**
+	 * @private
+	 * handle mouse and touch events
+	 * @param {Hammer} manager
+	 * @param {String} inputEvent
+	 * @param {Object} inputData
+	 */
+	handler = (manager, inputEvent, inputData) => {
+		const isTouch = (inputData.pointerType === INPUT_TYPE_TOUCH);
+		const isMouse = (inputData.pointerType === INPUT_TYPE_MOUSE);
+
+		if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
+			return;
+		}
+
+		// when we're in a touch event, record touches to  de-dupe synthetic mouse event
+		if (isTouch) {
+			recordTouches.call(this, inputEvent, inputData);
+		} else if (isMouse && isSyntheticEvent.call(this, inputData)) {
+			return;
+		}
+
+		this.callback(manager, inputEvent, inputData);
+	}
+
+	/**
+	 * @private
+	 * remove the event listeners
+	 */
+	destroy() {
+		this.touch.destroy();
+		this.mouse.destroy();
+	}
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/compute-delta-xy.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/compute-delta-xy.js
@ -0,0 +1,25 @@
+import { INPUT_START, INPUT_END } from './input-consts';
+
+export default function computeDeltaXY(session, input) {
+  let { center } = input;
+  // let { offsetDelta:offset = {}, prevDelta = {}, prevInput = {} } = session;
+  // jscs throwing error on defalut destructured values and without defaults tests fail
+  let offset = session.offsetDelta || {};
+  let prevDelta = session.prevDelta || {};
+  let prevInput = session.prevInput || {};
+
+  if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
+    prevDelta = session.prevDelta = {
+      x: prevInput.deltaX || 0,
+      y: prevInput.deltaY || 0
+    };
+
+    offset = session.offsetDelta = {
+      x: center.x,
+      y: center.y
+    };
+  }
+
+  input.deltaX = prevDelta.x + (center.x - offset.x);
+  input.deltaY = prevDelta.y + (center.y - offset.y);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/compute-input-data.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/compute-input-data.js
@ -0,0 +1,81 @@
+import { now } from '../utils/utils-consts';
+import { abs } from '../utils/utils-consts';
+import hasParent from '../utils/has-parent';
+import simpleCloneInputData from './simple-clone-input-data';
+import getCenter from './get-center';
+import getDistance from './get-distance';
+import getAngle from './get-angle';
+import getDirection from './get-direction';
+import computeDeltaXY from './compute-delta-xy';
+import getVelocity from './get-velocity';
+import getScale from './get-scale';
+import getRotation from './get-rotation';
+import computeIntervalInputData from './compute-interval-input-data';
+
+/**
+* @private
+ * extend the data with some usable properties like scale, rotate, velocity etc
+ * @param {Object} manager
+ * @param {Object} input
+ */
+export default function computeInputData(manager, input) {
+  let { session } = manager;
+  let { pointers } = input;
+  let { length:pointersLength } = pointers;
+
+  // store the first input to calculate the distance and direction
+  if (!session.firstInput) {
+    session.firstInput = simpleCloneInputData(input);
+  }
+
+  // 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;
+  }
+
+  let { firstInput, firstMultiple } = session;
+  let offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
+
+  let center = input.center = getCenter(pointers);
+  input.timeStamp = now();
+  input.deltaTime = input.timeStamp - firstInput.timeStamp;
+
+  input.angle = getAngle(offsetCenter, center);
+  input.distance = getDistance(offsetCenter, center);
+
+  computeDeltaXY(session, input);
+  input.offsetDirection = getDirection(input.deltaX, input.deltaY);
+
+  let overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
+  input.overallVelocityX = overallVelocity.x;
+  input.overallVelocityY = overallVelocity.y;
+  input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;
+
+  input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
+  input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
+
+  input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >
+  session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);
+
+  computeIntervalInputData(session, input);
+
+  // find the correct target
+  let target = manager.element;
+  const srcEvent = input.srcEvent;
+  let srcEventTarget;
+
+  if (srcEvent.composedPath) {
+    srcEventTarget = srcEvent.composedPath()[0];
+  } else if (srcEvent.path) {
+    srcEventTarget = srcEvent.path[0];
+  } else {
+    srcEventTarget = srcEvent.target;
+  }
+
+  if (hasParent(srcEventTarget, target)) {
+    target = srcEventTarget;
+  }
+  input.target = target;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/compute-interval-input-data.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/compute-interval-input-data.js
@ -0,0 +1,43 @@
+import { INPUT_CANCEL,COMPUTE_INTERVAL } from './input-consts';
+import { abs } from '../utils/utils-consts';
+import getVelocity from './get-velocity';
+import getDirection from './get-direction';
+
+/**
+ * @private
+ * velocity is calculated every x ms
+ * @param {Object} session
+ * @param {Object} input
+ */
+export default function computeIntervalInputData(session, input) {
+  let last = session.lastInterval || input;
+  let deltaTime = input.timeStamp - last.timeStamp;
+  let velocity;
+  let velocityX;
+  let velocityY;
+  let direction;
+
+  if (input.eventType !== INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
+    let deltaX = input.deltaX - last.deltaX;
+    let deltaY = input.deltaY - last.deltaY;
+
+    let 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);
+
+    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;
+  }
+
+  input.velocity = velocity;
+  input.velocityX = velocityX;
+  input.velocityY = velocityY;
+  input.direction = direction;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/create-input-instance.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/create-input-instance.js
@ -0,0 +1,31 @@
+import { SUPPORT_POINTER_EVENTS,SUPPORT_ONLY_TOUCH,SUPPORT_TOUCH } from './input-consts';
+import inputHandler from './input-handler';
+import PointerEventInput from '../input/pointerevent';
+import TouchInput from '../input/touch';
+import MouseInput from '../input/mouse';
+import TouchMouseInput from '../input/touchmouse';
+
+/**
+ * @private
+ * create new input type manager
+ * called by the Manager constructor
+ * @param {Hammer} manager
+ * @returns {Input}
+ */
+export default function createInputInstance(manager) {
+  let Type;
+  // let inputClass = manager.options.inputClass;
+  let { options:{ inputClass } } = manager;
+  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);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-angle.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-angle.js
@ -0,0 +1,18 @@
+import { PROPS_XY } from './input-consts';
+
+/**
+ * @private
+ * calculate the angle between two coordinates
+ * @param {Object} p1
+ * @param {Object} p2
+ * @param {Array} [props] containing x and y keys
+ * @return {Number} angle
+ */
+export default function getAngle(p1, p2, props) {
+  if (!props) {
+    props = PROPS_XY;
+  }
+  let x = p2[props[0]] - p1[props[0]];
+  let y = p2[props[1]] - p1[props[1]];
+  return Math.atan2(y, x) * 180 / Math.PI;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-center.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-center.js
@ -0,0 +1,33 @@
+import { round } from '../utils/utils-consts';
+
+/**
+ * @private
+ * get the center of all the pointers
+ * @param {Array} pointers
+ * @return {Object} center contains `x` and `y` properties
+ */
+export default function getCenter(pointers) {
+  let pointersLength = pointers.length;
+
+  // no need to loop when only one touch
+  if (pointersLength === 1) {
+    return {
+      x: round(pointers[0].clientX),
+      y: round(pointers[0].clientY)
+    };
+  }
+
+  let x = 0;
+  let y = 0;
+  let i = 0;
+  while (i < pointersLength) {
+    x += pointers[i].clientX;
+    y += pointers[i].clientY;
+    i++;
+  }
+
+  return {
+    x: round(x / pointersLength),
+    y: round(y / pointersLength)
+  };
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-direction.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-direction.js
@ -0,0 +1,20 @@
+import { abs } from '../utils/utils-consts';
+import { DIRECTION_NONE,DIRECTION_LEFT,DIRECTION_RIGHT,DIRECTION_UP,DIRECTION_DOWN } from './input-consts';
+
+/**
+ * @private
+ * get the direction between two points
+ * @param {Number} x
+ * @param {Number} y
+ * @return {Number} direction
+ */
+export default function getDirection(x, y) {
+  if (x === y) {
+    return DIRECTION_NONE;
+  }
+
+  if (abs(x) >= abs(y)) {
+    return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
+  }
+  return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-distance.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-distance.js
@ -0,0 +1,19 @@
+import { PROPS_XY } from './input-consts';
+
+/**
+ * @private
+ * 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
+ */
+export default function getDistance(p1, p2, props) {
+  if (!props) {
+    props = PROPS_XY;
+  }
+  let x = p2[props[0]] - p1[props[0]];
+  let y = p2[props[1]] - p1[props[1]];
+
+  return Math.sqrt((x * x) + (y * y));
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-rotation.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-rotation.js
@ -0,0 +1,13 @@
+import getAngle from './get-angle';
+import { PROPS_CLIENT_XY } from './input-consts';
+
+/**
+ * @private
+ * calculate the rotation degrees between two pointersets
+ * @param {Array} start array of pointers
+ * @param {Array} end array of pointers
+ * @return {Number} rotation
+ */
+export default function getRotation(start, end) {
+  return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-scale.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-scale.js
@ -0,0 +1,13 @@
+import { PROPS_CLIENT_XY } from './input-consts';
+import getDistance from './get-distance';
+/**
+ * @private
+ * 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
+ */
+export default function getScale(start, end) {
+  return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-velocity.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/get-velocity.js
@ -0,0 +1,14 @@
+/**
+ * @private
+ * 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`
+ */
+export default function getVelocity(deltaTime, x, y) {
+  return {
+    x: x / deltaTime || 0,
+    y: y / deltaTime || 0
+  };
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/input-constructor.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/input-constructor.js
@ -0,0 +1,59 @@
+import boolOrFn from '../utils/bool-or-fn';
+import addEventListeners from '../utils/add-event-listeners';
+import removeEventListeners from '../utils/remove-event-listeners';
+import getWindowForElement from '../utils/get-window-for-element';
+
+/**
+ * @private
+ * create new input type manager
+ * @param {Manager} manager
+ * @param {Function} callback
+ * @returns {Input}
+ * @constructor
+ */
+export default class Input {
+  constructor(manager, callback) {
+    let self = this;
+    this.manager = manager;
+    this.callback = callback;
+    this.element = manager.element;
+    this.target = manager.options.inputTarget;
+
+    // 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);
+      }
+    };
+
+    this.init();
+
+  }
+  /**
+   * @private
+   * should handle the inputEvent data and trigger the callback
+   * @virtual
+   */
+  handler() { }
+
+  /**
+   * @private
+   * bind the events
+   */
+  init() {
+    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);
+  }
+
+  /**
+   * @private
+   * unbind the events
+   */
+  destroy() {
+    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);
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/input-consts.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/input-consts.js
@ -0,0 +1,59 @@
+import prefixed from '../utils/prefixed';
+import {window} from "../browser";
+
+const MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
+
+const SUPPORT_TOUCH = ('ontouchstart' in window);
+const SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;
+const SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
+
+const INPUT_TYPE_TOUCH = 'touch';
+const INPUT_TYPE_PEN = 'pen';
+const INPUT_TYPE_MOUSE = 'mouse';
+const INPUT_TYPE_KINECT = 'kinect';
+
+const COMPUTE_INTERVAL = 25;
+
+const INPUT_START = 1;
+const INPUT_MOVE = 2;
+const INPUT_END = 4;
+const INPUT_CANCEL = 8;
+
+const DIRECTION_NONE = 1;
+const DIRECTION_LEFT = 2;
+const DIRECTION_RIGHT = 4;
+const DIRECTION_UP = 8;
+const DIRECTION_DOWN = 16;
+
+const DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
+const DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
+const DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
+
+const PROPS_XY = ['x', 'y'];
+const PROPS_CLIENT_XY = ['clientX', 'clientY'];
+
+export {
+    MOBILE_REGEX,
+    SUPPORT_ONLY_TOUCH,
+    SUPPORT_POINTER_EVENTS,
+    SUPPORT_TOUCH,
+    INPUT_TYPE_KINECT,
+    INPUT_TYPE_MOUSE,
+    INPUT_TYPE_PEN,
+    INPUT_TYPE_TOUCH,
+    COMPUTE_INTERVAL,
+    INPUT_START,
+    INPUT_MOVE,
+    INPUT_END,
+    INPUT_CANCEL,
+    DIRECTION_NONE,
+    DIRECTION_LEFT,
+    DIRECTION_RIGHT,
+    DIRECTION_UP,
+    DIRECTION_DOWN,
+    DIRECTION_HORIZONTAL,
+    DIRECTION_VERTICAL,
+    DIRECTION_ALL,
+    PROPS_XY,
+    PROPS_CLIENT_XY
+};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/input-handler.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/input-handler.js
@ -0,0 +1,36 @@
+import { INPUT_START,INPUT_END,INPUT_CANCEL } from './input-consts';
+import computeInputData from './compute-input-data';
+
+/**
+ * @private
+ * handle input events
+ * @param {Manager} manager
+ * @param {String} eventType
+ * @param {Object} input
+ */
+export default function inputHandler(manager, eventType, input) {
+  let pointersLen = input.pointers.length;
+  let changedPointersLen = input.changedPointers.length;
+  let isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));
+  let isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));
+
+  input.isFirst = !!isFirst;
+  input.isFinal = !!isFinal;
+
+  if (isFirst) {
+    manager.session = {};
+  }
+
+  // source event is the normalized value of the domEvents
+  // like 'touchstart, mouseup, pointerdown'
+  input.eventType = eventType;
+
+  // compute scale, rotation etc
+  computeInputData(manager, input);
+
+  // emit secret event
+  manager.emit('hammer.input', input);
+
+  manager.recognize(input);
+  manager.session.prevInput = input;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/simple-clone-input-data.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/inputjs/simple-clone-input-data.js
@ -0,0 +1,30 @@
+import { now,round } from '../utils/utils-consts';
+import getCenter from './get-center';
+
+/**
+ * @private
+ * create a simple clone from the input used for storage of firstInput and firstMultiple
+ * @param {Object} input
+ * @returns {Object} clonedInputData
+ */
+export default 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
+  let pointers = [];
+  let i = 0;
+  while (i < input.pointers.length) {
+    pointers[i] = {
+      clientX: round(input.pointers[i].clientX),
+      clientY: round(input.pointers[i].clientY)
+    };
+    i++;
+  }
+
+  return {
+    timeStamp: now(),
+    pointers,
+    center: getCenter(pointers),
+    deltaX: input.deltaX,
+    deltaY: input.deltaY
+  };
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/manager.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/manager.js
@ -0,0 +1,352 @@
+import assign from "./utils/assign";
+import TouchAction from "./touchactionjs/touchaction-constructor";
+import createInputInstance from "./inputjs/create-input-instance";
+import each from "./utils/each";
+import inArray from "./utils/in-array";
+import invokeArrayArg from "./utils/invoke-array-arg";
+import splitStr from "./utils/split-str";
+import prefixed from "./utils/prefixed";
+import Recognizer from "./recognizerjs/recognizer-constructor";
+import {
+  STATE_BEGAN,
+  STATE_ENDED,
+  STATE_CHANGED,
+  STATE_RECOGNIZED,
+} from "./recognizerjs/recognizer-consts";
+import defaults from "./defaults";
+
+const STOP = 1;
+const FORCED_STOP = 2;
+
+
+/**
+ * @private
+ * add/remove the css properties as defined in manager.options.cssProps
+ * @param {Manager} manager
+ * @param {Boolean} add
+ */
+function toggleCssProps(manager, add) {
+  const { element } = manager;
+
+  if (!element.style) {
+    return;
+  }
+  let prop;
+
+  each(manager.options.cssProps, (value, name) => {
+    prop = prefixed(element.style, name);
+    if (add) {
+      manager.oldCssProps[prop] = element.style[prop];
+      element.style[prop] = value;
+    } else {
+      element.style[prop] = manager.oldCssProps[prop] || "";
+    }
+  });
+  if (!add) {
+    manager.oldCssProps = {};
+  }
+}
+
+/**
+ * @private
+ * trigger dom event
+ * @param {String} event
+ * @param {Object} data
+ */
+function triggerDomEvent(event, data) {
+  const gestureEvent = document.createEvent("Event");
+
+  gestureEvent.initEvent(event, true, true);
+  gestureEvent.gesture = data;
+  data.target.dispatchEvent(gestureEvent);
+}
+
+
+/**
+* @private
+ * Manager
+ * @param {HTMLElement} element
+ * @param {Object} [options]
+ * @constructor
+ */
+export default class Manager {
+  constructor(element, options) {
+    this.options = assign({}, defaults, options || {});
+
+    this.options.inputTarget = this.options.inputTarget || element;
+
+    this.handlers = {};
+    this.session = {};
+    this.recognizers = [];
+    this.oldCssProps = {};
+
+    this.element = element;
+    this.input = createInputInstance(this);
+    this.touchAction = new TouchAction(this, this.options.touchAction);
+
+    toggleCssProps(this, true);
+
+    each(this.options.recognizers, item => {
+      const recognizer = this.add(new (item[0])(item[1]));
+
+      item[2] && recognizer.recognizeWith(item[2]);
+      item[3] && recognizer.requireFailure(item[3]);
+    }, this);
+  }
+
+	/**
+	 * @private
+	 * set options
+	 * @param {Object} options
+	 * @returns {Manager}
+	 */
+  set(options) {
+    assign(this.options, options);
+
+    // 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;
+  }
+
+	/**
+	 * @private
+	 * 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(force) {
+    this.session.stopped = force ? FORCED_STOP : STOP;
+  }
+
+	/**
+	 * @private
+	 * 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(inputData) {
+    const { session } = this;
+
+    if (session.stopped) {
+      return;
+    }
+
+    // run the touch-action polyfill
+    this.touchAction.preventDefaults(inputData);
+
+    let recognizer;
+    const { recognizers } = this;
+
+    // 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`
+    let { curRecognizer } = session;
+
+    // reset when the last recognizer is recognized
+    // or when we're in a new session
+    if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
+      session.curRecognizer = null;
+      curRecognizer = null;
+    }
+
+    let i = 0;
+
+    while (i < recognizers.length) {
+      recognizer = recognizers[i];
+
+      // 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();
+      }
+
+      // 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)) {
+        session.curRecognizer = recognizer;
+        curRecognizer = recognizer;
+      }
+      i++;
+    }
+  }
+
+	/**
+	 * @private
+	 * get a recognizer by its event name.
+	 * @param {Recognizer|String} recognizer
+	 * @returns {Recognizer|Null}
+	 */
+  get(recognizer) {
+    if (recognizer instanceof Recognizer) {
+      return recognizer;
+    }
+
+    const { recognizers } = this;
+
+    for (let i = 0; i < recognizers.length; i++) {
+      if (recognizers[i].options.event === recognizer) {
+        return recognizers[i];
+      }
+    }
+    return null;
+  }
+
+	/**
+	 * @private add a recognizer to the manager
+	 * existing recognizers with the same event name will be removed
+	 * @param {Recognizer} recognizer
+	 * @returns {Recognizer|Manager}
+	 */
+  add(recognizer) {
+    if (invokeArrayArg(recognizer, "add", this)) {
+      return this;
+    }
+
+    // remove existing
+    const existing = this.get(recognizer.options.event);
+
+    if (existing) {
+      this.remove(existing);
+    }
+
+    this.recognizers.push(recognizer);
+    recognizer.manager = this;
+
+    this.touchAction.update();
+    return recognizer;
+  }
+
+	/**
+	 * @private
+	 * remove a recognizer by name or instance
+	 * @param {Recognizer|String} recognizer
+	 * @returns {Manager}
+	 */
+  remove(recognizer) {
+    if (invokeArrayArg(recognizer, "remove", this)) {
+      return this;
+    }
+
+    const targetRecognizer = this.get(recognizer);
+
+    // let's make sure this recognizer exists
+    if (recognizer) {
+      const { recognizers } = this;
+      const index = inArray(recognizers, targetRecognizer);
+
+      if (index !== -1) {
+        recognizers.splice(index, 1);
+        this.touchAction.update();
+      }
+    }
+
+    return this;
+  }
+
+	/**
+	 * @private
+	 * bind event
+	 * @param {String} events
+	 * @param {Function} handler
+	 * @returns {EventEmitter} this
+	 */
+  on(events, handler) {
+    if (events === undefined || handler === undefined) {
+      return this;
+    }
+
+    const { handlers } = this;
+
+    each(splitStr(events), event => {
+      handlers[event] = handlers[event] || [];
+      handlers[event].push(handler);
+    });
+    return this;
+  }
+
+	/**
+	 * @private unbind event, leave emit blank to remove all handlers
+	 * @param {String} events
+	 * @param {Function} [handler]
+	 * @returns {EventEmitter} this
+	 */
+  off(events, handler) {
+    if (events === undefined) {
+      return this;
+    }
+
+    const { handlers } = this;
+
+    each(splitStr(events), event => {
+      if (!handler) {
+        delete handlers[event];
+      } else {
+        handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
+      }
+    });
+    return this;
+  }
+
+	/**
+	 * @private emit event to the listeners
+	 * @param {String} event
+	 * @param {Object} data
+	 */
+  emit(event, data) {
+    // we also want to trigger dom events
+    if (this.options.domEvents) {
+      triggerDomEvent(event, data);
+    }
+
+    // no handlers, so skip it all
+    const handlers = this.handlers[event] && this.handlers[event].slice();
+
+    if (!handlers || !handlers.length) {
+      return;
+    }
+
+    data.type = event;
+    data.preventDefault = function () {
+      data.srcEvent.preventDefault();
+    };
+
+    let i = 0;
+
+    while (i < handlers.length) {
+      handlers[i](data);
+      i++;
+    }
+  }
+
+	/**
+	 * @private
+	 * destroy the manager and unbinds all events
+	 * it doesn't unbind dom events, that is the user own responsibility
+	 */
+  destroy() {
+    this.element && toggleCssProps(this, false);
+
+    this.handlers = {};
+    this.session = {};
+    this.input.destroy();
+    this.element = null;
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/direction-str.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/direction-str.js
@ -0,0 +1,25 @@
+import {
+    DIRECTION_LEFT,
+    DIRECTION_RIGHT,
+    DIRECTION_UP,
+    DIRECTION_DOWN
+} from '../inputjs/input-consts';
+
+/**
+ * @private
+ * direction cons to string
+ * @param {constant} direction
+ * @returns {String}
+ */
+export default 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 '';
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/get-recognizer-by-name-if-manager.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/get-recognizer-by-name-if-manager.js
@ -0,0 +1,14 @@
+/**
+ * @private
+ * get a recognizer by name if it is bound to a manager
+ * @param {Recognizer|String} otherRecognizer
+ * @param {Recognizer} recognizer
+ * @returns {Recognizer}
+ */
+export default function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
+  let { manager } = recognizer;
+  if (manager) {
+    return manager.get(otherRecognizer);
+  }
+  return otherRecognizer;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/recognizer-constructor.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/recognizer-constructor.js
@ -0,0 +1,300 @@
+import {
+    STATE_POSSIBLE,
+    STATE_ENDED,
+    STATE_FAILED,
+    STATE_RECOGNIZED,
+    STATE_CANCELLED,
+    STATE_BEGAN,
+    STATE_CHANGED
+} from './recognizer-consts';
+import assign from '../utils/assign';
+import uniqueId from '../utils/unique-id';
+import invokeArrayArg from '../utils/invoke-array-arg';
+import inArray from '../utils/in-array';
+import boolOrFn from '../utils/bool-or-fn';
+import getRecognizerByNameIfManager from './get-recognizer-by-name-if-manager';
+import stateStr from './state-str';
+
+/**
+ * @private
+ * 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
+ */
+
+/**
+ * @private
+ * Recognizer
+ * Every recognizer needs to extend from this class.
+ * @constructor
+ * @param {Object} options
+ */
+export default class Recognizer {
+  constructor(options = {}) {
+    this.options = {
+      enable: true,
+      ...options,
+    };
+
+    this.id = uniqueId();
+
+    this.manager = null;
+
+    // default is enable true
+    this.state = STATE_POSSIBLE;
+    this.simultaneous = {};
+    this.requireFail = [];
+  }
+
+  /**
+   * @private
+   * set options
+   * @param {Object} options
+   * @return {Recognizer}
+   */
+  set(options) {
+    assign(this.options, options);
+
+    // also update the touchAction, in case something changed about the directions/enabled state
+    this.manager && this.manager.touchAction.update();
+    return this;
+  }
+
+  /**
+   * @private
+   * recognize simultaneous with an other recognizer.
+   * @param {Recognizer} otherRecognizer
+   * @returns {Recognizer} this
+   */
+  recognizeWith(otherRecognizer) {
+    if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
+      return this;
+    }
+
+    let { simultaneous } = this;
+    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+    if (!simultaneous[otherRecognizer.id]) {
+      simultaneous[otherRecognizer.id] = otherRecognizer;
+      otherRecognizer.recognizeWith(this);
+    }
+    return this;
+  }
+
+  /**
+   * @private
+   * drop the simultaneous link. it doesnt remove the link on the other recognizer.
+   * @param {Recognizer} otherRecognizer
+   * @returns {Recognizer} this
+   */
+  dropRecognizeWith(otherRecognizer) {
+    if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
+      return this;
+    }
+
+    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+    delete this.simultaneous[otherRecognizer.id];
+    return this;
+  }
+
+  /**
+   * @private
+   * recognizer can only run when an other is failing
+   * @param {Recognizer} otherRecognizer
+   * @returns {Recognizer} this
+   */
+  requireFailure(otherRecognizer) {
+    if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
+      return this;
+    }
+
+    let { requireFail } = this;
+    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+    if (inArray(requireFail, otherRecognizer) === -1) {
+      requireFail.push(otherRecognizer);
+      otherRecognizer.requireFailure(this);
+    }
+    return this;
+  }
+
+  /**
+   * @private
+   * drop the requireFailure link. it does not remove the link on the other recognizer.
+   * @param {Recognizer} otherRecognizer
+   * @returns {Recognizer} this
+   */
+  dropRequireFailure(otherRecognizer) {
+    if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
+      return this;
+    }
+
+    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+    let index = inArray(this.requireFail, otherRecognizer);
+    if (index > -1) {
+      this.requireFail.splice(index, 1);
+    }
+    return this;
+  }
+
+  /**
+   * @private
+   * has require failures boolean
+   * @returns {boolean}
+   */
+  hasRequireFailures() {
+    return this.requireFail.length > 0;
+  }
+
+  /**
+   * @private
+   * if the recognizer can recognize simultaneous with an other recognizer
+   * @param {Recognizer} otherRecognizer
+   * @returns {Boolean}
+   */
+  canRecognizeWith(otherRecognizer) {
+    return !!this.simultaneous[otherRecognizer.id];
+  }
+
+  /**
+   * @private
+   * You should use `tryEmit` instead of `emit` directly to check
+   * that all the needed recognizers has failed before emitting.
+   * @param {Object} input
+   */
+  emit(input) {
+    let self = this;
+    let { state } = this;
+
+    function emit(event) {
+      self.manager.emit(event, input);
+    }
+
+    // 'panstart' and 'panmove'
+    if (state < STATE_ENDED) {
+      emit(self.options.event + stateStr(state));
+    }
+
+    emit(self.options.event); // simple 'eventName' events
+
+    if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)
+      emit(input.additionalEvent);
+    }
+
+    // panend and pancancel
+    if (state >= STATE_ENDED) {
+      emit(self.options.event + stateStr(state));
+    }
+  }
+
+  /**
+   * @private
+   * 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(input) {
+    if (this.canEmit()) {
+      return this.emit(input);
+    }
+    // it's failing anyway
+    this.state = STATE_FAILED;
+  }
+
+  /**
+   * @private
+   * can we emit?
+   * @returns {boolean}
+   */
+  canEmit() {
+    let i = 0;
+    while (i < this.requireFail.length) {
+      if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
+        return false;
+      }
+      i++;
+    }
+    return true;
+  }
+
+  /**
+   * @private
+   * update the recognizer
+   * @param {Object} inputData
+   */
+  recognize(inputData) {
+    // make a new copy of the inputData
+    // so we can change the inputData without messing up the other recognizers
+    let inputDataClone = assign({}, inputData);
+
+    // is is enabled and allow recognizing?
+    if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
+      this.reset();
+      this.state = STATE_FAILED;
+      return;
+    }
+
+    // reset when we've reached the end
+    if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
+      this.state = STATE_POSSIBLE;
+    }
+
+    this.state = this.process(inputDataClone);
+
+    // the recognizer has recognized a gesture
+    // so trigger an event
+    if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
+      this.tryEmit(inputDataClone);
+    }
+  }
+
+  /**
+   * @private
+   * return the state of the recognizer
+   * the actual recognizing happens in this method
+   * @virtual
+   * @param {Object} inputData
+   * @returns {constant} STATE
+   */
+
+  /* jshint ignore:start */
+  process(inputData) { }
+  /* jshint ignore:end */
+
+  /**
+   * @private
+   * return the preferred touch-action
+   * @virtual
+   * @returns {Array}
+   */
+  getTouchAction() { }
+
+  /**
+   * @private
+   * called when the gesture isn't allowed to recognize
+   * like when another is being recognized or it is disabled
+   * @virtual
+   */
+  reset() { }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/recognizer-consts.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/recognizer-consts.js
@ -0,0 +1,17 @@
+const STATE_POSSIBLE = 1;
+const STATE_BEGAN = 2;
+const STATE_CHANGED = 4;
+const STATE_ENDED = 8;
+const STATE_RECOGNIZED = STATE_ENDED;
+const STATE_CANCELLED = 16;
+const STATE_FAILED = 32;
+
+export {
+    STATE_POSSIBLE,
+    STATE_BEGAN,
+    STATE_CHANGED,
+    STATE_ENDED,
+    STATE_RECOGNIZED,
+    STATE_CANCELLED,
+    STATE_FAILED
+};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/state-str.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizerjs/state-str.js
@ -0,0 +1,25 @@
+import {
+    STATE_CANCELLED,
+    STATE_ENDED,
+    STATE_CHANGED,
+    STATE_BEGAN
+} from './recognizer-consts';
+
+/**
+ * @private
+ * get a usable string, used as event postfix
+ * @param {constant} state
+ * @returns {String} state
+ */
+export default 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 '';
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/attribute.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/attribute.js
@ -0,0 +1,67 @@
+import Recognizer from '../recognizerjs/recognizer-constructor';
+import {
+    STATE_BEGAN,
+    STATE_CHANGED,
+    STATE_CANCELLED,
+    STATE_ENDED,
+    STATE_FAILED
+} from '../recognizerjs/recognizer-consts';
+import {
+    INPUT_CANCEL,
+    INPUT_END
+} from '../inputjs/input-consts';
+
+/**
+ * @private
+ * This recognizer is just used as a base for the simple attribute recognizers.
+ * @constructor
+ * @extends Recognizer
+ */
+export default class AttrRecognizer extends Recognizer {
+  constructor(options = {}) {
+    super({
+      pointers: 1,
+      ...options,
+    });
+  }
+
+  /**
+   * @private
+   * Used to check if it the recognizer receives valid input, like input.distance > 10.
+   * @memberof AttrRecognizer
+   * @param {Object} input
+   * @returns {Boolean} recognized
+   */
+  attrTest(input) {
+    let optionPointers = this.options.pointers;
+    return optionPointers === 0 || input.pointers.length === optionPointers;
+  }
+
+  /**
+   * @private
+   * Process the input and return the state for the recognizer
+   * @memberof AttrRecognizer
+   * @param {Object} input
+   * @returns {*} State
+   */
+  process(input) {
+    let { state } = this;
+    let { eventType } = input;
+
+    let isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
+    let 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;
+    }
+    return STATE_FAILED;
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/pan.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/pan.js
@ -0,0 +1,89 @@
+import  AttrRecognizer from './attribute';
+import {
+    DIRECTION_ALL,
+    DIRECTION_HORIZONTAL,
+    DIRECTION_VERTICAL,
+    DIRECTION_NONE,
+    DIRECTION_UP,
+    DIRECTION_DOWN,
+    DIRECTION_LEFT,
+    DIRECTION_RIGHT
+} from '../inputjs/input-consts';
+import { STATE_BEGAN } from '../recognizerjs/recognizer-consts';
+import { TOUCH_ACTION_PAN_X,TOUCH_ACTION_PAN_Y } from '../touchactionjs/touchaction-Consts';
+import directionStr from '../recognizerjs/direction-str';
+
+/**
+ * @private
+ * Pan
+ * Recognized when the pointer is down and moved in the allowed direction.
+ * @constructor
+ * @extends AttrRecognizer
+ */
+export default class PanRecognizer extends AttrRecognizer {
+  constructor(options = {}) {
+    super({
+      event: 'pan',
+      threshold: 10,
+      pointers: 1,
+      direction: DIRECTION_ALL,
+      ...options,
+    });
+    this.pX = null;
+    this.pY = null;
+  }
+
+  getTouchAction() {
+    let { options:{ direction } } = this;
+    let actions = [];
+    if (direction & DIRECTION_HORIZONTAL) {
+      actions.push(TOUCH_ACTION_PAN_Y);
+    }
+    if (direction & DIRECTION_VERTICAL) {
+      actions.push(TOUCH_ACTION_PAN_X);
+    }
+    return actions;
+  }
+
+  directionTest(input) {
+    let { options } = this;
+    let hasMoved = true;
+    let { distance } = input;
+    let { direction } = input;
+    let x = input.deltaX;
+    let 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);
+      }
+    }
+    input.direction = direction;
+    return hasMoved && distance > options.threshold && direction & options.direction;
+  }
+
+  attrTest(input) {
+    return AttrRecognizer.prototype.attrTest.call(this, input) && // replace with a super call
+        (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));
+  }
+
+  emit(input) {
+
+    this.pX = input.deltaX;
+    this.pY = input.deltaY;
+
+    let direction = directionStr(input.direction);
+
+    if (direction) {
+      input.additionalEvent = this.options.event + direction;
+    }
+    super.emit(input);
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/pinch.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/pinch.js
@ -0,0 +1,38 @@
+import AttrRecognizer from './attribute';
+import { TOUCH_ACTION_NONE } from '../touchactionjs/touchaction-Consts';
+import { STATE_BEGAN } from '../recognizerjs/recognizer-consts';
+
+/**
+ * @private
+ * Pinch
+ * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
+ * @constructor
+ * @extends AttrRecognizer
+ */
+export default class PinchRecognizer extends AttrRecognizer {
+  constructor(options = {}) {
+    super({
+      event: 'pinch',
+      threshold: 0,
+      pointers: 2,
+      ...options,
+    });
+  }
+
+  getTouchAction() {
+    return [TOUCH_ACTION_NONE];
+  }
+
+  attrTest(input) {
+    return super.attrTest(input) &&
+        (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
+  }
+
+  emit(input) {
+    if (input.scale !== 1) {
+      let inOut = input.scale < 1 ? 'in' : 'out';
+      input.additionalEvent = this.options.event + inOut;
+    }
+    super.emit(input);
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/press.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/press.js
@ -0,0 +1,79 @@
+import Recognizer from '../recognizerjs/recognizer-constructor';
+import {
+    STATE_RECOGNIZED,
+    STATE_FAILED
+} from '../recognizerjs/recognizer-consts';
+import { now } from '../utils/utils-consts';
+import { TOUCH_ACTION_AUTO } from '../touchactionjs/touchaction-Consts';
+import {
+    INPUT_START,
+    INPUT_END,
+    INPUT_CANCEL
+} from '../inputjs/input-consts';
+
+/**
+ * @private
+ * Press
+ * Recognized when the pointer is down for x ms without any movement.
+ * @constructor
+ * @extends Recognizer
+ */
+export default class PressRecognizer extends Recognizer {
+  constructor(options = {}) {
+    super({
+      event: 'press',
+      pointers: 1,
+      time: 251, // minimal time of the pointer to be pressed
+      threshold: 9, // a minimal movement is ok, but keep it low
+      ...options,
+    });
+    this._timer = null;
+    this._input = null;
+  }
+
+  getTouchAction() {
+    return [TOUCH_ACTION_AUTO];
+  }
+
+  process(input) {
+    let { options } = this;
+    let validPointers = input.pointers.length === options.pointers;
+    let validMovement = input.distance < options.threshold;
+    let validTime = input.deltaTime > options.time;
+
+    this._input = input;
+
+    // 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 = setTimeout(() => {
+        this.state = STATE_RECOGNIZED;
+        this.tryEmit();
+      }, options.time);
+    } else if (input.eventType & INPUT_END) {
+      return STATE_RECOGNIZED;
+    }
+    return STATE_FAILED;
+  }
+
+  reset() {
+    clearTimeout(this._timer);
+  }
+
+  emit(input) {
+    if (this.state !== STATE_RECOGNIZED) {
+      return;
+    }
+
+    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);
+    }
+  }
+}
+
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/rotate.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/rotate.js
@ -0,0 +1,30 @@
+import AttrRecognizer from './attribute';
+import { TOUCH_ACTION_NONE } from '../touchactionjs/touchaction-Consts';
+import { STATE_BEGAN } from '../recognizerjs/recognizer-consts';
+
+/**
+ * @private
+ * Rotate
+ * Recognized when two or more pointer are moving in a circular motion.
+ * @constructor
+ * @extends AttrRecognizer
+ */
+export default class RotateRecognizer extends AttrRecognizer {
+  constructor(options = {}) {
+    super( {
+      event: 'rotate',
+      threshold: 0,
+      pointers: 2,
+      ...options,
+    });
+  }
+
+  getTouchAction() {
+    return [TOUCH_ACTION_NONE];
+  }
+
+  attrTest(input) {
+    return super.attrTest(input) &&
+        (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/swipe.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/swipe.js
@ -0,0 +1,58 @@
+import AttrRecognizer from '../recognizers/attribute';
+import { abs } from '../utils/utils-consts';
+import { DIRECTION_HORIZONTAL,DIRECTION_VERTICAL } from '../inputjs/input-consts';
+import PanRecognizer from './pan';
+import { INPUT_END } from '../inputjs/input-consts';
+import directionStr from '../recognizerjs/direction-str';
+
+/**
+ * @private
+ * Swipe
+ * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
+ * @constructor
+ * @extends AttrRecognizer
+ */
+export default class SwipeRecognizer extends AttrRecognizer {
+  constructor(options = {}) {
+    super({
+      event: 'swipe',
+      threshold: 10,
+      velocity: 0.3,
+      direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
+      pointers: 1,
+      ...options,
+    });
+  }
+
+  getTouchAction() {
+    return PanRecognizer.prototype.getTouchAction.call(this);
+  }
+
+  attrTest(input) {
+    let { direction } = this.options;
+    let velocity;
+
+    if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
+      velocity = input.overallVelocity;
+    } else if (direction & DIRECTION_HORIZONTAL) {
+      velocity = input.overallVelocityX;
+    } else if (direction & DIRECTION_VERTICAL) {
+      velocity = input.overallVelocityY;
+    }
+
+    return super.attrTest(input) &&
+        direction & input.offsetDirection &&
+        input.distance > this.options.threshold &&
+        input.maxPointers === this.options.pointers &&
+        abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
+  }
+
+  emit(input) {
+    let direction = directionStr(input.offsetDirection);
+    if (direction) {
+      this.manager.emit(this.options.event + direction, input);
+    }
+
+    this.manager.emit(this.options.event, input);
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/tap.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/recognizers/tap.js
@ -0,0 +1,120 @@
+import Recognizer from '../recognizerjs/recognizer-constructor';
+import { TOUCH_ACTION_MANIPULATION } from '../touchactionjs/touchaction-Consts';
+import {INPUT_START,INPUT_END } from '../inputjs/input-consts';
+import {
+    STATE_RECOGNIZED,
+    STATE_BEGAN,
+    STATE_FAILED
+} from '../recognizerjs/recognizer-consts';
+import getDistance from '../inputjs/get-distance';
+
+/**
+ * @private
+ * A tap is recognized 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
+ */
+export default class TapRecognizer extends Recognizer {
+  constructor(options = {}) {
+    super({
+      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: 9, // a minimal movement is ok, but keep it low
+      posThreshold: 10, // a multi-tap can be a bit off the initial position
+      ...options,
+    });
+
+    // previous time and center,
+    // used for tap counting
+    this.pTime = false;
+    this.pCenter = false;
+
+    this._timer = null;
+    this._input = null;
+    this.count = 0;
+  }
+
+  getTouchAction() {
+    return [TOUCH_ACTION_MANIPULATION];
+  }
+
+  process(input) {
+    let { options } = this;
+
+    let validPointers = input.pointers.length === options.pointers;
+    let validMovement = input.distance < options.threshold;
+    let validTouchTime = input.deltaTime < options.time;
+
+    this.reset();
+
+    if ((input.eventType & INPUT_START) && (this.count === 0)) {
+      return this.failTimeout();
+    }
+
+    // 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();
+      }
+
+      let validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
+      let validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
+
+      this.pTime = input.timeStamp;
+      this.pCenter = input.center;
+
+      if (!validMultiTap || !validInterval) {
+        this.count = 1;
+      } else {
+        this.count += 1;
+      }
+
+      this._input = input;
+
+      // if tap count matches we have recognized it,
+      // else it has began recognizing...
+      let 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 = setTimeout(() => {
+            this.state = STATE_RECOGNIZED;
+            this.tryEmit();
+          }, options.interval);
+          return STATE_BEGAN;
+        }
+      }
+    }
+    return STATE_FAILED;
+  }
+
+  failTimeout() {
+    this._timer = setTimeout(() => {
+      this.state = STATE_FAILED;
+    }, this.options.interval);
+    return STATE_FAILED;
+  }
+
+  reset() {
+    clearTimeout(this._timer);
+  }
+
+  emit() {
+    if (this.state === STATE_RECOGNIZED) {
+      this._input.tapCount = this.count;
+      this.manager.emit(this.options.event, this._input);
+    }
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/clean-touch-actions.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/clean-touch-actions.js
@ -0,0 +1,44 @@
+import inStr from '../utils/in-str';
+import {
+    TOUCH_ACTION_NONE,
+    TOUCH_ACTION_PAN_X,
+    TOUCH_ACTION_PAN_Y,
+    TOUCH_ACTION_MANIPULATION,
+    TOUCH_ACTION_AUTO
+} from './touchaction-Consts';
+
+/**
+ * @private
+ * when the touchActions are collected they are not a valid value, so we need to clean things up. *
+ * @param {String} actions
+ * @returns {*}
+ */
+export default function cleanTouchActions(actions) {
+  // none
+  if (inStr(actions, TOUCH_ACTION_NONE)) {
+    return TOUCH_ACTION_NONE;
+  }
+
+  let hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
+  let hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
+
+  // if both pan-x and pan-y are set (different recognizers
+  // for different directions, e.g. horizontal pan but vertical swipe?)
+  // we need none (as otherwise with pan-x pan-y combined none of these
+  // recognizers will work, since the browser would handle all panning
+  if (hasPanX && hasPanY) {
+    return TOUCH_ACTION_NONE;
+  }
+
+  // pan-x OR pan-y
+  if (hasPanX || hasPanY) {
+    return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
+  }
+
+  // manipulation
+  if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
+    return TOUCH_ACTION_MANIPULATION;
+  }
+
+  return TOUCH_ACTION_AUTO;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/get-touchaction-props.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/get-touchaction-props.js
@ -0,0 +1,21 @@
+import prefixed from '../utils/prefixed';
+import { TEST_ELEMENT } from '../utils/utils-consts';
+import {window} from '../browser';
+
+export const PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
+export const NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
+
+export default function getTouchActionProps() {
+  if (!NATIVE_TOUCH_ACTION) {
+    return false;
+  }
+  let touchMap = {};
+  let cssSupports = window.CSS && window.CSS.supports;
+  ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach((val) => {
+
+    // If css.supports is not supported but there is native touch-action assume it supports
+    // all values. This is the case for IE 10 and 11.
+    return touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;
+  });
+  return touchMap;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/touchaction-Consts.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/touchaction-Consts.js
@ -0,0 +1,22 @@
+import getTouchActionProps from './get-touchaction-props';
+
+
+
+// magical touchAction value
+const TOUCH_ACTION_COMPUTE = 'compute';
+const TOUCH_ACTION_AUTO = 'auto';
+const TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
+const TOUCH_ACTION_NONE = 'none';
+const TOUCH_ACTION_PAN_X = 'pan-x';
+const TOUCH_ACTION_PAN_Y = 'pan-y';
+const TOUCH_ACTION_MAP = getTouchActionProps();
+
+export {
+  TOUCH_ACTION_AUTO,
+  TOUCH_ACTION_COMPUTE,
+  TOUCH_ACTION_MANIPULATION,
+  TOUCH_ACTION_NONE,
+  TOUCH_ACTION_PAN_X,
+  TOUCH_ACTION_PAN_Y,
+  TOUCH_ACTION_MAP
+};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/touchaction-constructor.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/touchactionjs/touchaction-constructor.js
@ -0,0 +1,127 @@
+import {
+    TOUCH_ACTION_COMPUTE,
+    TOUCH_ACTION_MAP,
+    TOUCH_ACTION_NONE,
+    TOUCH_ACTION_PAN_X,
+    TOUCH_ACTION_PAN_Y
+} from './touchaction-Consts';
+import {
+  NATIVE_TOUCH_ACTION,
+  PREFIXED_TOUCH_ACTION,
+} from "./get-touchaction-props";
+import {
+    DIRECTION_VERTICAL,
+    DIRECTION_HORIZONTAL
+} from '../inputjs/input-consts';
+import each from '../utils/each';
+import boolOrFn from '../utils/bool-or-fn';
+import inStr from '../utils/in-str';
+import cleanTouchActions from './clean-touch-actions';
+
+/**
+ * @private
+ * Touch Action
+ * sets the touchAction property or uses the js alternative
+ * @param {Manager} manager
+ * @param {String} value
+ * @constructor
+ */
+export default class TouchAction {
+  constructor(manager, value) {
+    this.manager = manager;
+    this.set(value);
+  }
+
+  /**
+   * @private
+   * set the touchAction value on the element or enable the polyfill
+   * @param {String} value
+   */
+  set(value) {
+    // find out the touch-action by the event handlers
+    if (value === TOUCH_ACTION_COMPUTE) {
+      value = this.compute();
+    }
+
+    if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
+      this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
+    }
+    this.actions = value.toLowerCase().trim();
+  }
+
+  /**
+   * @private
+   * just re-set the touchAction value
+   */
+  update() {
+    this.set(this.manager.options.touchAction);
+  }
+
+  /**
+   * @private
+   * compute the value for the touchAction property based on the recognizer's settings
+   * @returns {String} value
+   */
+  compute() {
+    let actions = [];
+    each(this.manager.recognizers, (recognizer) => {
+      if (boolOrFn(recognizer.options.enable, [recognizer])) {
+        actions = actions.concat(recognizer.getTouchAction());
+      }
+    });
+    return cleanTouchActions(actions.join(' '));
+  }
+
+  /**
+   * @private
+   * this method is called on each input cycle and provides the preventing of the browser behavior
+   * @param {Object} input
+   */
+  preventDefaults(input) {
+    let { srcEvent } = input;
+    let direction = input.offsetDirection;
+
+    // if the touch action did prevented once this session
+    if (this.manager.session.prevented) {
+      srcEvent.preventDefault();
+      return;
+    }
+
+    let { actions } = this;
+    let hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
+    let hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
+    let hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
+
+    if (hasNone) {
+      // do not prevent defaults if this is a tap gesture
+      let isTapPointer = input.pointers.length === 1;
+      let isTapMovement = input.distance < 2;
+      let isTapTouchTime = input.deltaTime < 250;
+
+      if (isTapPointer && isTapMovement && isTapTouchTime) {
+        return;
+      }
+    }
+
+    if (hasPanX && hasPanY) {
+      // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
+      return;
+    }
+
+    if (hasNone ||
+        (hasPanY && direction & DIRECTION_HORIZONTAL) ||
+        (hasPanX && direction & DIRECTION_VERTICAL)) {
+      return this.preventSrc(srcEvent);
+    }
+  }
+
+  /**
+   * @private
+   * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
+   * @param {Object} srcEvent
+   */
+  preventSrc(srcEvent) {
+    this.manager.session.prevented = true;
+    srcEvent.preventDefault();
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/add-event-listeners.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/add-event-listeners.js
@ -0,0 +1,14 @@
+import each from './each';
+import splitStr from './split-str';
+/**
+ * @private
+ * addEventListener with multiple events at once
+ * @param {EventTarget} target
+ * @param {String} types
+ * @param {Function} handler
+ */
+export default function addEventListeners(target, types, handler) {
+  each(splitStr(types), (type) => {
+    target.addEventListener(type, handler, false);
+  });
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/assign.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/assign.js
@ -0,0 +1,33 @@
+/**
+ * @private
+ * extend object.
+ * means that properties in dest will be overwritten by the ones in src.
+ * @param {Object} target
+ * @param {...Object} objects_to_assign
+ * @returns {Object} target
+ */
+let assign;
+if (typeof Object.assign !== 'function') {
+  assign = function assign(target) {
+    if (target === undefined || target === null) {
+      throw new TypeError('Cannot convert undefined or null to object');
+    }
+
+    let output = Object(target);
+    for (let index = 1; index < arguments.length; index++) {
+      const source = arguments[index];
+      if (source !== undefined && source !== null) {
+        for (const nextKey in source) {
+          if (source.hasOwnProperty(nextKey)) {
+            output[nextKey] = source[nextKey];
+          }
+        }
+      }
+    }
+    return output;
+  };
+} else {
+  assign = Object.assign;
+}
+
+export default assign;
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/bind-fn.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/bind-fn.js
@ -0,0 +1,12 @@
+/**
+ * @private
+ * simple function bind
+ * @param {Function} fn
+ * @param {Object} context
+ * @returns {Function}
+ */
+export default function bindFn(fn, context) {
+  return function boundFn() {
+    return fn.apply(context, arguments);
+  };
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/bool-or-fn.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/bool-or-fn.js
@ -0,0 +1,15 @@
+import { TYPE_FUNCTION } from './utils-consts';
+/**
+ * @private
+ * 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}
+ */
+export default function boolOrFn(val, args) {
+  if (typeof val === TYPE_FUNCTION) {
+    return val.apply(args ? args[0] || undefined : undefined, args);
+  }
+  return val;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/deprecate.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/deprecate.js
@ -0,0 +1,23 @@
+/**
+ * @private
+ * wrap a method with a deprecation warning and stack trace
+ * @param {Function} method
+ * @param {String} name
+ * @param {String} message
+ * @returns {Function} A new function wrapping the supplied method.
+ */
+export default function deprecate(method, name, message) {
+  let deprecationMessage = `DEPRECATED METHOD: ${name}\n${message} AT \n`;
+  return function() {
+    let e = new Error('get-stack-trace');
+    let stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '')
+        .replace(/^\s+at\s+/gm, '')
+        .replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';
+
+    let log = window.console && (window.console.warn || window.console.log);
+    if (log) {
+      log.call(window.console, deprecationMessage, stack);
+    }
+    return method.apply(this, arguments);
+  };
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/each.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/each.js
@ -0,0 +1,28 @@
+/**
+ * @private
+ * walk objects and arrays
+ * @param {Object} obj
+ * @param {Function} iterator
+ * @param {Object} context
+ */
+export default function each(obj, iterator, context) {
+  let i;
+
+  if (!obj) {
+    return;
+  }
+
+  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);
+    }
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/extend.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/extend.js
@ -0,0 +1,23 @@
+import deprecate from './deprecate';
+/**
+ * @private
+ * extend object.
+ * means that properties in dest will be overwritten by the ones in src.
+ * @param {Object} dest
+ * @param {Object} src
+ * @param {Boolean} [merge=false]
+ * @returns {Object} dest
+ */
+const extend = deprecate((dest, src, merge) => {
+  let keys = Object.keys(src);
+  let i = 0;
+  while (i < keys.length) {
+    if (!merge || (merge && dest[keys[i]] === undefined)) {
+      dest[keys[i]] = src[keys[i]];
+    }
+    i++;
+  }
+  return dest;
+}, 'extend', 'Use `assign`.');
+
+export default extend;
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/get-window-for-element.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/get-window-for-element.js
@ -0,0 +1,10 @@
+/**
+ * @private
+ * get the window object of an element
+ * @param {HTMLElement} element
+ * @returns {DocumentView|Window}
+ */
+export default function getWindowForElement(element) {
+  let doc = element.ownerDocument || element;
+  return (doc.defaultView || doc.parentWindow || window);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/has-parent.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/has-parent.js
@ -0,0 +1,17 @@
+/**
+ * @private
+ * find if a node is in the given parent
+ * @method hasParent
+ * @param {HTMLElement} node
+ * @param {HTMLElement} parent
+ * @return {Boolean} found
+ */
+export default function hasParent(node, parent) {
+  while (node) {
+    if (node === parent) {
+      return true;
+    }
+    node = node.parentNode;
+  }
+  return false;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/if-undefined.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/if-undefined.js
@ -0,0 +1,10 @@
+/**
+ * @private
+ * use the val2 when val1 is undefined
+ * @param {*} val1
+ * @param {*} val2
+ * @returns {*}
+ */
+export default function ifUndefined(val1, val2) {
+  return (val1 === undefined) ? val2 : val1;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/in-array.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/in-array.js
@ -0,0 +1,22 @@
+/**
+ * @private
+ * 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
+ */
+export default function inArray(src, find, findByKey) {
+  if (src.indexOf && !findByKey) {
+    return src.indexOf(find);
+  } else {
+    let i = 0;
+    while (i < src.length) {
+      if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {// do not use === here, test fails
+        return i;
+      }
+      i++;
+    }
+    return -1;
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/in-str.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/in-str.js
@ -0,0 +1,10 @@
+/**
+ * @private
+ * small indexOf wrapper
+ * @param {String} str
+ * @param {String} find
+ * @returns {Boolean} found
+ */
+export default function inStr(str, find) {
+  return str.indexOf(find) > -1;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/inherit.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/inherit.js
@ -0,0 +1,20 @@
+import assign from './assign';
+/**
+ * @private
+ * simple class inheritance
+ * @param {Function} child
+ * @param {Function} base
+ * @param {Object} [properties]
+ */
+export default function inherit(child, base, properties) {
+  let baseP = base.prototype;
+  let childP;
+
+  childP = child.prototype = Object.create(baseP);
+  childP.constructor = child;
+  childP._super = baseP;
+
+  if (properties) {
+    assign(childP, properties);
+  }
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/invoke-array-arg.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/invoke-array-arg.js
@ -0,0 +1,18 @@
+import each from './each';
+/**
+ * @private
+ * 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}
+ */
+export default function invokeArrayArg(arg, fn, context) {
+  if (Array.isArray(arg)) {
+    each(arg, context[fn], context);
+    return true;
+  }
+  return false;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/merge.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/merge.js
@ -0,0 +1,15 @@
+import deprecate from './deprecate';
+import extend from './extend';
+/**
+ * @private
+ * 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
+ */
+const merge = deprecate((dest, src) => {
+  return extend(dest, src, true);
+}, 'merge', 'Use `assign`.');
+
+export default merge;
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/prefixed.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/prefixed.js
@ -0,0 +1,25 @@
+import { VENDOR_PREFIXES } from './utils-consts';
+/**
+ * @private
+ * get the prefixed property
+ * @param {Object} obj
+ * @param {String} property
+ * @returns {String|Undefined} prefixed
+ */
+export default function prefixed(obj, property) {
+  let prefix;
+  let prop;
+  let camelProp = property[0].toUpperCase() + property.slice(1);
+
+  let 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;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/remove-event-listeners.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/remove-event-listeners.js
@ -0,0 +1,14 @@
+import each from './each';
+import splitStr from './split-str';
+/**
+ * @private
+ * removeEventListener with multiple events at once
+ * @param {EventTarget} target
+ * @param {String} types
+ * @param {Function} handler
+ */
+export default function removeEventListeners(target, types, handler) {
+  each(splitStr(types), (type) => {
+    target.removeEventListener(type, handler, false);
+  });
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/set-timeout-context.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/set-timeout-context.js
@ -0,0 +1,13 @@
+import bindFn from './bind-fn';
+
+/**
+ * @private
+ * set a timeout with a given scope
+ * @param {Function} fn
+ * @param {Number} timeout
+ * @param {Object} context
+ * @returns {number}
+ */
+export default function setTimeoutContext(fn, timeout, context) {
+  return setTimeout(bindFn(fn, context), timeout);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/split-str.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/split-str.js
@ -0,0 +1,10 @@
+/**
+ * @private
+ * split string on whitespace
+ * @param {String} str
+ * @returns {Array} words
+ */
+
+export default function splitStr(str) {
+  return str.trim().split(/\s+/g);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/to-array.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/to-array.js
@ -0,0 +1,9 @@
+/**
+ * @private
+ * convert array-like objects to real arrays
+ * @param {Object} obj
+ * @returns {Array}
+ */
+export default function toArray(obj) {
+  return Array.prototype.slice.call(obj, 0);
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/unique-array.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/unique-array.js
@ -0,0 +1,36 @@
+import inArray from './in-array';
+
+/**
+ * @private
+ * 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}]
+ */
+export default function uniqueArray(src, key, sort) {
+  let results = [];
+  let values = [];
+  let i = 0;
+
+  while (i < src.length) {
+    let val = key ? src[i][key] : src[i];
+    if (inArray(values, val) < 0) {
+      results.push(src[i]);
+    }
+    values[i] = val;
+    i++;
+  }
+
+  if (sort) {
+    if (!key) {
+      results = results.sort();
+    } else {
+      results = results.sort((a, b) => {
+        return a[key] > b[key];
+      });
+    }
+  }
+
+  return results;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/unique-id.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/unique-id.js
@ -0,0 +1,9 @@
+/**
+ * @private
+ * get a unique id
+ * @returns {number} uniqueId
+ */
+let _uniqueId = 1;
+export default function uniqueId() {
+  return _uniqueId++;
+}
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/utils-consts.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/src/utils/utils-consts.js
@ -0,0 +1,17 @@
+
+const VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
+const TEST_ELEMENT = typeof document === "undefined" ? {style: {}} : document.createElement('div');
+
+const TYPE_FUNCTION = 'function';
+
+const { round, abs } = Math;
+const { now } = Date;
+
+export {
+    VENDOR_PREFIXES,
+    TEST_ELEMENT,
+    TYPE_FUNCTION,
+    round,
+    abs,
+    now
+};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/testrollup.config.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/testrollup.config.js
@ -0,0 +1,31 @@
+import babel from "rollup-plugin-babel";
+import { uglify } from "rollup-plugin-uglify";
+
+export default [
+	{
+		input: "./tests/index.js",
+		plugins: [babel({ exclude: "node_modules/**" })],
+		output: {
+			format: "umd",
+			name: "Hammer",
+			exports: "default",
+			freeze: false,
+			interop: false,
+			sourcemap: true,
+			file: "./testdist/hammer.js",
+		},
+	},
+	{
+		input: "./tests/index.js",
+		plugins: [babel({ exclude: "node_modules/**" }), uglify({ sourcemap: true })],
+		output: {
+			format: "umd",
+			name: "Hammer",
+			exports: "default",
+			freeze: false,
+			interop: false,
+			sourcemap: true,
+			file: "./testdist/hammer.min.js",
+		},
+	},
+];
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/index.js
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/index.js
@ -0,0 +1,6 @@
+import {Manager, Pan, Pinch, DIRECTION_NONE, DIRECTION_VERTICAL, DIRECTION_HORIZONTAL, DIRECTION_ALL, PointerEventInput, TouchMouseInput, TouchInput, MouseInput} from "../src/index";
+
+console.log(Manager, Pan, Pinch, PointerEventInput, TouchMouseInput, TouchInput, MouseInput, DIRECTION_NONE, DIRECTION_VERTICAL, DIRECTION_HORIZONTAL, DIRECTION_ALL);
+
+
+export default {};
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/assets/style.css
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/assets/style.css
@ -0,0 +1,42 @@
+@import url(http://fonts.googleapis.com/css?family=Open+Sans);
+
+*, *:after, *:before {
+    box-sizing: border-box;
+    -moz-box-sizing: border-box;
+}
+
+html, body {
+    margin: 0;
+    padding: 0;
+    height: 100%;
+    min-height: 100%;
+    background: #eee;
+    font: 13px/1.5em 'Open Sans', Helvetica, Arial, sans-serif;
+}
+
+a {
+    color: #4986e7;
+}
+
+.bg1, .green { background: #42d692; }
+.bg2, .blue { background: #4986e7; }
+.bg3, .red { background: #d06b64; }
+.bg4, .purple { background: #cd74e6; }
+.bg5, .azure { background: #9fe1e7; }
+
+body {
+    margin: 20px;
+}
+
+pre {
+    background: #fff;
+    padding: 20px;
+    margin-bottom: 20px;
+}
+
+.container {
+    max-width: 900px;
+    margin: 0 auto;
+}
+
+.clear { clear: both; }
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/compute_touch_action.html
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/compute_touch_action.html
@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width, user-scalable=no">
+    <title></title>
+</head>
+<body>
+    Open the inspector and play a bit with the touchAction property.
+    <script src="../../dist/hammer.min.js"></script>
+    <script>
+        var mc = new Hammer(document.body);
+        mc.add(new Hammer.Swipe({ direction: Hammer.DIRECTION_HORIZONTAL }));
+        mc.add(new Hammer.Pan({ direction: Hammer.DIRECTION_HORIZONTAL }));
+
+        console.log(document.body.style.touchAction)
+    </script>
+</body>
+</html>
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/input.html
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/input.html
@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1, maximum-scale=1">
+    <meta name="msapplication-tap-highlight" content="no"/>
+    <link rel="stylesheet" href="assets/style.css">
+    <title>Hammer.js</title>
+</head>
+<body>
+    <div class="container">
+        <div id="hit" class="bg1" style="padding: 30px; height: 200px;">
+        </div>
+
+        <pre id="debug" style="overflow:hidden; background: #eee; padding: 15px;"></pre>
+
+        <pre id="log" style="overflow:hidden;"></pre>
+    </div>
+    <script src="../../dist/hammer.js"></script>
+    <script>
+
+        Object.prototype.toDirString = function() {
+            var output = [];
+            for(var key in this) {
+                if(this.hasOwnProperty(key)) {
+                    var value = this[key];
+                    if(Array.isArray(value)) {
+                        value = "Array("+ value.length +"):"+ value;
+                    } else if(value instanceof HTMLElement) {
+                        value = value +" ("+ value.outerHTML.substring(0, 50) +"...)";
+                    }
+                    output.push(key +": "+ value);
+                }
+            }
+            return output.join("\n")
+        };
+
+        var el = document.querySelector("#hit");
+        var log = document.querySelector("#log");
+        var debug = document.querySelector("#debug");
+
+        var mc = new Hammer(el);
+        mc.get('pinch').set({ enable: true });
+
+        mc.on("hammer.input", function(ev) {
+            debug.innerHTML = [ev.srcEvent.type, ev.pointers.length, ev.isFinal, ev.deltaX, ev.deltaY].join("<br>");
+        });
+
+    </script>
+</body>
+</html>
--- a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/log.html
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/log.html
@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1, maximum-scale=1">
+    <link rel="stylesheet" href="assets/style.css">
+    <title>Hammer.js</title>
+</head>
+<body>
+    <div class="container">
+
+        <div id="hit" class="bg1" style="padding: 30px;">
+            <span id="target" class="bg5" style="display: block; height: 100px;"></span>
+        </div>
+
+        <pre id="debug" style="overflow:hidden; background: #eee; padding: 15px;"></pre>
+
+        <pre id="log" style="overflow:hidden;"></pre>
+
+    </div>
+    <script src="../../dist/hammer.min.js"></script>
+    <script>
+
+        Object.prototype.toDirString = function() {
+            var output = [];
+            for(var key in this) {
+                if(this.hasOwnProperty(key)) {
+                    var value = this[key];
+                    if(Array.isArray(value)) {
+                        value = "Array("+ value.length +"):"+ value;
+                    } else if(value instanceof HTMLElement) {
+                        value = value +" ("+ value.outerHTML.substring(0, 50) +"...)";
+                    }
+                    output.push(key +": "+ value);
+                }
+            }
+            return output.join("\n")
+        };
+
+
+        var el = document.querySelector("#hit");
+        var log = document.querySelector("#log");
+        var debug = document.querySelector("#debug");
+
+        var mc = new Hammer(el);
+        mc.get('pinch').set({ enable: true });
+        mc.get('rotate').set({ enable: true });
+        mc.on("swipe pan panstart panmove panend pancancel multipan press pressup pinch rotate tap doubletap",
+                logGesture);
+
+        function DEBUG(str) {
+            debug.textContent = str;
+        }
+        function logGesture(ev) {
+            console.log(ev.timeStamp, ev.type, ev);
+            log.textContent = ev.toDirString();
+        }
+
+    </script>
+</body>
+</html>
--- a/Show More
+++ b/Show More