{"version":3,"file":"js/2309-9ac20220027b474ae9d3.js","mappings":"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","sources":["webpack:///./app/javascript/src/common/logger/treasure-data-logger.js","webpack:///./app/javascript/src/common/logger/console-logger.js","webpack:///./app/javascript/src/common/logger/logger-factory.js","webpack:///./node_modules/babel-runtime/core-js/object/keys.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/object/keys.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_a-function.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_an-object.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_array-includes.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_cof.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_core.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_ctx.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_defined.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_descriptors.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_dom-create.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_enum-bug-keys.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_export.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_fails.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_global.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_has.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_hide.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_ie8-dom-define.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iobject.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_is-object.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_library.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-dp.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys-internal.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-sap.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_property-desc.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_shared-key.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_shared.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-absolute-index.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-integer.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-iobject.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-length.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-object.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-primitive.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_uid.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.keys.js","webpack:///./node_modules/hammerjs/hammer.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/fromArray.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/map.js","webpack:///./node_modules/rxjs/_esm5/internal/scheduled/scheduleArray.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isScheduler.js","webpack:///./node_modules/rxjs/_esm5/internal/util/subscribeToArray.js","webpack:///./node_modules/vue-add-event-listener/index.js","webpack:///./node_modules/vue2-hammer/index.min.js"],"sourcesContent":["export default class TreasureDataLogger {\n  constructor(eventTableName) {\n    if (window.td) {\n      window.td.setSignedMode();\n    } else {\n      // eslint-disable-next-line no-console\n      console.error('TreasureDataLogger was instantiated before td was created');\n    }\n    this.eventTableName = eventTableName;\n  }\n\n  sendEvent(event, value, placeId, mapId, pointId, itemId) {\n    let data = { event: event, value: value, place_id: placeId, map_id: mapId, point_id: pointId, item_id: itemId }\n    if (typeof value === 'object') {\n      data.value = null\n      data = Object.assign(data, value)\n    }\n    console.log('[nc-client-log]', data)\n    window.td.trackEvent(this.eventTableName, data)\n  }\n\n  sendWatchVideoEvent(\n    placeId,\n    mapId, \n    pointId, \n    itemId,\n    videoDuration,\n    videoStart,\n    videoEnd,\n    signed_url_slug,\n    isDownloaded,\n    accountId\n  ) {\n    const data = { \n      event: 'watchVideo', \n      place_id: placeId, \n      map_id: mapId,\n      point_id: pointId,\n      item_id: itemId,\n      video_duration: videoDuration,\n      video_start: videoStart,\n      video_end: videoEnd,\n      signed_url_slug: signed_url_slug,\n      is_downloaded: isDownloaded,\n      account_id: accountId\n    }\n\n    window.td.trackEvent(this.eventTableName, data)\n  }\n}\n","export default class ConsoleLogger {\n  constructor(active = true) {\n    this.active = active;\n  }\n\n  sendEvent(event, value, placeId, mapId, pointId, itemId) {\n    if (!this.active) return;\n\n    let data = { event: event, value: value, place_id: placeId, map_id: mapId, point_id: pointId, item_id: itemId }\n    if (typeof value === 'object') {\n      data.value = null\n      data = Object.assign(data, value)\n    }\n    const array = []\n    for (const key in data) {\n      if (data.hasOwnProperty(key)) {\n        array.push(key + ': ' + data[key])\n      }\n    };\n    const result = array.join(', ')\n    // eslint-disable-next-line no-console\n    console.log(result)\n  }\n\n  sendWatchVideoEvent(\n    placeId,\n    mapId, \n    pointId, \n    itemId,\n    videoDuration,\n    videoStart,\n    videoEnd,\n    signed_url_slug,\n    isDownloaded,\n    accountId\n  ) {\n    const data = { \n      event: 'watchVideo', \n      place_id: placeId, \n      map_id: mapId,\n      point_id: pointId,\n      item_id: itemId,\n      video_duration: videoDuration,\n      video_start: videoStart,\n      video_end: videoEnd,\n      signed_url_slug: signed_url_slug,\n      is_downloaded: isDownloaded,\n      account_id: accountId\n    }\n\n    console.log(data)\n  }\n}\n","import TreasureDataLogger from './treasure-data-logger';\nimport ConsoleLogger from './console-logger';\n\nexport default function createLogger() {\n  if (window.td) {\n    // NOTE: GAとかにも同時に送出したい場合、Facade作って差し替えて下さい\n    return new TreasureDataLogger('panorama_user_event');\n  } else {\n    return new ConsoleLogger();\n  }\n}\n","module.exports = { \"default\": require(\"core-js/library/fn/object/keys\"), __esModule: true };","require('../../modules/es6.object.keys');\nmodule.exports = require('../../modules/_core').Object.keys;\n","module.exports = function (it) {\n  if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n  return it;\n};\n","var isObject = require('./_is-object');\nmodule.exports = function (it) {\n  if (!isObject(it)) throw TypeError(it + ' is not an object!');\n  return it;\n};\n","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject');\nvar toLength = require('./_to-length');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nmodule.exports = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {\n      if (O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","var core = module.exports = { version: '2.6.12' };\nif (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function () {\n  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n});\n","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n  return is ? document.createElement(it) : {};\n};\n","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n","var global = require('./_global');\nvar core = require('./_core');\nvar ctx = require('./_ctx');\nvar hide = require('./_hide');\nvar has = require('./_has');\nvar PROTOTYPE = 'prototype';\n\nvar $export = function (type, name, source) {\n  var IS_FORCED = type & $export.F;\n  var IS_GLOBAL = type & $export.G;\n  var IS_STATIC = type & $export.S;\n  var IS_PROTO = type & $export.P;\n  var IS_BIND = type & $export.B;\n  var IS_WRAP = type & $export.W;\n  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});\n  var expProto = exports[PROTOTYPE];\n  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];\n  var key, own, out;\n  if (IS_GLOBAL) source = name;\n  for (key in source) {\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if (own && has(exports, key)) continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function (C) {\n      var F = function (a, b, c) {\n        if (this instanceof C) {\n          switch (arguments.length) {\n            case 0: return new C();\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if (IS_PROTO) {\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library`\nmodule.exports = $export;\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (e) {\n    return true;\n  }\n};\n","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self\n  // eslint-disable-next-line no-new-func\n  : Function('return this')();\nif (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var dP = require('./_object-dp');\nvar createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function (object, key, value) {\n  return dP.f(object, key, createDesc(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","module.exports = !require('./_descriptors') && !require('./_fails')(function () {\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7;\n});\n","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\n// eslint-disable-next-line no-prototype-builtins\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","module.exports = true;\n","var anObject = require('./_an-object');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar toPrimitive = require('./_to-primitive');\nvar dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return dP(O, P, Attributes);\n  } catch (e) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var has = require('./_has');\nvar toIObject = require('./_to-iobject');\nvar arrayIndexOf = require('./_array-includes')(false);\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function (object, names) {\n  var O = toIObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal');\nvar enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O) {\n  return $keys(O, enumBugKeys);\n};\n","// most Object methods by ES6 should accept primitives\nvar $export = require('./_export');\nvar core = require('./_core');\nvar fails = require('./_fails');\nmodule.exports = function (KEY, exec) {\n  var fn = (core.Object || {})[KEY] || Object[KEY];\n  var exp = {};\n  exp[KEY] = exec(fn);\n  $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","var shared = require('./_shared')('keys');\nvar uid = require('./_uid');\nmodule.exports = function (key) {\n  return shared[key] || (shared[key] = uid(key));\n};\n","var core = require('./_core');\nvar global = require('./_global');\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || (global[SHARED] = {});\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: core.version,\n  mode: require('./_library') ? 'pure' : 'global',\n  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'\n});\n","var toInteger = require('./_to-integer');\nvar max = Math.max;\nvar min = Math.min;\nmodule.exports = function (index, length) {\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n","// 7.1.4 ToInteger\nvar ceil = Math.ceil;\nvar floor = Math.floor;\nmodule.exports = function (it) {\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject');\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return IObject(defined(it));\n};\n","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer');\nvar min = Math.min;\nmodule.exports = function (it) {\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return Object(defined(it));\n};\n","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (it, S) {\n  if (!isObject(it)) return it;\n  var fn, val;\n  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var id = 0;\nvar px = Math.random();\nmodule.exports = function (key) {\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n","// 19.1.2.14 Object.keys(O)\nvar toObject = require('./_to-object');\nvar $keys = require('./_object-keys');\n\nrequire('./_object-sap')('keys', function () {\n  return function keys(it) {\n    return $keys(toObject(it));\n  };\n});\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","/** PURE_IMPORTS_START _Observable,_util_subscribeToArray,_scheduled_scheduleArray PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { subscribeToArray } from '../util/subscribeToArray';\nimport { scheduleArray } from '../scheduled/scheduleArray';\nexport function fromArray(input, scheduler) {\n    if (!scheduler) {\n        return new Observable(subscribeToArray(input));\n    }\n    else {\n        return scheduleArray(input, scheduler);\n    }\n}\n//# sourceMappingURL=fromArray.js.map\n","/** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { Subscriber } from '../Subscriber';\nexport function map(project, thisArg) {\n    return function mapOperation(source) {\n        if (typeof project !== 'function') {\n            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');\n        }\n        return source.lift(new MapOperator(project, thisArg));\n    };\n}\nvar MapOperator = /*@__PURE__*/ (function () {\n    function MapOperator(project, thisArg) {\n        this.project = project;\n        this.thisArg = thisArg;\n    }\n    MapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));\n    };\n    return MapOperator;\n}());\nexport { MapOperator };\nvar MapSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(MapSubscriber, _super);\n    function MapSubscriber(destination, project, thisArg) {\n        var _this = _super.call(this, destination) || this;\n        _this.project = project;\n        _this.count = 0;\n        _this.thisArg = thisArg || _this;\n        return _this;\n    }\n    MapSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.project.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return MapSubscriber;\n}(Subscriber));\n//# sourceMappingURL=map.js.map\n","/** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nexport function scheduleArray(input, scheduler) {\n    return new Observable(function (subscriber) {\n        var sub = new Subscription();\n        var i = 0;\n        sub.add(scheduler.schedule(function () {\n            if (i === input.length) {\n                subscriber.complete();\n                return;\n            }\n            subscriber.next(input[i++]);\n            if (!subscriber.closed) {\n                sub.add(this.schedule());\n            }\n        }));\n        return sub;\n    });\n}\n//# sourceMappingURL=scheduleArray.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function isScheduler(value) {\n    return value && typeof value.schedule === 'function';\n}\n//# sourceMappingURL=isScheduler.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport var subscribeToArray = function (array) {\n    return function (subscriber) {\n        for (var i = 0, len = array.length; i < len && !subscriber.closed; i++) {\n            subscriber.next(array[i]);\n        }\n        subscriber.complete();\n    };\n};\n//# sourceMappingURL=subscribeToArray.js.map\n","const VueAddEventListener = {\n  install(Vue) {\n    Vue.prototype.$listen = function(target, eventType, callback, options) {\n      const self = this\n      if (!self._eventRemovers) {\n        self._eventRemovers = []\n      }\n      target.addEventListener(eventType, callback, options)\n      self._eventRemovers.push({\n        target,\n        remove() {\n          target.removeEventListener(eventType, callback, options)\n          self._eventRemovers = self._eventRemovers.filter(event => event !== this)\n        },\n      })\n    }\n\n    Vue.mixin({\n      destroyed() {\n        if (this._eventRemovers && this._eventRemovers.length) {\n          this._eventRemovers.forEach((eventRemover) => {\n            eventRemover.remove()\n          })\n        }\n      },\n    })\n  },\n}\n\nexport default VueAddEventListener","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.VueHammer=undefined;var _keys=require(\"babel-runtime/core-js/object/keys\");var _keys2=_interopRequireDefault(_keys);var _hammerjs=require(\"hammerjs\");var _hammerjs2=_interopRequireDefault(_hammerjs);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}var gestures=[\"tap\",\"pan\",\"pinch\",\"press\",\"rotate\",\"swipe\"];var subGestures=[\"panstart\",\"panend\",\"panmove\",\"pancancel\",\"pinchstart\",\"pinchmove\",\"pinchend\",\"pinchcancel\",\"pinchin\",\"pinchout\",\"pressup\",\"rotatestart\",\"rotatemove\",\"rotateend\",\"rotatecancel\"];var directions=[\"up\",\"down\",\"left\",\"right\",\"horizontal\",\"vertical\",\"all\"];var VueHammer=exports.VueHammer={config:{},customEvents:{},install:function install(Vue){var _this=this;Vue.directive(\"hammer\",{bind:function bind(el,binding){if(!el.hammer){el.hammer=new _hammerjs2.default.Manager(el)}var mc=el.hammer;var event=binding.arg;if(!event){console.warn(\"[vue-hammer] event type argument is required.\")}el.__hammerConfig=el.__hammerConfig||{};el.__hammerConfig[event]={};var direction=binding.modifiers;el.__hammerConfig[event].direction=el.__hammerConfig[event].direction||[];if((0,_keys2.default)(direction).length){(0,_keys2.default)(direction).filter(function(keyName){return binding.modifiers[keyName]}).forEach(function(keyName){var elDirectionArray=el.__hammerConfig[event].direction;if(elDirectionArray.indexOf(keyName)===-1){elDirectionArray.push(String(keyName))}})}var recognizerType=void 0,recognizer=void 0;if(_this.customEvents[event]){var custom=_this.customEvents[event];recognizerType=custom.type;recognizer=new(_hammerjs2.default[_this.capitalize(recognizerType)])(custom);recognizer.recognizeWith(mc.recognizers);mc.add(recognizer)}else{recognizerType=gestures.find(function(gesture){return gesture===event});var subGesturesType=subGestures.find(function(gesture){return gesture===event});if(!recognizerType&&!subGesturesType){console.warn(\"[vue-hammer] invalid event type: \"+event);return}if(subGesturesType&&el.__hammerConfig[subGesturesType].direction.length!==0){console.warn(\"[vue-hammer] \"+subGesturesType+\" should not have directions\")}if(!recognizerType){return}if(recognizerType===\"tap\"||recognizerType===\"pinch\"||recognizerType===\"press\"||recognizerType===\"rotate\"){if(el.__hammerConfig[recognizerType].direction.length!==0){throw Error(\"[vue-hammer] \"+recognizerType+\" should not have directions\")}}recognizer=mc.get(recognizerType);if(!recognizer){recognizer=new(_hammerjs2.default[_this.capitalize(recognizerType)]);recognizer.recognizeWith(mc.recognizers);mc.add(recognizer)}var globalOptions=_this.config[recognizerType];if(globalOptions){_this.guardDirections(globalOptions);recognizer.set(globalOptions)}var localOptions=el.hammerOptions&&el.hammerOptions[recognizerType];if(localOptions){_this.guardDirections(localOptions);recognizer.set(localOptions)}}},inserted:function inserted(el,binding){var mc=el.hammer;var event=binding.arg;var eventWithDir=subGestures.find(function(subGes){return subGes===event})?event:_this.buildEventWithDirections(event,el.__hammerConfig[event].direction);if(mc.handler){mc.off(eventWithDir,mc.handler)}if(typeof binding.value!==\"function\"){mc.handler=null;console.warn(\"[vue-hammer] invalid handler function for v-hammer: \"+binding.arg)}else{mc.on(eventWithDir,mc.handler=binding.value)}},componentUpdated:function componentUpdated(el,binding){var mc=el.hammer;var event=binding.arg;var eventWithDir=subGestures.find(function(subGes){return subGes===event})?event:_this.buildEventWithDirections(event,el.__hammerConfig[event].direction);if(mc.handler){mc.off(eventWithDir,mc.handler)}if(typeof binding.value!==\"function\"){mc.handler=null;console.warn(\"[vue-hammer] invalid handler function for v-hammer: \"+binding.arg)}else{mc.on(eventWithDir,mc.handler=binding.value)}},unbind:function unbind(el,binding){var mc=el.hammer;var event=binding.arg;var eventWithDir=subGestures.find(function(subGes){return subGes===event})?event:_this.buildEventWithDirections(event,el.__hammerConfig[event].direction);if(mc.handler){el.hammer.off(eventWithDir,mc.handler)}if(!(0,_keys2.default)(mc.handlers).length){el.hammer.destroy();el.hammer=null}}})},guardDirections:function guardDirections(options){var dir=options.direction;if(typeof dir===\"string\"){var hammerDirection=\"DIRECTION_\"+dir.toUpperCase();if(directions.indexOf(dir)>-1&&_hammerjs2.default.hasOwnProperty(hammerDirection)){options.direction=_hammerjs2.default[hammerDirection]}else{console.warn(\"[vue-hammer] invalid direction: \"+dir)}}},buildEventWithDirections:function buildEventWithDirections(eventName,directionArray){var f={};directionArray.forEach(function(dir){dir=dir.toLowerCase();if(dir===\"horizontal\"){f.left=1;f.right=1}else if(dir===\"vertical\"){f.up=1;f.down=1}else if(dir===\"all\"){f.left=1;f.right=1;f.up=1;f.down=1}else{f[dir]=1}});var _directionArray=(0,_keys2.default)(f);if(_directionArray.length===0){return eventName}var eventWithDirArray=_directionArray.map(function(dir){return eventName+dir});return eventWithDirArray.join(\" \")},capitalize:function capitalize(str){return str.charAt(0).toUpperCase()+str.slice(1)}};"],"names":["TreasureDataLogger","eventTableName","_classCallCheck","window","td","setSignedMode","console","error","this","key","value","event","placeId","mapId","pointId","itemId","data","place_id","map_id","point_id","item_id","_typeof","Object","assign","log","trackEvent","videoDuration","videoStart","videoEnd","signed_url_slug","isDownloaded","accountId","video_duration","video_start","video_end","is_downloaded","account_id","ConsoleLogger","active","arguments","length","undefined","array","hasOwnProperty","push","result","join","createLogger","module","exports","require","__esModule","it","TypeError","isObject","toIObject","toLength","toAbsoluteIndex","IS_INCLUDES","$this","el","fromIndex","O","index","toString","call","slice","core","version","__e","aFunction","fn","that","a","b","c","apply","defineProperty","get","document","is","createElement","split","global","ctx","hide","has","PROTOTYPE","$export","type","name","source","own","out","IS_FORCED","F","IS_GLOBAL","G","IS_STATIC","S","IS_PROTO","P","IS_BIND","B","IS_WRAP","W","expProto","target","C","Function","virtual","R","U","exec","e","Math","self","__g","dP","createDesc","object","f","cof","propertyIsEnumerable","anObject","IE8_DOM_DEFINE","toPrimitive","Attributes","arrayIndexOf","IE_PROTO","names","i","$keys","enumBugKeys","keys","fails","KEY","exp","bitmap","enumerable","configurable","writable","shared","uid","SHARED","store","mode","copyright","toInteger","max","min","ceil","floor","isNaN","IObject","defined","val","valueOf","id","px","random","concat","toObject","window2","document2","exportName","VENDOR_PREFIXES","TEST_ELEMENT","TYPE_FUNCTION","round","abs","now","Date","setTimeoutContext","timeout","context","setTimeout","bindFn","invokeArrayArg","arg","Array","isArray","each","obj","iterator","forEach","deprecate","method","message","deprecationMessage","Error","stack","replace","warn","output","nextKey","extend","dest","src","merge2","merge","inherit","child","base","properties","childP","baseP","prototype","create","constructor","_super","boolOrFn","args","ifUndefined","val1","val2","addEventListeners","types","handler","splitStr","addEventListener","removeEventListeners","removeEventListener","hasParent","node","parent","parentNode","inStr","str","find","indexOf","trim","inArray","findByKey","toArray","uniqueArray","sort","results","values","prefixed","property","prefix","prop","camelProp","toUpperCase","_uniqueId","getWindowForElement","element","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","test","navigator","userAgent","INPUT_TYPE_TOUCH","INPUT_TYPE_MOUSE","COMPUTE_INTERVAL","INPUT_START","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","Input","manager","callback","self2","options","inputTarget","domHandler","ev","enable","init","inputHandler","eventType","input","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","offset","offsetDelta","prevDelta","prevInput","x","deltaX","y","deltaY","computeDeltaXY","offsetDirection","getDirection","start","end","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","scale","rotation","getRotation","maxPointers","velocity","velocityX","velocityY","direction","last","lastInterval","v","computeIntervalInputData","srcEvent","computeInputData","emit","recognize","clientX","clientY","p1","p2","props","sqrt","atan2","PI","evEl","evTarget","evWin","destroy","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","MouseInput","pressed","button","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","PointerEventInput","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","toLowerCase","isTouch","storeIndex","pointerId","splice","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SingleTouchInput","started","normalizeSingleTouches","all","touches","changed","changedTouches","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","TouchInput","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","filter","touch","DEDUP_TIMEOUT","TouchMouseInput","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","isSyntheticEvent","t","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","style","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_AUTO","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","getTouchActionProps","TouchAction","set","compute","actions","update","touchAction","recognizers","recognizer","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_POSSIBLE","STATE_FAILED","Recognizer","defaults","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","preset","Manager","handlers","oldCssProps","inputClass","toggleCssProps","item","add","recognizeWith","requireFailure","cssProps","dropRecognizeWith","dropRequireFailure","hasRequireFailures","canRecognizeWith","additionalEvent","tryEmit","canEmit","inputDataClone","reset","process","attrTest","optionPointers","isRecognized","isValid","threshold","directionTest","hasMoved","inOut","time","validPointers","validMovement","validTime","clearTimeout","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","stop","force","stopped","curRecognizer","existing","remove","on","events","off","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","INPUT_MOVE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","Tap","Pan","Swipe","Pinch","Rotate","Press","define","fromArray","scheduler","scheduleArray","Observable","subscribeToArray","map","project","thisArg","lift","MapOperator","MapOperator2","subscriber","subscribe","MapSubscriber","MapSubscriber2","destination","_this","tslib_1","_next","err","next","Subscriber","sub","Subscription","schedule","closed","complete","isScheduler","len","install","Vue","$listen","_eventRemovers","mixin","destroyed","eventRemover","_keys2","_interopRequireDefault","_hammerjs2","default","gestures","subGestures","directions","config","customEvents","directive","bind","binding","hammer","mc","__hammerConfig","modifiers","keyName","elDirectionArray","String","recognizerType","custom","capitalize","subGesturesType","globalOptions","guardDirections","localOptions","hammerOptions","inserted","eventWithDir","subGes","buildEventWithDirections","componentUpdated","unbind","dir","hammerDirection","eventName","directionArray","left","right","up","down","_directionArray","charAt"],"sourceRoot":""}