{"version":3,"sources":["webpack:///./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack:///./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack:///./src/components/organisms/image-zoom/animations.ts","webpack:///./src/components/organisms/image-zoom/ImageZoom.tsx","webpack:///./src/components/organisms/image-zoom/Wrapper.tsx","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack:///./src/images/image-zoom/icon-zoom-in.svg","webpack:///./src/components/atoms/button/Button.tsx","webpack:///./node_modules/ieee754/index.js","webpack:///./src/images/image-zoom/icon-zoom-out.svg","webpack:///./node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/@babel/runtime/regenerator/index.js","webpack:///./node_modules/hammerjs/hammer.js"],"names":["asyncGeneratorStep","gen","resolve","reject","_next","_throw","key","arg","info","value","error","done","Promise","then","_asyncToGenerator","fn","self","this","args","arguments","apply","err","undefined","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","imageZoomAnimation","initial","display","opacity","scale","close","transition","duration","ease","open","ImageZoom","Constructor","protoProps","staticProps","afterRenderQueue","scaleRange","min","max","zoomSliderHeight","navigatorBackgroundPadding","state","top","left","width","height","animateIn","a","animationControls","start","animateOut","set","document","body","style","overflow","onMouseWheel","fabricEvent","image","scaleX","delta","e","deltaY","Math","setImageScale","onObjectMove","applyImagePositionBounds","updateMapControl","mapControl","applyMapControlPositionBounds","updateImagePosition","sliderHandle","applySliderHandleBounds","updateImageScaleBySliderHandle","onSelectionCreated","type","canvas","discardActiveObject","afterCanvasRender","forEach","callback","onZoomInClick","scaleIncrease","onZoomOutClick","scaleDecrease","onPinch","pinchStartScale","onPinchEnd","onMouseUp","onResize","resizeTimeout","window","clearTimeout","setTimeout","resize","calculateCanvasDimensions","calculateCanvasPosition","setDimensions","calcOffset","setImagePosition","updateMap","updateSlider","updateSliderHandle","updateZoomControls","requestRenderAll","fabric","prototype","originX","originY","isDesktopOrDown","componentDidMount","setState","innerHeight","innerWidth","UNSAFE_componentWillReceiveProps","nextProps","src","openPopup","closePopup","Canvas","canvasElement","centeredScaling","preserveObjectStacking","selectionColor","selectionBorderColor","loadAndCreateImage","hasControls","selectable","hoverCursor","moveCursor","add","navigatorBackground","createNavigatorBackground","map","createMap","createMapControl","slider","createSlider","createSliderHandle","iconZoomOut","getZoomOutProperties","zoomOut","iconZoomIn","getZoomInProperties","zoomIn","addEventListeners","queue","removeEventListeners","options","Image","onload","Rect","fill","getMapBackgroundProperties","stroke","strokeWidth","hasBorders","getMapControlProperties","imageElement","getElement","getMapProperties","getSliderProperties","rx","ry","Circle","radius","padding","lockMovementY","getSliderHandleProperties","visible","isMobileOrDown","navigatorWidth","navigatorBackgroundLeft","getHeight","mapHeight","navigatorBackgroundBottom","scaleY","getScalePercentage","widthScale","getWidth","heightScale","setCoords","progress","scaleDiff","imageHeight","imageWidth","viewportCenterObject","on","addEventListener","element","hammer","Hammer","get","enable","dispose","destroy","removeEventListener","push","scaledImageWidth","scaledImageHeight","imageTopLeft","Point","x","y","minTop","maxTop","minLeft","maxLeft","pageHeader","querySelector","clientHeight","render","StyledImageZoom","animate","ref","el","variants","CloseButton","label","buttonCloseText","onClick","onClose","onHoverEnd","onHoverCloseButtonEnd","onHoverStart","onHoverCloseButtonStart","Component","styled","motion","div","Colors","WHITE","Button","rem","Wrapper","dictionary","useDictionary","useAnimation","useAppState","zoomImageSrc","dispatch","onImageZoomClose","useCallback","payload","Actions","SET_ZOOM_IMAGE_SRC","SET_CURSOR_OVERLAY_TYPE","toString","module","exports","Array","isArray","arr","call","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","extraBytes","parts","len2","encodeChunk","lookup","join","Uint8Array","code","Error","indexOf","end","num","output","base64","ieee754","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","__proto__","encodingOrOffset","allocUnsafe","from","TypeError","ArrayBuffer","array","byteOffset","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","slice","fromString","obj","isBuffer","checked","copy","buffer","val","data","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","n","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","fromCharCode","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","typedArraySupport","poolSize","_augment","Symbol","species","allocUnsafeSlow","_isBuffer","compare","concat","list","pos","swap16","swap32","swap64","equals","inspect","match","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","Infinity","leadSurrogate","trim","replace","stringtrim","base64clean","dst","StyledButton","button","SHIP_GREY","ALTO","className","to","as","Link","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","abs","log","LN2","runtime","Op","hasOwn","hasOwnProperty","$Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","create","context","Context","_invoke","method","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","result","__await","unwrapped","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","constructor","displayName","isGeneratorFunction","genFun","ctor","name","mark","setPrototypeOf","awrap","async","iter","keys","object","reverse","pop","skipTempReset","prev","charAt","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","exportName","assign","VENDOR_PREFIXES","TEST_ELEMENT","createElement","round","now","Date","setTimeoutContext","timeout","bindFn","invokeArrayArg","each","deprecate","message","deprecationMessage","stack","console","warn","index","source","nextKey","extend","dest","merge","inherit","child","base","properties","childP","baseP","_super","boolOrFn","ifUndefined","val1","val2","types","handler","splitStr","hasParent","node","parent","parentNode","inStr","find","split","inArray","findByKey","toArray","uniqueArray","sort","results","prefixed","property","prefix","prop","camelProp","toUpperCase","_uniqueId","getWindowForElement","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","test","navigator","userAgent","PROPS_XY","PROPS_CLIENT_XY","Input","manager","inputTarget","domHandler","ev","init","inputHandler","eventType","input","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","offsetDelta","prevDelta","prevInput","deltaX","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","rotation","getRotation","maxPointers","velocity","velocityX","velocityY","direction","last","lastInterval","v","computeIntervalInputData","srcEvent","computeInputData","emit","recognize","clientX","clientY","p1","p2","sqrt","atan2","PI","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MouseInput","pressed","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","2","3","4","5","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","PointerEventInput","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","isTouch","storeIndex","pointerId","splice","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SingleTouchInput","started","normalizeSingleTouches","all","touches","changed","changedTouches","TOUCH_INPUT_MAP","TouchInput","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","filter","touch","TouchMouseInput","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","isSyntheticEvent","t","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","getTouchActionProps","TouchAction","compute","actions","update","touchAction","recognizers","recognizer","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","DIRECTION_LEFT","DIRECTION_UP","preventSrc","Recognizer","defaults","id","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","preset","Manager","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","event","additionalEvent","tryEmit","canEmit","inputDataClone","process","attrTest","optionPointers","isRecognized","isValid","threshold","DIRECTION_HORIZONTAL","directionTest","hasMoved","inOut","time","validPointers","validMovement","validTime","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","inputClass","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","handlers","oldCssProps","toggleCssProps","item","force","stopped","curRecognizer","existing","remove","events","off","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","INPUT_START","INPUT_MOVE","INPUT_END","INPUT_CANCEL","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","STATE_FAILED","DIRECTION_NONE","DIRECTION_RIGHT","DIRECTION_DOWN","DIRECTION_VERTICAL","DIRECTION_ALL","Tap","Pan","Swipe","Pinch","Rotate","Press"],"mappings":"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","file":"12-6c83a5a1718739073c36.js","sourcesContent":["function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}","import { Variants } from 'framer-motion'\n\nexport const imageZoomAnimation: Variants = {\n  initial: {\n    display: 'none',\n    opacity: 0,\n    scale: 0.8,\n  },\n  close: {\n    opacity: 0,\n    scale: 0.8,\n    transition: {\n      duration: 0.3,\n      ease: 'easeOut',\n    },\n  },\n  open: {\n    display: 'block',\n    opacity: 1,\n    scale: 1,\n    transition: {\n      duration: 0.3,\n      ease: 'easeInOut',\n    },\n  },\n}\n","/* eslint-disable no-throw-literal */\nimport { AnimationControls, motion } from 'framer-motion'\nimport Button, { ButtonProps } from '../../atoms/button/Button'\nimport { isDesktopOrDown, isMobileOrDown } from '../../../utils/mediaQueries'\nimport React, { Component } from 'react'\nimport Colors from '../../../tokens/Colors'\nimport { fabric } from 'fabric'\nimport Hammer from 'hammerjs'\nimport iconZoomIn from '../../../images/image-zoom/icon-zoom-in.svg'\nimport iconZoomOut from '../../../images/image-zoom/icon-zoom-out.svg'\nimport { imageZoomAnimation } from './animations'\nimport { rem } from '../../../utils/rem'\nimport styled from 'styled-components'\n\ninterface ScaleRange {\n  max: number\n  min: number\n}\n\nexport interface ImageZoomProps {\n  animationControls: AnimationControls\n  buttonCloseText: string\n  onClose: () => void\n  onHoverCloseButtonEnd: ButtonProps['onHoverEnd']\n  onHoverCloseButtonStart: ButtonProps['onHoverStart']\n  src: string | null\n}\n\ninterface ImageZoomState {\n  height: number\n  left: number\n  top: number\n  width: number\n}\n\nclass ImageZoom extends Component<ImageZoomProps, ImageZoomState> {\n  /**\n   * The element of the component\n   * @var {HTMLCanvasElement}\n   */\n  private element!: HTMLDivElement | null\n\n  /**\n   * The canvas html element\n   * @var {HTMLCanvasElement}\n   */\n  private canvasElement!: HTMLCanvasElement | null\n\n  /**\n   * The Fabric canvas element\n   */\n  private canvas!: fabric.Canvas\n\n  /**\n   * The resize timout handler\n   * @var {number}\n   */\n  private resizeTimeout!: number\n\n  /**\n   * Queue with methods that will execute after render\n   */\n  private afterRenderQueue: (() => void)[] = []\n\n  /**\n   * Default ScaleRange\n   * Will be updated depending on the image size\n   */\n  private scaleRange: ScaleRange = {\n    min: 0,\n    max: 1,\n  }\n\n  /**\n   * The image to display\n   */\n  private image!: fabric.Image\n\n  /**\n   * Dynamic map height\n   * @var {number}\n   */\n  private mapHeight!: number\n\n  /**\n   * The height of the zoom slider\n   * @var {number}\n   */\n  private zoomSliderHeight = 36\n\n  /**\n   * Padding to apply to the navigator background\n   */\n  private navigatorBackgroundPadding = 10\n\n  /**\n   * The state interface\n   */\n  public state: ImageZoomState = {\n    top: 0,\n    left: 0,\n    width: 0,\n    height: 0,\n  }\n\n  /**\n   * The background of the map\n   */\n  private navigatorBackground!: fabric.Rect\n\n  /**\n   * The scaled version of the image\n   * @var {Image}\n   */\n  private map!: fabric.Image\n\n  /**\n   * The map control\n   * @var {Rect}\n   */\n  private mapControl!: fabric.Rect\n\n  /**\n   * @var {Rect}\n   */\n  private slider!: fabric.Rect\n\n  /**\n   * @var {Circle}\n   */\n  private sliderHandle!: fabric.Circle\n\n  /**\n   * @var {Image}\n   */\n  private zoomOut!: fabric.Image\n\n  /**\n   * @var {Image}\n   */\n  private zoomIn!: fabric.Image\n\n  /**\n   * Hammer js instance\n   */\n  private hammer!: HammerManager\n\n  /**\n   * The scale of the image when the pinching starts\n   */\n  private pinchStartScale!: number | null\n\n  /**\n   * Get the width of the navigator based on the window width\n   * @return {number}\n   */\n  private get navigatorWidth(): number {\n    return isDesktopOrDown() ? 220 : 280\n  }\n\n  /**\n   * Get the left position of the navigator\n   * @return {number}\n   */\n  private get navigatorBackgroundLeft(): number {\n    return isDesktopOrDown() ? 30 : 60\n  }\n\n  /**\n   * Get the bottom position of the navigator\n   * @return {number}\n   */\n  private get navigatorBackgroundBottom(): number {\n    return isDesktopOrDown() ? 30 : 60\n  }\n\n  /**\n   * Image Zoom component constructor\n   * @param props\n   */\n  constructor(props: ImageZoomProps) {\n    super(props)\n\n    // Set default fabric properties\n    fabric.Object.prototype.set({\n      originX: 'center',\n      originY: 'center',\n    })\n  }\n\n  public componentDidMount(): void {\n    this.setState({\n      height: window.innerHeight,\n      width: window.innerWidth,\n    })\n  }\n\n  /**\n   * Check if component will receive props\n   * @param nextProps\n   * @param nextContext\n   */\n  public UNSAFE_componentWillReceiveProps(nextProps: ImageZoomProps): void {\n    if (this.props.src === null && nextProps.src) {\n      void this.openPopup(nextProps.src)\n    } else if (this.props.src !== null && nextProps.src === null) {\n      void this.closePopup()\n    }\n  }\n\n  /**\n   * Open the image zoom popup\n   * @param src\n   */\n  private async openPopup(src: string): Promise<void> {\n    // Create the canvas\n    this.canvas = new fabric.Canvas(this.canvasElement, {\n      centeredScaling: true,\n      preserveObjectStacking: true,\n      selectionColor: 'rgba(255, 255, 255, 0)',\n      selectionBorderColor: 'rgba(255, 255, 255, 0)',\n    })\n\n    // Load and create image from src\n    this.image = await this.loadAndCreateImage(src, {\n      hasControls: false,\n      selectable: true,\n      hoverCursor: 'grab',\n      moveCursor: 'grabbing',\n    })\n\n    // Add objects to canvas\n    this.canvas.add(this.image)\n\n    // Set the position of the image\n    this.setImagePosition()\n\n    // Create a background around the map\n    this.navigatorBackground = this.createNavigatorBackground()\n    this.canvas.add(this.navigatorBackground)\n\n    // Create the map\n    this.map = this.createMap()\n    this.canvas.add(this.map)\n\n    // Create the map controls\n    this.mapControl = this.createMapControl()\n    this.canvas.add(this.mapControl)\n\n    // Create slider (background)\n    this.slider = this.createSlider()\n    this.canvas.add(this.slider)\n\n    // Create slider (handle)\n    this.sliderHandle = this.createSliderHandle()\n    this.canvas.add(this.sliderHandle)\n\n    // Create zoom out button\n    this.zoomOut = await this.loadAndCreateImage(iconZoomOut, {\n      selectable: false,\n      hoverCursor: 'pointer',\n      ...this.getZoomOutProperties(),\n    })\n    this.canvas.add(this.zoomOut)\n\n    // Create zoom out button\n    this.zoomIn = await this.loadAndCreateImage(iconZoomIn, {\n      selectable: false,\n      hoverCursor: 'pointer',\n      ...this.getZoomInProperties(),\n    })\n    this.canvas.add(this.zoomIn)\n\n    // Render the canvas\n    this.canvas.requestRenderAll()\n\n    // Add event listeners\n    this.addEventListeners()\n\n    // Resize the canvas\n    this.resize()\n\n    // Animate in\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    this.queue(() => setTimeout(this.animateIn, 100))\n  }\n\n  /**\n   * Close the popup\n   */\n  private async closePopup(): Promise<void> {\n    await this.animateOut()\n    this.removeEventListeners()\n  }\n\n  /**\n   * Load the image and return a fabric Image back\n   * @param src\n   * @param options\n   */\n  private async loadAndCreateImage(\n    src: string,\n    options: fabric.IImageOptions,\n  ): Promise<fabric.Image> {\n    return new Promise(\n      (resolve: (image: fabric.Image) => void, reject: () => void) => {\n        const image = new Image()\n        image.onload = (e: Event): void =>\n          resolve(new fabric.Image(image, options))\n        image.src = src\n      },\n    )\n  }\n\n  /**\n   * Create map background\n   */\n  private createNavigatorBackground(): fabric.Rect {\n    // Double check parameters\n    if (!this.image.width || !this.image.height) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // Return new image based on the main image\n    return new fabric.Rect({\n      fill: 'white',\n      selectable: false,\n      hoverCursor: 'default',\n      ...this.getMapBackgroundProperties(),\n    })\n  }\n\n  /**\n   * Create the map control\n   * @return {Rect}\n   */\n  private createMapControl(): fabric.Rect {\n    return new fabric.Rect({\n      fill: 'rgba(255, 255, 255, .25)',\n      stroke: '#414042',\n      strokeWidth: 1,\n      selectable: true,\n      hasControls: false,\n      hasBorders: false,\n      hoverCursor: 'grab',\n      moveCursor: 'grabbing',\n      ...this.getMapControlProperties(),\n    })\n  }\n\n  /**\n   * Create the map\n   * @return {Image}\n   */\n  private createMap(): fabric.Image {\n    const imageElement = this.image.getElement()\n\n    // Return new image based on the main image\n    return new fabric.Image(imageElement, {\n      hoverCursor: 'default',\n      selectable: false,\n      ...this.getMapProperties(),\n    })\n  }\n\n  /**\n   * Create the background of the slider\n   * @return {Rect}\n   */\n  private createSlider(): fabric.Rect {\n    return new fabric.Rect({\n      ...this.getSliderProperties(),\n      hoverCursor: 'default',\n      selectable: false,\n      height: 6,\n      fill: '#f4f4f4',\n      rx: 3,\n      ry: 3,\n    })\n  }\n\n  /**\n   * Create the slider handle\n   * @return {Circle}\n   */\n  private createSliderHandle(): fabric.Circle {\n    return new fabric.Circle({\n      hoverCursor: 'grab',\n      moveCursor: 'grabbing',\n      radius: 6,\n      padding: 10,\n      hasControls: false,\n      hasBorders: false,\n      fill: '#414042',\n      lockMovementY: true,\n      ...this.getSliderHandleProperties(),\n    })\n  }\n\n  /**\n   * Get the zoom out properties\n   */\n  private getZoomOutProperties(): Record<string, unknown> {\n    const { left, top, width, height } = this.navigatorBackground\n    if (!left || !top || !width || !height) {\n      throw \"Can't get necessary properties\"\n    }\n\n    return {\n      visible: !isMobileOrDown(),\n      top: top - height / 2 + 25,\n      left: left - width / 2 + 25,\n      padding: 10,\n    }\n  }\n\n  /**\n   * Get the zoom out properties\n   */\n  private getZoomInProperties(): Record<string, unknown> {\n    const { left, top, width, height } = this.navigatorBackground\n    if (!left || !top || !width || !height) {\n      throw \"Can't get necessary properties\"\n    }\n    return {\n      visible: !isMobileOrDown(),\n      top: top - height / 2 + 25,\n      left: left + width / 2 - 25,\n      padding: 10,\n    }\n  }\n\n  /**\n   * @return {object}\n   */\n  private getMapProperties(): Record<string, unknown> {\n    // Double check parameters\n    if (!this.image.width || !this.image.height) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // Create scaled reference image\n    const scale = this.navigatorWidth / this.image.width\n    const left =\n      this.navigatorWidth / 2 +\n      this.navigatorBackgroundLeft +\n      this.navigatorBackgroundPadding\n\n    const top =\n      this.canvas.getHeight() -\n      this.mapHeight / 2 -\n      this.navigatorBackgroundBottom -\n      this.navigatorBackgroundPadding\n\n    return {\n      visible: !isMobileOrDown(),\n      scaleX: scale,\n      scaleY: scale,\n      left,\n      top,\n    }\n  }\n\n  /**\n   * @return {Record<string, unknown>}\n   */\n  private getMapBackgroundProperties(): Record<string, unknown> {\n    // Double check parameters\n    if (!this.image.width || !this.image.height) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // Calculate map height and update the property\n    const scale = this.navigatorWidth / this.image.width\n    this.mapHeight = this.image.height * scale\n\n    const left =\n      this.navigatorWidth / 2 +\n      this.navigatorBackgroundLeft +\n      this.navigatorBackgroundPadding\n\n    const top =\n      this.canvas.getHeight() -\n      (this.mapHeight + this.zoomSliderHeight) / 2 -\n      this.navigatorBackgroundBottom -\n      this.navigatorBackgroundPadding\n\n    return {\n      left,\n      top,\n      width: this.navigatorWidth + this.navigatorBackgroundPadding * 2,\n      height:\n        this.mapHeight +\n        this.navigatorBackgroundPadding * 2 +\n        this.zoomSliderHeight,\n      visible: !isMobileOrDown(),\n    }\n  }\n\n  /**\n   * Get slider properties\n   * @return {Record<string, unknown>}\n   */\n  private getSliderProperties(): Record<string, unknown> {\n    const { left, top, width, height } = this.navigatorBackground\n    if (!left || !top || !width || !height) {\n      throw \"Can't get necessary properties\"\n    }\n    return {\n      top: top - height / 2 + 25,\n      left,\n      width: width - 100,\n      visible: !isMobileOrDown(),\n    }\n  }\n\n  /**\n   * Get the slider handle properties\n   */\n  private getSliderHandleProperties(): Record<string, unknown> {\n    // Get the position of the slider as base for the calculations\n    const { left, top, width, height } = this.slider\n\n    if (!left || !top || !width || !height) {\n      throw \"Can't get necessary properties\"\n    }\n\n    const percentage = this.getScalePercentage()\n    const offset = (width / 100) * percentage\n\n    return {\n      left: left - width / 2 + offset,\n      top,\n      visible: !isMobileOrDown(),\n    }\n  }\n\n  /**\n   * Get the percentage\n   * @return {number}\n   */\n  private getScalePercentage(): number {\n    if (!this.image.scaleX) {\n      throw \"Can't get necessary properties\"\n    }\n\n    return (\n      ((this.image.scaleX - this.scaleRange.min) /\n        (this.scaleRange.max - this.scaleRange.min)) *\n      100\n    )\n  }\n\n  /**\n   * Calculate the map control properties\n   * @return {Record<string, unknown>}\n   */\n  private getMapControlProperties(): Record<string, unknown> {\n    if (\n      !this.image.width ||\n      !this.image.top ||\n      !this.image.scaleX ||\n      !this.image.height ||\n      !this.image.scaleY ||\n      !this.image.left ||\n      !this.map.top ||\n      !this.map.left\n    ) {\n      throw \"Can't get necessary properties\"\n    }\n\n    const widthScale =\n      (this.image.width * this.image.scaleX) / this.canvas.getWidth()\n    const heightScale =\n      (this.image.height * this.image.scaleY) / this.canvas.getHeight()\n    const width = this.navigatorWidth / widthScale\n    const height = this.mapHeight / heightScale\n    const top =\n      this.map.top +\n      height / 2 -\n      this.image.top * (height / this.canvas.getHeight())\n    const left =\n      this.map.left +\n      width / 2 -\n      this.image.left * (width / this.canvas.getWidth())\n\n    // Return the width, height, top and left of the image\n    return {\n      visible: !isMobileOrDown(),\n      width,\n      height,\n      top,\n      left,\n    }\n  }\n\n  /**\n   * Update the map control\n   */\n  private updateMapControl(): void {\n    this.mapControl.set({\n      ...this.getMapControlProperties(),\n    })\n    this.mapControl.setCoords()\n  }\n\n  /**\n   * Update the image position based on the map control\n   */\n  private updateImagePosition(): void {\n    if (\n      !this.mapControl.left ||\n      !this.mapControl.width ||\n      !this.map.left ||\n      !this.mapControl.top ||\n      !this.map.top\n    ) {\n      throw \"Can't get necessary properties\"\n    }\n\n    const scale = this.canvas.getWidth() / this.mapControl.width\n    const left =\n      -(this.mapControl.left - this.map.left) * scale +\n      this.canvas.getWidth() / 2\n    const top =\n      -(this.mapControl.top - this.map.top) * scale +\n      this.canvas.getHeight() / 2\n\n    this.image.set({ left, top })\n    this.image.setCoords()\n  }\n\n  /**\n   * Update the scale of the image based on the slider handle\n   */\n  private updateImageScaleBySliderHandle(): void {\n    if (\n      !this.sliderHandle.left ||\n      !this.sliderHandle.width ||\n      !this.slider.width ||\n      !this.slider.left\n    ) {\n      throw \"Can't get necessary properties\"\n    }\n\n    const progress =\n      (this.sliderHandle.left -\n        this.sliderHandle.width / 2 -\n        (this.slider.left - this.slider.width / 2)) /\n      this.slider.width\n    const scaleDiff = this.scaleRange.max - this.scaleRange.min\n    const scale = this.scaleRange.min + scaleDiff * progress\n\n    this.image.set({\n      scaleX: scale,\n      scaleY: scale,\n    })\n    this.image.setCoords()\n  }\n\n  /**\n   * Update the map and the map background\n   */\n  private updateMap(): void {\n    this.navigatorBackground.set({\n      ...this.getMapBackgroundProperties(),\n    })\n    this.map.set({\n      ...this.getMapProperties(),\n    })\n\n    this.navigatorBackground.setCoords()\n    this.map.setCoords()\n  }\n\n  /**\n   * Update the slider\n   */\n  private updateSlider(): void {\n    this.slider.set({\n      ...this.getSliderProperties(),\n    })\n    this.slider.setCoords()\n  }\n\n  /**\n   * Update the position of the zoom controls\n   */\n  private updateZoomControls(): void {\n    // Update zoom in properties\n    this.zoomIn.set({\n      ...this.getZoomInProperties(),\n    })\n    // Update zoom out properties\n    this.zoomOut.set({\n      ...this.getZoomOutProperties(),\n    })\n\n    // Update coords\n    this.zoomIn.setCoords()\n    this.zoomOut.setCoords()\n  }\n\n  /**\n   * Update the slider handle\n   */\n  private updateSliderHandle(): void {\n    this.sliderHandle.set({\n      ...this.getSliderHandleProperties(),\n    })\n    this.sliderHandle.setCoords()\n  }\n\n  /**\n   * Set the position of the image\n   */\n  private setImagePosition(): void {\n    // Get the width and height of the image\n    const imageHeight = this.image.height as number\n    const imageWidth = this.image.width as number\n\n    // Center image\n    this.canvas.viewportCenterObject(this.image)\n\n    // Check how much we have to zoom to fit the image\n    const heightScale = this.canvas.getHeight() / imageHeight\n    const widthScale = this.canvas.getWidth() / imageWidth\n\n    // Pick the lowest value to determine which scale to use\n    const scale = Math.max(heightScale, widthScale)\n\n    // Set the default scale range\n    this.scaleRange.min = scale\n\n    // Always allow to scale to original size\n    this.scaleRange.max = Math.max(scale + 1, 1)\n\n    // Apply scaling\n    this.image.scale(scale)\n    this.image.setCoords()\n  }\n\n  /**\n   * Animate in\n   * @return {Promise}\n   */\n  private animateIn = async (): Promise<unknown> =>\n    this.props.animationControls.start('open')\n\n  /**\n   * Animate out\n   * @return {Promise}\n   */\n  private animateOut = async (): Promise<unknown> =>\n    this.props.animationControls.start('close').then(() => {\n      this.props.animationControls.set({\n        display: 'none',\n      })\n\n      document.body.style.overflow = ''\n    })\n\n  /**\n   * Add event listeners to canvas\n   */\n  private addEventListeners(): void {\n    // Canvas events\n    this.canvas.on('mouse:wheel', this.onMouseWheel)\n    this.canvas.on('mouse:up', this.onMouseUp)\n    this.canvas.on('object:moving', this.onObjectMove)\n    this.canvas.on('selection:created', this.onSelectionCreated)\n    this.canvas.on('after:render', this.afterCanvasRender)\n\n    this.zoomIn.on('mousedown', this.onZoomInClick)\n    this.zoomOut.on('mousedown', this.onZoomOutClick)\n\n    // Window events\n    window.addEventListener('resize', this.onResize)\n\n    // Touch gestures events\n    if (this.element) {\n      this.hammer = new Hammer(this.element)\n      this.hammer.get('pinch').set({ enable: true })\n      this.hammer.on('pinch', this.onPinch)\n      this.hammer.on('pinchend', this.onPinchEnd)\n    }\n  }\n\n  /**\n   * Remove event listeners from canvas\n   */\n  private removeEventListeners(): void {\n    this.canvas.dispose()\n    this.hammer.destroy()\n    window.removeEventListener('resize', this.onResize)\n  }\n\n  /**\n   * Update the scale of the image\n   * @param scale\n   */\n  private setImageScale(scale: number): void {\n    // Apply scaling\n    this.image.scale(scale)\n\n    // Update the map control\n    this.updateMapControl()\n\n    // Cap the map control bounds\n    this.applyMapControlPositionBounds()\n\n    // Cap the image moving capabilities\n    this.applyImagePositionBounds()\n\n    // Update slider handle\n    this.updateSliderHandle()\n\n    // Render the canvas\n    this.canvas.requestRenderAll()\n  }\n\n  /**\n   * Push callback to after render queue\n   * @param callback\n   */\n  public queue(callback: () => void): void {\n    this.afterRenderQueue.push(callback)\n  }\n\n  /**\n   * Canvas mousewheel event\n   * @param {IEvent} fe The fabric event\n   */\n  public onMouseWheel = (fabricEvent: fabric.IEvent): void => {\n    if (!this.image.scaleX) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // Get the original mousewheel event\n    const e = fabricEvent.e as MouseWheelEvent\n    const delta = e.deltaY\n\n    // Apply delta\n    let scale = this.image.scaleX + delta / 200\n\n    // Apply min and max scale values\n    scale = Math.min(scale, this.scaleRange.max)\n    scale = Math.max(scale, this.scaleRange.min)\n\n    this.setImageScale(scale)\n  }\n\n  /**\n   * Object move event handler\n   * Check bounding box while moving the image object\n   */\n  public onObjectMove = (e: fabric.IEvent): void => {\n    if (e.target === this.image) {\n      this.applyImagePositionBounds()\n      this.updateMapControl()\n    }\n\n    if (e.target === this.mapControl) {\n      this.applyMapControlPositionBounds()\n      this.updateImagePosition()\n    }\n\n    if (e.target === this.sliderHandle) {\n      this.applySliderHandleBounds()\n\n      this.updateImageScaleBySliderHandle()\n      this.updateMapControl()\n\n      this.applyMapControlPositionBounds()\n      this.applyImagePositionBounds()\n    }\n  }\n\n  /**\n   * Disable group selection\n   */\n  public onSelectionCreated = (e: fabric.IEvent): void => {\n    if (e.target && e.target.type === 'activeSelection') {\n      this.canvas.discardActiveObject()\n    }\n  }\n\n  /**\n   * After canvas render event handler\n   */\n  public afterCanvasRender = (): void => {\n    // Return if queue is empty\n    if (this.afterRenderQueue.length === 0) {\n      return\n    }\n\n    // Execute each callback\n    this.afterRenderQueue.forEach((callback: () => void) => callback())\n\n    // Reset render queue\n    this.afterRenderQueue = []\n  }\n\n  /**\n   * On zoom in click\n   */\n  public onZoomInClick = (): void => {\n    if (!this.image.scaleX) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // get 10% zoom increase\n    const scaleIncrease = (this.scaleRange.max - this.scaleRange.min) * 0.1\n    const scale = Math.min(\n      this.image.scaleX + scaleIncrease,\n      this.scaleRange.max,\n    )\n\n    this.setImageScale(scale)\n  }\n\n  /**\n   * On zoom out click\n   */\n  public onZoomOutClick = (): void => {\n    if (!this.image.scaleX) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // get 10% zoom decrease\n    const scaleDecrease = (this.scaleRange.max - this.scaleRange.min) * 0.1\n    const scale = Math.max(\n      this.image.scaleX - scaleDecrease,\n      this.scaleRange.min,\n    )\n\n    this.setImageScale(scale)\n  }\n\n  /**\n   * On touch gesture\n   * @param e\n   */\n  public onPinch = (e: HammerInput): void => {\n    // Double check for parameters\n    if (!this.image.scaleX) {\n      return\n    }\n\n    if (!this.pinchStartScale) {\n      this.pinchStartScale = this.image.scaleX\n    }\n\n    let scale = this.pinchStartScale * e.scale\n    scale = Math.min(scale, this.scaleRange.max)\n    scale = Math.max(scale, this.scaleRange.min)\n\n    this.setImageScale(scale)\n  }\n\n  /**\n   * On pinch end event handler\n   */\n  public onPinchEnd = (): void => {\n    // Reset the start scale on end\n    this.pinchStartScale = null\n  }\n\n  /**\n   * Always disable selection when the dragging is stopped\n   */\n  public onMouseUp = (): void => {\n    this.canvas.discardActiveObject()\n  }\n\n  /**\n   * Apply position bounds\n   */\n  private applyImagePositionBounds(): void {\n    // Check if properties exists\n    if (\n      !this.image.left ||\n      !this.image.top ||\n      !this.image.width ||\n      !this.image.scaleX ||\n      !this.image.height ||\n      !this.image.scaleY\n    ) {\n      return\n    }\n\n    // Get the scaled image width and height\n    const scaledImageWidth = this.image.width * this.image.scaleX\n    const scaledImageHeight = this.image.height * this.image.scaleY\n\n    // Get the top left point of the image\n    const imageTopLeft = new fabric.Point(\n      this.image.left - scaledImageWidth / 2,\n      this.image.top - scaledImageHeight / 2,\n    )\n\n    // Cap left position based on image scale\n    if (imageTopLeft.x < this.canvas.getWidth() - scaledImageWidth) {\n      this.image.set({\n        left: this.canvas.getWidth() - scaledImageWidth + scaledImageWidth / 2,\n      })\n    } else if (imageTopLeft.x > 0) {\n      this.image.set({\n        left: scaledImageWidth / 2,\n      })\n    }\n\n    // Cap top position based on image scale\n    if (imageTopLeft.y < this.canvas.getHeight() - scaledImageHeight) {\n      this.image.set({\n        top:\n          this.canvas.getHeight() - scaledImageHeight + scaledImageHeight / 2,\n      })\n    } else if (imageTopLeft.y > 0) {\n      this.image.set({\n        top: scaledImageHeight / 2,\n      })\n    }\n  }\n\n  /**\n   * Apply bounds to map control\n   */\n  private applyMapControlPositionBounds(): void {\n    // Double check properties\n    if (\n      !this.mapControl.top ||\n      !this.map.top ||\n      !this.map.height ||\n      !this.mapControl.height ||\n      !this.map.scaleX ||\n      !this.map.scaleY ||\n      !this.mapControl.width ||\n      !this.map.left ||\n      !this.map.width ||\n      !this.mapControl.left\n    ) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // Apply min height\n    const minTop =\n      this.map.top -\n      (this.map.height * this.map.scaleY - this.mapControl.height) / 2\n    if (this.mapControl.top < minTop) {\n      this.mapControl.set({ top: minTop })\n    }\n\n    // Apply min height\n    const maxTop =\n      this.map.top +\n      (this.map.height * this.map.scaleY - this.mapControl.height) / 2\n    if (this.mapControl.top > maxTop) {\n      this.mapControl.set({ top: maxTop })\n    }\n\n    // Apply min left\n    const minLeft =\n      this.map.left -\n      (this.map.width * this.map.scaleX - this.mapControl.width) / 2\n    if (this.mapControl.left < minLeft) {\n      this.mapControl.set({ left: minLeft })\n    }\n\n    // Apply max left\n    const maxLeft =\n      this.map.left +\n      (this.map.width * this.map.scaleX - this.mapControl.width) / 2\n    if (this.mapControl.left > maxLeft) {\n      this.mapControl.set({ left: maxLeft })\n    }\n  }\n\n  /**\n   * Calculate the width and height of the canvas\n   */\n  private calculateCanvasDimensions(): void {\n    const pageHeader = document.querySelector('.page-header')\n    // Return the full window height if the page header isn't available\n    // or if the show header flag is turned off\n    if (!pageHeader) {\n      this.setState({\n        width: window.innerWidth,\n        height: window.innerHeight,\n      })\n      return\n    }\n    this.setState({\n      width: window.innerWidth,\n      height: window.innerHeight - pageHeader.clientHeight,\n    })\n  }\n\n  /**\n   * Calculate the position of the canvas based on the page header\n   */\n  private calculateCanvasPosition(): void {\n    const pageHeader = document.querySelector('.page-header')\n    // Return the full window height if the page header isn't available\n    if (!pageHeader) {\n      this.setState({\n        left: 0,\n        top: 0,\n      })\n      return\n    }\n    this.setState({\n      left: 0,\n      top: pageHeader.clientHeight,\n    })\n  }\n\n  /**\n   * Apply horizontal bounds for slider handle\n   */\n  public applySliderHandleBounds(): void {\n    if (\n      !this.sliderHandle.left ||\n      !this.sliderHandle.width ||\n      !this.slider.left ||\n      !this.slider.width\n    ) {\n      throw \"Can't get necessary properties\"\n    }\n\n    // Apply min left bounds\n    const minLeft =\n      this.slider.left - this.slider.width / 2 + this.sliderHandle.width / 2\n    if (this.sliderHandle.left < minLeft) {\n      this.sliderHandle.set({ left: minLeft })\n    }\n\n    // Apply max left bounds\n    const maxLeft =\n      this.slider.left + this.slider.width / 2 - this.sliderHandle.width / 2\n    if (this.sliderHandle.left > maxLeft) {\n      this.sliderHandle.set({ left: maxLeft })\n    }\n  }\n\n  /**\n   * Window resize event\n   * @param e\n   */\n  public onResize = (): void => {\n    if (this.resizeTimeout) {\n      window.clearTimeout(this.resizeTimeout)\n    }\n    this.resizeTimeout = window.setTimeout(this.resize, 500)\n  }\n\n  /**\n   * Canvas resize handler\n   */\n  public resize = (): void => {\n    // Apply new size to canvas\n    this.calculateCanvasDimensions()\n    this.calculateCanvasPosition()\n\n    this.canvas.setDimensions({\n      width: this.state.width,\n      height: this.state.height,\n    })\n\n    this.canvas.calcOffset()\n\n    // Set positions of element\n    this.setImagePosition()\n\n    // Update the position of the map\n    this.updateMap()\n\n    // Update the position of the slider\n    this.updateSlider()\n    this.updateSliderHandle()\n    this.updateZoomControls()\n\n    // Update the map control\n    this.updateMapControl()\n\n    // Render the canvas\n    this.canvas.requestRenderAll()\n\n    // Make sure the overflow is still disabled\n    document.body.style.overflow = 'hidden'\n  }\n\n  /**\n   * Render the component\n   */\n  public render(): JSX.Element {\n    return (\n      <StyledImageZoom\n        animate={this.props.animationControls}\n        initial=\"initial\"\n        ref={(el): HTMLDivElement | null => (this.element = el)}\n        style={{\n          top: this.state.top,\n          left: this.state.left,\n          width: this.state.width,\n          height: this.state.height,\n        }}\n        variants={imageZoomAnimation}\n      >\n        <Canvas\n          height={this.state.height}\n          ref={(el): HTMLCanvasElement | null => (this.canvasElement = el)}\n          width={this.state.width}\n        />\n        <CloseButton\n          label={this.props.buttonCloseText}\n          onClick={this.props.onClose}\n          onHoverEnd={this.props.onHoverCloseButtonEnd}\n          onHoverStart={this.props.onHoverCloseButtonStart}\n        />\n      </StyledImageZoom>\n    )\n  }\n}\n\nconst StyledImageZoom = styled(motion.div)`\n  position: fixed;\n  background: ${Colors.WHITE};\n  z-index: 1001;\n`\n\nconst Canvas = styled.canvas`\n  position: absolute;\n  left: 0;\n  top: 0;\n`\n\nconst CloseButton = styled(Button)`\n  position: absolute;\n  top: ${rem(60)};\n  right: ${rem(60)};\n  z-index: 1002;\n`\n\nexport default ImageZoom\n","import React, { FunctionComponent, useCallback } from 'react'\nimport { Actions } from '../../../contexts/app-state/AppStateReducer'\nimport ImageZoom from './ImageZoom'\nimport { useAnimation } from 'framer-motion'\nimport { useAppState } from '../../../contexts/app-state/AppStateContext'\nimport useDictionary from '../../../hooks/use-dictionary/useDictionary'\n\nconst Wrapper: FunctionComponent = () => {\n  const dictionary = useDictionary()\n  const animationControls = useAnimation()\n  const [{ zoomImageSrc }, dispatch] = useAppState()\n\n  const onImageZoomClose = useCallback(() => {\n    dispatch({\n      payload: null,\n      type: Actions.SET_ZOOM_IMAGE_SRC,\n    })\n  }, [])\n\n  const onHoverCloseButtonEnd = useCallback(() => {\n    dispatch({\n      payload: null,\n      type: Actions.SET_CURSOR_OVERLAY_TYPE,\n    })\n  }, [])\n\n  const onHoverCloseButtonStart = useCallback(() => {\n    dispatch({\n      payload: 'minimize',\n      type: Actions.SET_CURSOR_OVERLAY_TYPE,\n    })\n  }, [])\n\n  return (\n    <ImageZoom\n      animationControls={animationControls}\n      buttonCloseText={dictionary.get('buttonCloseText')}\n      onClose={onImageZoomClose}\n      onHoverCloseButtonEnd={onHoverCloseButtonEnd}\n      onHoverCloseButtonStart={onHoverCloseButtonStart}\n      src={zoomImageSrc}\n    />\n  )\n}\n\nexport default Wrapper\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};","'use strict';\n\nexports.byteLength = byteLength;\nexports.toByteArray = toByteArray;\nexports.fromByteArray = fromByteArray;\nvar lookup = [];\nvar revLookup = [];\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i];\n  revLookup[code.charCodeAt(i)] = i;\n} // Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\n\n\nrevLookup['-'.charCodeAt(0)] = 62;\nrevLookup['_'.charCodeAt(0)] = 63;\n\nfunction getLens(b64) {\n  var len = b64.length;\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4');\n  } // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n\n\n  var validLen = b64.indexOf('=');\n  if (validLen === -1) validLen = len;\n  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;\n  return [validLen, placeHoldersLen];\n} // base64 is 4/3 + up to two characters of the original data\n\n\nfunction byteLength(b64) {\n  var lens = getLens(b64);\n  var validLen = lens[0];\n  var placeHoldersLen = lens[1];\n  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n}\n\nfunction _byteLength(b64, validLen, placeHoldersLen) {\n  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n}\n\nfunction toByteArray(b64) {\n  var tmp;\n  var lens = getLens(b64);\n  var validLen = lens[0];\n  var placeHoldersLen = lens[1];\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n  var curByte = 0; // if there are placeholders, only get up to the last complete 4 chars\n\n  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;\n  var i;\n\n  for (i = 0; i < len; i += 4) {\n    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];\n    arr[curByte++] = tmp >> 16 & 0xFF;\n    arr[curByte++] = tmp >> 8 & 0xFF;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;\n    arr[curByte++] = tmp >> 8 & 0xFF;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  return arr;\n}\n\nfunction tripletToBase64(num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];\n}\n\nfunction encodeChunk(uint8, start, end) {\n  var tmp;\n  var output = [];\n\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);\n    output.push(tripletToBase64(tmp));\n  }\n\n  return output.join('');\n}\n\nfunction fromByteArray(uint8) {\n  var tmp;\n  var len = uint8.length;\n  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\n\n  var parts = [];\n  var maxChunkLength = 16383; // must be multiple of 3\n  // go through the array every three bytes, we'll deal with trailing stuff later\n\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));\n  } // pad the end with zeros, but make sure to not forget the extra bytes\n\n\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1];\n    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1];\n    parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');\n  }\n\n  return parts.join('');\n}","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n\n/* eslint-disable no-proto */\n'use strict';\n\nvar base64 = require('base64-js');\n\nvar ieee754 = require('ieee754');\n\nvar isArray = require('isarray');\n\nexports.Buffer = Buffer;\nexports.SlowBuffer = SlowBuffer;\nexports.INSPECT_MAX_BYTES = 50;\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\n\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();\n/*\n * Export kMaxLength after typed array support is determined.\n */\n\nexports.kMaxLength = kMaxLength();\n\nfunction typedArraySupport() {\n  try {\n    var arr = new Uint8Array(1);\n    arr.__proto__ = {\n      __proto__: Uint8Array.prototype,\n      foo: function foo() {\n        return 42;\n      }\n    };\n    return arr.foo() === 42 && // typed array instances can be augmented\n    typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n    arr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction kMaxLength() {\n  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;\n}\n\nfunction createBuffer(that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length');\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length);\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length);\n    }\n\n    that.length = length;\n  }\n\n  return that;\n}\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\n\nfunction Buffer(arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length);\n  } // Common case.\n\n\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error('If encoding is specified then the first argument must be a string');\n    }\n\n    return allocUnsafe(this, arg);\n  }\n\n  return from(this, arg, encodingOrOffset, length);\n}\n\nBuffer.poolSize = 8192; // not used by this implementation\n// TODO: Legacy, not needed anymore. Remove in next major version.\n\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype;\n  return arr;\n};\n\nfunction from(that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number');\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length);\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset);\n  }\n\n  return fromObject(that, value);\n}\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\n\n\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length);\n};\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype;\n  Buffer.__proto__ = Uint8Array;\n\n  if (typeof Symbol !== 'undefined' && Symbol.species && Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    });\n  }\n}\n\nfunction assertSize(size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number');\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative');\n  }\n}\n\nfunction alloc(that, size, fill, encoding) {\n  assertSize(size);\n\n  if (size <= 0) {\n    return createBuffer(that, size);\n  }\n\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);\n  }\n\n  return createBuffer(that, size);\n}\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\n\n\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding);\n};\n\nfunction allocUnsafe(that, size) {\n  assertSize(size);\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\n\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0;\n    }\n  }\n\n  return that;\n}\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\n\n\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size);\n};\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\n\n\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size);\n};\n\nfunction fromString(that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8';\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding');\n  }\n\n  var length = byteLength(string, encoding) | 0;\n  that = createBuffer(that, length);\n  var actual = that.write(string, encoding);\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual);\n  }\n\n  return that;\n}\n\nfunction fromArrayLike(that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0;\n  that = createBuffer(that, length);\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255;\n  }\n\n  return that;\n}\n\nfunction fromArrayBuffer(that, array, byteOffset, length) {\n  array.byteLength; // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds');\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds');\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array);\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset);\n  } else {\n    array = new Uint8Array(array, byteOffset, length);\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array;\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array);\n  }\n\n  return that;\n}\n\nfunction fromObject(that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0;\n    that = createBuffer(that, len);\n\n    if (that.length === 0) {\n      return that;\n    }\n\n    obj.copy(that, 0, 0, len);\n    return that;\n  }\n\n  if (obj) {\n    if (typeof ArrayBuffer !== 'undefined' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0);\n      }\n\n      return fromArrayLike(that, obj);\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data);\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');\n}\n\nfunction checked(length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');\n  }\n\n  return length | 0;\n}\n\nfunction SlowBuffer(length) {\n  if (+length != length) {\n    // eslint-disable-line eqeqeq\n    length = 0;\n  }\n\n  return Buffer.alloc(+length);\n}\n\nBuffer.isBuffer = function isBuffer(b) {\n  return !!(b != null && b._isBuffer);\n};\n\nBuffer.compare = function compare(a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers');\n  }\n\n  if (a === b) return 0;\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n};\n\nBuffer.isEncoding = function isEncoding(encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true;\n\n    default:\n      return false;\n  }\n};\n\nBuffer.concat = function concat(list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers');\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0);\n  }\n\n  var i;\n\n  if (length === undefined) {\n    length = 0;\n\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length;\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length);\n  var pos = 0;\n\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i];\n\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers');\n    }\n\n    buf.copy(buffer, pos);\n    pos += buf.length;\n  }\n\n  return buffer;\n};\n\nfunction byteLength(string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length;\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength;\n  }\n\n  if (typeof string !== 'string') {\n    string = '' + string;\n  }\n\n  var len = string.length;\n  if (len === 0) return 0; // Use a for loop to avoid recursion\n\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len;\n\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length;\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2;\n\n      case 'hex':\n        return len >>> 1;\n\n      case 'base64':\n        return base64ToBytes(string).length;\n\n      default:\n        if (loweredCase) return utf8ToBytes(string).length; // assume utf8\n\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n}\n\nBuffer.byteLength = byteLength;\n\nfunction slowToString(encoding, start, end) {\n  var loweredCase = false; // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n\n  if (start === undefined || start < 0) {\n    start = 0;\n  } // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n\n\n  if (start > this.length) {\n    return '';\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length;\n  }\n\n  if (end <= 0) {\n    return '';\n  } // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n\n\n  end >>>= 0;\n  start >>>= 0;\n\n  if (end <= start) {\n    return '';\n  }\n\n  if (!encoding) encoding = 'utf8';\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end);\n\n      case 'ascii':\n        return asciiSlice(this, start, end);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end);\n\n      case 'base64':\n        return base64Slice(this, start, end);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = (encoding + '').toLowerCase();\n        loweredCase = true;\n    }\n  }\n} // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\n\n\nBuffer.prototype._isBuffer = true;\n\nfunction swap(b, n, m) {\n  var i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n}\n\nBuffer.prototype.swap16 = function swap16() {\n  var len = this.length;\n\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits');\n  }\n\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap32 = function swap32() {\n  var len = this.length;\n\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits');\n  }\n\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3);\n    swap(this, i + 1, i + 2);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap64 = function swap64() {\n  var len = this.length;\n\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits');\n  }\n\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7);\n    swap(this, i + 1, i + 6);\n    swap(this, i + 2, i + 5);\n    swap(this, i + 3, i + 4);\n  }\n\n  return this;\n};\n\nBuffer.prototype.toString = function toString() {\n  var length = this.length | 0;\n  if (length === 0) return '';\n  if (arguments.length === 0) return utf8Slice(this, 0, length);\n  return slowToString.apply(this, arguments);\n};\n\nBuffer.prototype.equals = function equals(b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');\n  if (this === b) return true;\n  return Buffer.compare(this, b) === 0;\n};\n\nBuffer.prototype.inspect = function inspect() {\n  var str = '';\n  var max = exports.INSPECT_MAX_BYTES;\n\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\n    if (this.length > max) str += ' ... ';\n  }\n\n  return '<Buffer ' + str + '>';\n};\n\nBuffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer');\n  }\n\n  if (start === undefined) {\n    start = 0;\n  }\n\n  if (end === undefined) {\n    end = target ? target.length : 0;\n  }\n\n  if (thisStart === undefined) {\n    thisStart = 0;\n  }\n\n  if (thisEnd === undefined) {\n    thisEnd = this.length;\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index');\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0;\n  }\n\n  if (thisStart >= thisEnd) {\n    return -1;\n  }\n\n  if (start >= end) {\n    return 1;\n  }\n\n  start >>>= 0;\n  end >>>= 0;\n  thisStart >>>= 0;\n  thisEnd >>>= 0;\n  if (this === target) return 0;\n  var x = thisEnd - thisStart;\n  var y = end - start;\n  var len = Math.min(x, y);\n  var thisCopy = this.slice(thisStart, thisEnd);\n  var targetCopy = target.slice(start, end);\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i];\n      y = targetCopy[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n}; // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\n\n\nfunction bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1; // Normalize byteOffset\n\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset;\n    byteOffset = 0;\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff;\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000;\n  }\n\n  byteOffset = +byteOffset; // Coerce to Number.\n\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : buffer.length - 1;\n  } // Normalize byteOffset: negative offsets start from the end of the buffer\n\n\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1;else byteOffset = buffer.length - 1;\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0;else return -1;\n  } // Normalize val\n\n\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding);\n  } // Finally, search either indexOf (if dir is true) or lastIndexOf\n\n\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1;\n    }\n\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n  } else if (typeof val === 'number') {\n    val = val & 0xFF; // Search for a byte value [0-255]\n\n    if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n      }\n    }\n\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n  }\n\n  throw new TypeError('val must be string, number or Buffer');\n}\n\nfunction arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1;\n  var arrLength = arr.length;\n  var valLength = val.length;\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase();\n\n    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1;\n      }\n\n      indexSize = 2;\n      arrLength /= 2;\n      valLength /= 2;\n      byteOffset /= 2;\n    }\n  }\n\n  function read(buf, i) {\n    if (indexSize === 1) {\n      return buf[i];\n    } else {\n      return buf.readUInt16BE(i * indexSize);\n    }\n  }\n\n  var i;\n\n  if (dir) {\n    var foundIndex = -1;\n\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i;\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex;\n        foundIndex = -1;\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\n\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true;\n\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false;\n          break;\n        }\n      }\n\n      if (found) return i;\n    }\n  }\n\n  return -1;\n}\n\nBuffer.prototype.includes = function includes(val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1;\n};\n\nBuffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n};\n\nBuffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n};\n\nfunction hexWrite(buf, string, offset, length) {\n  offset = Number(offset) || 0;\n  var remaining = buf.length - offset;\n\n  if (!length) {\n    length = remaining;\n  } else {\n    length = Number(length);\n\n    if (length > remaining) {\n      length = remaining;\n    }\n  } // must be an even number of digits\n\n\n  var strLen = string.length;\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string');\n\n  if (length > strLen / 2) {\n    length = strLen / 2;\n  }\n\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16);\n    if (isNaN(parsed)) return i;\n    buf[offset + i] = parsed;\n  }\n\n  return i;\n}\n\nfunction utf8Write(buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nfunction asciiWrite(buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length);\n}\n\nfunction latin1Write(buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length);\n}\n\nfunction base64Write(buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length);\n}\n\nfunction ucs2Write(buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nBuffer.prototype.write = function write(string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8';\n    length = this.length;\n    offset = 0; // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset;\n    length = this.length;\n    offset = 0; // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0;\n\n    if (isFinite(length)) {\n      length = length | 0;\n      if (encoding === undefined) encoding = 'utf8';\n    } else {\n      encoding = length;\n      length = undefined;\n    } // legacy write(string, encoding, offset, length) - remove in v0.13\n\n  } else {\n    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');\n  }\n\n  var remaining = this.length - offset;\n  if (length === undefined || length > remaining) length = remaining;\n\n  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds');\n  }\n\n  if (!encoding) encoding = 'utf8';\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length);\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length);\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n};\n\nBuffer.prototype.toJSON = function toJSON() {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  };\n};\n\nfunction base64Slice(buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf);\n  } else {\n    return base64.fromByteArray(buf.slice(start, end));\n  }\n}\n\nfunction utf8Slice(buf, start, end) {\n  end = Math.min(buf.length, end);\n  var res = [];\n  var i = start;\n\n  while (i < end) {\n    var firstByte = buf[i];\n    var codePoint = null;\n    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint;\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte;\n          }\n\n          break;\n\n        case 2:\n          secondByte = buf[i + 1];\n\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;\n\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 3:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;\n\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 4:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n          fourthByte = buf[i + 3];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;\n\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD;\n      bytesPerSequence = 1;\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000;\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800);\n      codePoint = 0xDC00 | codePoint & 0x3FF;\n    }\n\n    res.push(codePoint);\n    i += bytesPerSequence;\n  }\n\n  return decodeCodePointsArray(res);\n} // Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\n\n\nvar MAX_ARGUMENTS_LENGTH = 0x1000;\n\nfunction decodeCodePointsArray(codePoints) {\n  var len = codePoints.length;\n\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()\n  } // Decode in chunks to avoid \"call stack size exceeded\".\n\n\n  var res = '';\n  var i = 0;\n\n  while (i < len) {\n    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));\n  }\n\n  return res;\n}\n\nfunction asciiSlice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F);\n  }\n\n  return ret;\n}\n\nfunction latin1Slice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i]);\n  }\n\n  return ret;\n}\n\nfunction hexSlice(buf, start, end) {\n  var len = buf.length;\n  if (!start || start < 0) start = 0;\n  if (!end || end < 0 || end > len) end = len;\n  var out = '';\n\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i]);\n  }\n\n  return out;\n}\n\nfunction utf16leSlice(buf, start, end) {\n  var bytes = buf.slice(start, end);\n  var res = '';\n\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n  }\n\n  return res;\n}\n\nBuffer.prototype.slice = function slice(start, end) {\n  var len = this.length;\n  start = ~~start;\n  end = end === undefined ? len : ~~end;\n\n  if (start < 0) {\n    start += len;\n    if (start < 0) start = 0;\n  } else if (start > len) {\n    start = len;\n  }\n\n  if (end < 0) {\n    end += len;\n    if (end < 0) end = 0;\n  } else if (end > len) {\n    end = len;\n  }\n\n  if (end < start) end = start;\n  var newBuf;\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end);\n    newBuf.__proto__ = Buffer.prototype;\n  } else {\n    var sliceLen = end - start;\n    newBuf = new Buffer(sliceLen, undefined);\n\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start];\n    }\n  }\n\n  return newBuf;\n};\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\n\n\nfunction checkOffset(offset, ext, length) {\n  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length);\n  }\n\n  var val = this[offset + --byteLength];\n  var mul = 1;\n\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  return this[offset];\n};\n\nBuffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] | this[offset + 1] << 8;\n};\n\nBuffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] << 8 | this[offset + 1];\n};\n\nBuffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;\n};\n\nBuffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n};\n\nBuffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n  return val;\n};\n\nBuffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var i = byteLength;\n  var mul = 1;\n  var val = this[offset + --i];\n\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n  return val;\n};\n\nBuffer.prototype.readInt8 = function readInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  if (!(this[offset] & 0x80)) return this[offset];\n  return (0xff - this[offset] + 1) * -1;\n};\n\nBuffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset] | this[offset + 1] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset + 1] | this[offset] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n};\n\nBuffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n};\n\nBuffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return ieee754.read(this, offset, true, 23, 4);\n};\n\nBuffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return ieee754.read(this, offset, false, 23, 4);\n};\n\nBuffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return ieee754.read(this, offset, true, 52, 8);\n};\n\nBuffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return ieee754.read(this, offset, false, 52, 8);\n};\n\nfunction checkInt(buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance');\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds');\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var mul = 1;\n  var i = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nfunction objectWriteUInt16(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\n  return offset + 2;\n};\n\nfunction objectWriteUInt32(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = value >>> 24;\n    this[offset + 2] = value >>> 16;\n    this[offset + 1] = value >>> 8;\n    this[offset] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = 0;\n  var mul = 1;\n  var sub = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1;\n    }\n\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  var sub = 0;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1;\n    }\n\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  if (value < 0) value = 0xff + value + 1;\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nBuffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n    this[offset + 2] = value >>> 16;\n    this[offset + 3] = value >>> 24;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n  if (value < 0) value = 0xffffffff + value + 1;\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nfunction checkIEEE754(buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n  if (offset < 0) throw new RangeError('Index out of range');\n}\n\nfunction writeFloat(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);\n  }\n\n  ieee754.write(buf, value, offset, littleEndian, 23, 4);\n  return offset + 4;\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert);\n};\n\nfunction writeDouble(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);\n  }\n\n  ieee754.write(buf, value, offset, littleEndian, 52, 8);\n  return offset + 8;\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert);\n}; // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\n\nBuffer.prototype.copy = function copy(target, targetStart, start, end) {\n  if (!start) start = 0;\n  if (!end && end !== 0) end = this.length;\n  if (targetStart >= target.length) targetStart = target.length;\n  if (!targetStart) targetStart = 0;\n  if (end > 0 && end < start) end = start; // Copy 0 bytes; we're done\n\n  if (end === start) return 0;\n  if (target.length === 0 || this.length === 0) return 0; // Fatal error conditions\n\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds');\n  }\n\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');\n  if (end < 0) throw new RangeError('sourceEnd out of bounds'); // Are we oob?\n\n  if (end > this.length) end = this.length;\n\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start;\n  }\n\n  var len = end - start;\n  var i;\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else {\n    Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);\n  }\n\n  return len;\n}; // Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\n\n\nBuffer.prototype.fill = function fill(val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start;\n      start = 0;\n      end = this.length;\n    } else if (typeof end === 'string') {\n      encoding = end;\n      end = this.length;\n    }\n\n    if (val.length === 1) {\n      var code = val.charCodeAt(0);\n\n      if (code < 256) {\n        val = code;\n      }\n    }\n\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string');\n    }\n\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding);\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255;\n  } // Invalid ranges are not set to a default, so can range check early.\n\n\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index');\n  }\n\n  if (end <= start) {\n    return this;\n  }\n\n  start = start >>> 0;\n  end = end === undefined ? this.length : end >>> 0;\n  if (!val) val = 0;\n  var i;\n\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val;\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());\n    var len = bytes.length;\n\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len];\n    }\n  }\n\n  return this;\n}; // HELPER FUNCTIONS\n// ================\n\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g;\n\nfunction base64clean(str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, ''); // Node converts strings with length < 2 to ''\n\n  if (str.length < 2) return ''; // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\n  while (str.length % 4 !== 0) {\n    str = str + '=';\n  }\n\n  return str;\n}\n\nfunction stringtrim(str) {\n  if (str.trim) return str.trim();\n  return str.replace(/^\\s+|\\s+$/g, '');\n}\n\nfunction toHex(n) {\n  if (n < 16) return '0' + n.toString(16);\n  return n.toString(16);\n}\n\nfunction utf8ToBytes(string, units) {\n  units = units || Infinity;\n  var codePoint;\n  var length = string.length;\n  var leadSurrogate = null;\n  var bytes = [];\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i); // is surrogate component\n\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        } // valid lead\n\n\n        leadSurrogate = codePoint;\n        continue;\n      } // 2 leads in a row\n\n\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n        leadSurrogate = codePoint;\n        continue;\n      } // valid surrogate pair\n\n\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n    }\n\n    leadSurrogate = null; // encode utf8\n\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break;\n      bytes.push(codePoint);\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break;\n      bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break;\n      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break;\n      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else {\n      throw new Error('Invalid code point');\n    }\n  }\n\n  return bytes;\n}\n\nfunction asciiToBytes(str) {\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF);\n  }\n\n  return byteArray;\n}\n\nfunction utf16leToBytes(str, units) {\n  var c, hi, lo;\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break;\n    c = str.charCodeAt(i);\n    hi = c >> 8;\n    lo = c % 256;\n    byteArray.push(lo);\n    byteArray.push(hi);\n  }\n\n  return byteArray;\n}\n\nfunction base64ToBytes(str) {\n  return base64.toByteArray(base64clean(str));\n}\n\nfunction blitBuffer(src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if (i + offset >= dst.length || i >= src.length) break;\n    dst[i + offset] = src[i];\n  }\n\n  return i;\n}\n\nfunction isnan(val) {\n  return val !== val; // eslint-disable-line no-self-compare\n}","module.exports = \"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMCIgaGVpZ2h0PSIxMCIgdmlld0JveD0iMCAwIDEwIDEwIj4KICA8ZGVmcz4KICAgIDxzdHlsZT4KICAgICAgLmNscy0xIHsKICAgICAgICBmaWxsOiAjNDE0MDQyOwogICAgICAgIGZpbGwtcnVsZTogZXZlbm9kZDsKICAgICAgfQogICAgPC9zdHlsZT4KICA8L2RlZnM+CiAgPHBhdGggaWQ9Il8iIGRhdGEtbmFtZT0iKyIgY2xhc3M9ImNscy0xIiBkPSJNMTY3MywxMzIyaC00djRoLTJ2LTRoLTR2LTJoNHYtNGgydjRoNHYyWiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTE2NjMgLTEzMTYpIi8+Cjwvc3ZnPgo=\"","import { HoverHandlers, motion } from 'framer-motion'\nimport React, { FunctionComponent, MouseEvent } from 'react'\nimport Colors from '../../../tokens/Colors'\nimport { Link } from 'gatsby'\nimport { rem } from '../../../utils/rem'\nimport styled from 'styled-components'\n\nexport interface ButtonProps {\n  className?: string\n  label: string\n  onClick?: (event: MouseEvent<HTMLAnchorElement | HTMLButtonElement>) => void\n  onHoverEnd?: HoverHandlers['onHoverEnd']\n  onHoverStart?: HoverHandlers['onHoverStart']\n  to?: string\n}\n\nconst Button: FunctionComponent<ButtonProps> = ({\n  className,\n  label,\n  to,\n  ...props\n}) =>\n  to ? (\n    <StyledButton as={Link} className={className} to={to} {...props}>\n      {label}\n    </StyledButton>\n  ) : (\n    <StyledButton className={className} {...props}>\n      {label}\n    </StyledButton>\n  )\n\nconst StyledButton = styled(motion.button)`\n  font-size: ${rem(15)};\n  font-weight: 700;\n  background: ${Colors.WHITE};\n  text-decoration: none;\n  color: ${Colors.SHIP_GREY};\n  padding: 0 ${rem(24)};\n  line-height: ${rem(40)};\n  height: ${rem(40)};\n  border-radius: ${rem(20)};\n  display: inline-block;\n  transition: background 200ms ease-out;\n  border: none;\n  cursor: pointer;\n  outline: none;\n\n  &:hover {\n    transition: background 200ms ease-in;\n    background: ${Colors.ALTO};\n  }\n\n  .hide-cursor & {\n    cursor: none;\n  }\n`\n\nexport default Button\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var nBits = -7;\n  var i = isLE ? nBytes - 1 : 0;\n  var d = isLE ? -1 : 1;\n  var s = buffer[offset + i];\n  i += d;\n  e = s & (1 << -nBits) - 1;\n  s >>= -nBits;\n  nBits += eLen;\n\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & (1 << -nBits) - 1;\n  e >>= -nBits;\n  nBits += mLen;\n\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias;\n  } else if (e === eMax) {\n    return m ? NaN : (s ? -1 : 1) * Infinity;\n  } else {\n    m = m + Math.pow(2, mLen);\n    e = e - eBias;\n  }\n\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n};\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;\n  var i = isLE ? 0 : nBytes - 1;\n  var d = isLE ? 1 : -1;\n  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n  value = Math.abs(value);\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0;\n    e = eMax;\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2);\n\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * Math.pow(2, 1 - eBias);\n    }\n\n    if (value * c >= 2) {\n      e++;\n      c /= 2;\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0;\n      e = eMax;\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen);\n      e = e + eBias;\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n      e = 0;\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = e << mLen | m;\n  eLen += mLen;\n\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128;\n};","module.exports = \"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMCIgaGVpZ2h0PSIyIiB2aWV3Qm94PSIwIDAgMTAgMiI+CiAgPGRlZnM+CiAgICA8c3R5bGU+CiAgICAgIC5jbHMtMSB7CiAgICAgICAgZmlsbDogIzQxNDA0MjsKICAgICAgfQogICAgPC9zdHlsZT4KICA8L2RlZnM+CiAgPHJlY3QgaWQ9Il8tIiBkYXRhLW5hbWU9Ii0iIGNsYXNzPSJjbHMtMSIgd2lkdGg9IjEwIiBoZWlnaHQ9IjIiLz4KPC9zdmc+Cg==\"","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","module.exports = require(\"regenerator-runtime\");\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\n  var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\n  var TEST_ELEMENT = document.createElement('div');\n  var TYPE_FUNCTION = 'function';\n  var round = Math.round;\n  var abs = Math.abs;\n  var now = Date.now;\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   */\n\n  function setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\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   */\n\n\n  function invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n      each(arg, context[fn], context);\n      return true;\n    }\n\n    return false;\n  }\n  /**\n   * walk objects and arrays\n   * @param {Object} obj\n   * @param {Function} iterator\n   * @param {Object} context\n   */\n\n\n  function 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\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   * 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   */\n\n\n  function 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, '').replace(/^\\s+at\\s+/gm, '').replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n      var log = window.console && (window.console.warn || window.console.log);\n\n      if (log) {\n        log.call(window.console, deprecationMessage, stack);\n      }\n\n      return method.apply(this, arguments);\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   */\n\n\n  var assign;\n\n  if (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\n      for (var index = 1; index < arguments.length; index++) {\n        var source = arguments[index];\n\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\n      return output;\n    };\n  } else {\n    assign = Object.assign;\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   */\n\n\n  var extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n\n    while (i < keys.length) {\n      if (!merge || merge && dest[keys[i]] === undefined) {\n        dest[keys[i]] = src[keys[i]];\n      }\n\n      i++;\n    }\n\n    return dest;\n  }, 'extend', 'Use `assign`.');\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   */\n\n  var merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n  }, 'merge', 'Use `assign`.');\n  /**\n   * simple class inheritance\n   * @param {Function} child\n   * @param {Function} base\n   * @param {Object} [properties]\n   */\n\n  function inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\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   * simple function bind\n   * @param {Function} fn\n   * @param {Object} context\n   * @returns {Function}\n   */\n\n\n  function bindFn(fn, context) {\n    return function boundFn() {\n      return fn.apply(context, arguments);\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   */\n\n\n  function boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n      return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n\n    return val;\n  }\n  /**\n   * use the val2 when val1 is undefined\n   * @param {*} val1\n   * @param {*} val2\n   * @returns {*}\n   */\n\n\n  function ifUndefined(val1, val2) {\n    return val1 === undefined ? val2 : val1;\n  }\n  /**\n   * addEventListener with multiple events at once\n   * @param {EventTarget} target\n   * @param {String} types\n   * @param {Function} handler\n   */\n\n\n  function addEventListeners(target, types, handler) {\n    each(splitStr(types), function (type) {\n      target.addEventListener(type, handler, false);\n    });\n  }\n  /**\n   * removeEventListener with multiple events at once\n   * @param {EventTarget} target\n   * @param {String} types\n   * @param {Function} handler\n   */\n\n\n  function removeEventListeners(target, types, handler) {\n    each(splitStr(types), function (type) {\n      target.removeEventListener(type, handler, false);\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   */\n\n\n  function hasParent(node, parent) {\n    while (node) {\n      if (node == parent) {\n        return true;\n      }\n\n      node = node.parentNode;\n    }\n\n    return false;\n  }\n  /**\n   * small indexOf wrapper\n   * @param {String} str\n   * @param {String} find\n   * @returns {Boolean} found\n   */\n\n\n  function inStr(str, find) {\n    return str.indexOf(find) > -1;\n  }\n  /**\n   * split string on whitespace\n   * @param {String} str\n   * @returns {Array} words\n   */\n\n\n  function splitStr(str) {\n    return str.trim().split(/\\s+/g);\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   */\n\n\n  function inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n      return src.indexOf(find);\n    } else {\n      var i = 0;\n\n      while (i < src.length) {\n        if (findByKey && src[i][findByKey] == find || !findByKey && src[i] === find) {\n          return i;\n        }\n\n        i++;\n      }\n\n      return -1;\n    }\n  }\n  /**\n   * convert array-like objects to real arrays\n   * @param {Object} obj\n   * @returns {Array}\n   */\n\n\n  function toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\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   */\n\n\n  function 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\n      if (inArray(values, val) < 0) {\n        results.push(src[i]);\n      }\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   * get the prefixed property\n   * @param {Object} obj\n   * @param {String} property\n   * @returns {String|Undefined} prefixed\n   */\n\n\n  function prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n    var i = 0;\n\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\n      i++;\n    }\n\n    return undefined;\n  }\n  /**\n   * get a unique id\n   * @returns {number} uniqueId\n   */\n\n\n  var _uniqueId = 1;\n\n  function uniqueId() {\n    return _uniqueId++;\n  }\n  /**\n   * get the window object of an element\n   * @param {HTMLElement} element\n   * @returns {DocumentView|Window}\n   */\n\n\n  function getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return doc.defaultView || doc.parentWindow || window;\n  }\n\n  var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n  var SUPPORT_TOUCH = ('ontouchstart' in window);\n  var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\n  var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n  var INPUT_TYPE_TOUCH = 'touch';\n  var INPUT_TYPE_PEN = 'pen';\n  var INPUT_TYPE_MOUSE = 'mouse';\n  var INPUT_TYPE_KINECT = 'kinect';\n  var COMPUTE_INTERVAL = 25;\n  var INPUT_START = 1;\n  var INPUT_MOVE = 2;\n  var INPUT_END = 4;\n  var INPUT_CANCEL = 8;\n  var DIRECTION_NONE = 1;\n  var DIRECTION_LEFT = 2;\n  var DIRECTION_RIGHT = 4;\n  var DIRECTION_UP = 8;\n  var DIRECTION_DOWN = 16;\n  var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\n  var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\n  var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n  var PROPS_XY = ['x', 'y'];\n  var PROPS_CLIENT_XY = ['clientX', 'clientY'];\n  /**\n   * create new input type manager\n   * @param {Manager} manager\n   * @param {Function} callback\n   * @returns {Input}\n   * @constructor\n   */\n\n  function 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; // 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\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  Input.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function handler() {},\n\n    /**\n     * bind the events\n     */\n    init: function init() {\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 destroy() {\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   * create new input type manager\n   * called by the Manager constructor\n   * @param {Hammer} manager\n   * @returns {Input}\n   */\n\n  function 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\n    return new Type(manager, inputHandler);\n  }\n  /**\n   * handle input events\n   * @param {Manager} manager\n   * @param {String} eventType\n   * @param {Object} input\n   */\n\n\n  function 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    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n      manager.session = {};\n    } // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n\n\n    input.eventType = eventType; // compute scale, rotation etc\n\n    computeInputData(manager, input); // emit secret event\n\n    manager.emit('hammer.input', input);\n    manager.recognize(input);\n    manager.session.prevInput = input;\n  }\n  /**\n   * extend the data with some usable properties like scale, rotate, velocity etc\n   * @param {Object} manager\n   * @param {Object} input\n   */\n\n\n  function computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length; // store the first input to calculate the distance and direction\n\n    if (!session.firstInput) {\n      session.firstInput = simpleCloneInputData(input);\n    } // to compute scale and rotation we need to store the multiple touches\n\n\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    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\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    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n    input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;\n    computeIntervalInputData(session, input); // find the correct target\n\n    var target = manager.element;\n\n    if (hasParent(input.srcEvent.target, target)) {\n      target = input.srcEvent.target;\n    }\n\n    input.target = target;\n  }\n\n  function 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      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   * velocity is calculated every x ms\n   * @param {Object} session\n   * @param {Object} input\n   */\n\n\n  function computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity,\n        velocityX,\n        velocityY,\n        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      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      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   * create a simple clone from the input used for storage of firstInput and firstMultiple\n   * @param {Object} input\n   * @returns {Object} clonedInputData\n   */\n\n\n  function 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\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   * get the center of all the pointers\n   * @param {Array} pointers\n   * @return {Object} center contains `x` and `y` properties\n   */\n\n\n  function getCenter(pointers) {\n    var pointersLength = pointers.length; // no need to loop when only one touch\n\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,\n        y = 0,\n        i = 0;\n\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   * 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   */\n\n\n  function getVelocity(deltaTime, x, y) {\n    return {\n      x: x / deltaTime || 0,\n      y: y / deltaTime || 0\n    };\n  }\n  /**\n   * get the direction between two points\n   * @param {Number} x\n   * @param {Number} y\n   * @return {Number} direction\n   */\n\n\n  function 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\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\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   */\n\n\n  function getDistance(p1, p2, props) {\n    if (!props) {\n      props = PROPS_XY;\n    }\n\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.sqrt(x * x + y * y);\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   */\n\n\n  function getAngle(p1, p2, props) {\n    if (!props) {\n      props = PROPS_XY;\n    }\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   * 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   */\n\n\n  function getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\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   */\n\n\n  function getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n  }\n\n  var MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n  };\n  var MOUSE_ELEMENT_EVENTS = 'mousedown';\n  var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n  /**\n   * Mouse events input\n   * @constructor\n   * @extends Input\n   */\n\n  function MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n  }\n\n  inherit(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]; // on start we want to have the left mouse button down\n\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      } // mouse must be down\n\n\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  var POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n  }; // in IE10 the pointer types is defined as an enum\n\n  var 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  };\n  var POINTER_ELEMENT_EVENTS = 'pointerdown';\n  var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel'; // IE10 has prefixed support, and case-sensitive\n\n  if (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n  }\n  /**\n   * Pointer events input\n   * @constructor\n   * @extends Input\n   */\n\n\n  function PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n    Input.apply(this, arguments);\n    this.store = this.manager.session.pointerEvents = [];\n  }\n\n  inherit(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      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      var isTouch = pointerType == INPUT_TYPE_TOUCH; // get index of the event in the store\n\n      var storeIndex = inArray(store, ev.pointerId, 'pointerId'); // start and mouse must be down\n\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      } // it not found, so the pointer hasn't been down (so it's probably a hover)\n\n\n      if (storeIndex < 0) {\n        return;\n      } // update the event in the store\n\n\n      store[storeIndex] = ev;\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  var SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n  };\n  var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\n  var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n  /**\n   * Touch events input\n   * @constructor\n   * @extends Input\n   */\n\n  function SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n    Input.apply(this, arguments);\n  }\n\n  inherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n      var type = SINGLE_TOUCH_INPUT_MAP[ev.type]; // should we handle the touch events?\n\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); // when done, reset the started state\n\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   * @this {TouchInput}\n   * @param {Object} ev\n   * @param {Number} type flag\n   * @returns {undefined|Array} [all, changed]\n   */\n\n  function 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\n  var TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n  };\n  var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n  /**\n   * Multi-user touch events input\n   * @constructor\n   * @extends Input\n   */\n\n  function TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n    Input.apply(this, arguments);\n  }\n\n  inherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n      var type = TOUCH_INPUT_MAP[ev.type];\n      var touches = getTouches.call(this, ev, type);\n\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   * @this {TouchInput}\n   * @param {Object} ev\n   * @param {Number} type flag\n   * @returns {undefined|Array} [all, changed]\n   */\n\n  function getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds; // when there is only one touch, the process can be simplified\n\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; // get target touches from touches\n\n    targetTouches = allTouches.filter(function (touch) {\n      return hasParent(touch.target, target);\n    }); // collect touches\n\n    if (type === INPUT_START) {\n      i = 0;\n\n      while (i < targetTouches.length) {\n        targetIds[targetTouches[i].identifier] = true;\n        i++;\n      }\n    } // filter changed touches to only contain touches that exist in the collected target ids\n\n\n    i = 0;\n\n    while (i < changedTouches.length) {\n      if (targetIds[changedTouches[i].identifier]) {\n        changedTargetTouches.push(changedTouches[i]);\n      } // cleanup removed touches\n\n\n      if (type & (INPUT_END | INPUT_CANCEL)) {\n        delete targetIds[changedTouches[i].identifier];\n      }\n\n      i++;\n    }\n\n    if (!changedTargetTouches.length) {\n      return;\n    }\n\n    return [// merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n    uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true), changedTargetTouches];\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\n\n  var DEDUP_TIMEOUT = 2500;\n  var DEDUP_DISTANCE = 25;\n\n  function TouchMouseInput() {\n    Input.apply(this, arguments);\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n    this.primaryTouch = null;\n    this.lastTouches = [];\n  }\n\n  inherit(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      } // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n\n\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\n  function 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\n  function setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n      var lastTouch = {\n        x: touch.clientX,\n        y: touch.clientY\n      };\n      this.lastTouches.push(lastTouch);\n      var lts = this.lastTouches;\n\n      var removeLastTouch = function removeLastTouch() {\n        var i = lts.indexOf(lastTouch);\n\n        if (i > -1) {\n          lts.splice(i, 1);\n        }\n      };\n\n      setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n  }\n\n  function isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX,\n        y = eventData.srcEvent.clientY;\n\n    for (var i = 0; i < this.lastTouches.length; i++) {\n      var t = this.lastTouches[i];\n      var dx = Math.abs(x - t.x),\n          dy = Math.abs(y - t.y);\n\n      if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\n  var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined; // magical touchAction value\n\n  var TOUCH_ACTION_COMPUTE = 'compute';\n  var TOUCH_ACTION_AUTO = 'auto';\n  var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\n\n  var TOUCH_ACTION_NONE = 'none';\n  var TOUCH_ACTION_PAN_X = 'pan-x';\n  var TOUCH_ACTION_PAN_Y = 'pan-y';\n  var TOUCH_ACTION_MAP = getTouchActionProps();\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   */\n\n  function TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n  }\n\n  TouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function set(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\n      this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function update() {\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 compute() {\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 preventDefaults(input) {\n      var srcEvent = input.srcEvent;\n      var direction = input.offsetDirection; // if the touch action did prevented once this session\n\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        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 || hasPanY && direction & DIRECTION_HORIZONTAL || 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 preventSrc(srcEvent) {\n      this.manager.session.prevented = true;\n      srcEvent.preventDefault();\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   */\n\n  function 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); // 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\n    if (hasPanX && hasPanY) {\n      return TOUCH_ACTION_NONE;\n    } // pan-x OR pan-y\n\n\n    if (hasPanX || hasPanY) {\n      return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    } // manipulation\n\n\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n      return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n  }\n\n  function getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n      return false;\n    }\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      // 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   * 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   */\n\n\n  var STATE_POSSIBLE = 1;\n  var STATE_BEGAN = 2;\n  var STATE_CHANGED = 4;\n  var STATE_ENDED = 8;\n  var STATE_RECOGNIZED = STATE_ENDED;\n  var STATE_CANCELLED = 16;\n  var STATE_FAILED = 32;\n  /**\n   * Recognizer\n   * Every recognizer needs to extend from this class.\n   * @constructor\n   * @param {Object} options\n   */\n\n  function Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n    this.id = uniqueId();\n    this.manager = null; // default is enable true\n\n    this.options.enable = ifUndefined(this.options.enable, true);\n    this.state = STATE_POSSIBLE;\n    this.simultaneous = {};\n    this.requireFail = [];\n  }\n\n  Recognizer.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 set(options) {\n      assign(this.options, options); // also update the touchAction, in case something changed about the directions/enabled state\n\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 recognizeWith(otherRecognizer) {\n      if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n        return this;\n      }\n\n      var simultaneous = this.simultaneous;\n      otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n\n      if (!simultaneous[otherRecognizer.id]) {\n        simultaneous[otherRecognizer.id] = otherRecognizer;\n        otherRecognizer.recognizeWith(this);\n      }\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 dropRecognizeWith(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 requireFailure(otherRecognizer) {\n      if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n        return this;\n      }\n\n      var requireFail = this.requireFail;\n      otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n\n      if (inArray(requireFail, otherRecognizer) === -1) {\n        requireFail.push(otherRecognizer);\n        otherRecognizer.requireFailure(this);\n      }\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 dropRequireFailure(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\n      if (index > -1) {\n        this.requireFail.splice(index, 1);\n      }\n\n      return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function hasRequireFailures() {\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 canRecognizeWith(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 emit(input) {\n      var self = this;\n      var state = this.state;\n\n      function emit(event) {\n        self.manager.emit(event, input);\n      } // 'panstart' and 'panmove'\n\n\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) {\n        // additional event(panleft, panright, pinchin, pinchout...)\n        emit(input.additionalEvent);\n      } // panend and pancancel\n\n\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 tryEmit(input) {\n      if (this.canEmit()) {\n        return this.emit(input);\n      } // it's failing anyway\n\n\n      this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function canEmit() {\n      var i = 0;\n\n      while (i < this.requireFail.length) {\n        if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n          return false;\n        }\n\n        i++;\n      }\n\n      return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function recognize(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); // is is enabled and allow recognizing?\n\n      if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n        this.reset();\n        this.state = STATE_FAILED;\n        return;\n      } // reset when we've reached the end\n\n\n      if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n        this.state = STATE_POSSIBLE;\n      }\n\n      this.state = this.process(inputDataClone); // the recognizer has recognized a gesture\n      // so trigger an event\n\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 process(inputData) {},\n    // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function getTouchAction() {},\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 reset() {}\n  };\n  /**\n   * get a usable string, used as event postfix\n   * @param {Const} state\n   * @returns {String} state\n   */\n\n  function 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\n    return '';\n  }\n  /**\n   * direction cons to string\n   * @param {Const} direction\n   * @returns {String}\n   */\n\n\n  function 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\n    return '';\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   */\n\n\n  function getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n\n    if (manager) {\n      return manager.get(otherRecognizer);\n    }\n\n    return otherRecognizer;\n  }\n  /**\n   * This recognizer is just used as a base for the simple attribute recognizers.\n   * @constructor\n   * @extends Recognizer\n   */\n\n\n  function AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n  }\n\n  inherit(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 attrTest(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 process(input) {\n      var state = this.state;\n      var eventType = input.eventType;\n      var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n      var isValid = this.attrTest(input); // on cancel input and we've recognized before, return STATE_CANCELLED\n\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\n        return state | STATE_CHANGED;\n      }\n\n      return STATE_FAILED;\n    }\n  });\n  /**\n   * Pan\n   * Recognized when the pointer is down and moved in the allowed direction.\n   * @constructor\n   * @extends AttrRecognizer\n   */\n\n  function PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n    this.pX = null;\n    this.pY = null;\n  }\n\n  inherit(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    getTouchAction: function getTouchAction() {\n      var direction = this.options.direction;\n      var actions = [];\n\n      if (direction & DIRECTION_HORIZONTAL) {\n        actions.push(TOUCH_ACTION_PAN_Y);\n      }\n\n      if (direction & DIRECTION_VERTICAL) {\n        actions.push(TOUCH_ACTION_PAN_X);\n      }\n\n      return actions;\n    },\n    directionTest: function directionTest(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; // lock to axis?\n\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\n      input.direction = direction;\n      return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n    attrTest: function attrTest(input) {\n      return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));\n    },\n    emit: function emit(input) {\n      this.pX = input.deltaX;\n      this.pY = input.deltaY;\n      var direction = directionStr(input.direction);\n\n      if (direction) {\n        input.additionalEvent = this.options.event + direction;\n      }\n\n      this._super.emit.call(this, input);\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   */\n\n  function PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n  }\n\n  inherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n      event: 'pinch',\n      threshold: 0,\n      pointers: 2\n    },\n    getTouchAction: function getTouchAction() {\n      return [TOUCH_ACTION_NONE];\n    },\n    attrTest: function attrTest(input) {\n      return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n    emit: function emit(input) {\n      if (input.scale !== 1) {\n        var inOut = input.scale < 1 ? 'in' : 'out';\n        input.additionalEvent = this.options.event + inOut;\n      }\n\n      this._super.emit.call(this, input);\n    }\n  });\n  /**\n   * Press\n   * Recognized when the pointer is down for x ms without any movement.\n   * @constructor\n   * @extends Recognizer\n   */\n\n  function PressRecognizer() {\n    Recognizer.apply(this, arguments);\n    this._timer = null;\n    this._input = null;\n  }\n\n  inherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n      event: 'press',\n      pointers: 1,\n      time: 251,\n      // 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 getTouchAction() {\n      return [TOUCH_ACTION_AUTO];\n    },\n    process: function process(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      this._input = input; // we only allow little movement\n      // and we've reached an end event, so a tap is possible\n\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\n      return STATE_FAILED;\n    },\n    reset: function reset() {\n      clearTimeout(this._timer);\n    },\n    emit: function emit(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   * Rotate\n   * Recognized when two or more pointer are moving in a circular motion.\n   * @constructor\n   * @extends AttrRecognizer\n   */\n\n  function RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n  }\n\n  inherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n      event: 'rotate',\n      threshold: 0,\n      pointers: 2\n    },\n    getTouchAction: function getTouchAction() {\n      return [TOUCH_ACTION_NONE];\n    },\n    attrTest: function attrTest(input) {\n      return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\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   */\n\n  function SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n  }\n\n  inherit(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    getTouchAction: function getTouchAction() {\n      return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n    attrTest: function attrTest(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) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers == this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n    emit: function emit(input) {\n      var direction = directionStr(input.offsetDirection);\n\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   * 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   */\n\n  function TapRecognizer() {\n    Recognizer.apply(this, arguments); // previous time and center,\n    // used for tap counting\n\n    this.pTime = false;\n    this.pCenter = false;\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n  }\n\n  inherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n      event: 'tap',\n      pointers: 1,\n      taps: 1,\n      interval: 300,\n      // max time between the multi-tap taps\n      time: 250,\n      // max time of the pointer to be down (like finger on the screen)\n      threshold: 9,\n      // 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 getTouchAction() {\n      return [TOUCH_ACTION_MANIPULATION];\n    },\n    process: function process(input) {\n      var options = this.options;\n      var validPointers = input.pointers.length === options.pointers;\n      var validMovement = input.distance < options.threshold;\n      var validTouchTime = input.deltaTime < options.time;\n      this.reset();\n\n      if (input.eventType & INPUT_START && this.count === 0) {\n        return this.failTimeout();\n      } // we only allow little movement\n      // and we've reached an end event, so a tap is possible\n\n\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        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; // if tap count matches we have recognized it,\n        // else it has began recognizing...\n\n        var tapCount = this.count % options.taps;\n\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\n      return STATE_FAILED;\n    },\n    failTimeout: function failTimeout() {\n      this._timer = setTimeoutContext(function () {\n        this.state = STATE_FAILED;\n      }, this.options.interval, this);\n      return STATE_FAILED;\n    },\n    reset: function reset() {\n      clearTimeout(this._timer);\n    },\n    emit: function emit() {\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   * Simple way to create a manager with a default set of recognizers.\n   * @param {HTMLElement} element\n   * @param {Object} [options]\n   * @constructor\n   */\n\n  function Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n  }\n  /**\n   * @const {string}\n   */\n\n\n  Hammer.VERSION = '2.0.7';\n  /**\n   * default settings\n   * @namespace\n   */\n\n  Hammer.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: [// RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n    [RotateRecognizer, {\n      enable: false\n    }], [PinchRecognizer, {\n      enable: false\n    }, ['rotate']], [SwipeRecognizer, {\n      direction: DIRECTION_HORIZONTAL\n    }], [PanRecognizer, {\n      direction: DIRECTION_HORIZONTAL\n    }, ['swipe']], [TapRecognizer], [TapRecognizer, {\n      event: 'doubletap',\n      taps: 2\n    }, ['tap']], [PressRecognizer]],\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  var STOP = 1;\n  var FORCED_STOP = 2;\n  /**\n   * Manager\n   * @param {HTMLElement} element\n   * @param {Object} [options]\n   * @constructor\n   */\n\n  function Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n    this.options.inputTarget = this.options.inputTarget || element;\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n    toggleCssProps(this, true);\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\n  Manager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function set(options) {\n      assign(this.options, options); // Options that need a little more setup\n\n      if (options.touchAction) {\n        this.touchAction.update();\n      }\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\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 stop(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 recognize(inputData) {\n      var session = this.session;\n\n      if (session.stopped) {\n        return;\n      } // run the touch-action polyfill\n\n\n      this.touchAction.preventDefaults(inputData);\n      var recognizer;\n      var recognizers = this.recognizers; // 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\n      var curRecognizer = session.curRecognizer; // reset when the last recognizer is recognized\n      // or when we're in a new session\n\n      if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) {\n        curRecognizer = session.curRecognizer = null;\n      }\n\n      var i = 0;\n\n      while (i < recognizers.length) {\n        recognizer = recognizers[i]; // 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\n        if (session.stopped !== FORCED_STOP && ( // 1\n        !curRecognizer || recognizer == curRecognizer || // 2\n        recognizer.canRecognizeWith(curRecognizer))) {\n          // 3\n          recognizer.recognize(inputData);\n        } else {\n          recognizer.reset();\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\n\n        if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n          curRecognizer = session.curRecognizer = recognizer;\n        }\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 get(recognizer) {\n      if (recognizer instanceof Recognizer) {\n        return recognizer;\n      }\n\n      var recognizers = this.recognizers;\n\n      for (var i = 0; i < recognizers.length; i++) {\n        if (recognizers[i].options.event == recognizer) {\n          return recognizers[i];\n        }\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 add(recognizer) {\n      if (invokeArrayArg(recognizer, 'add', this)) {\n        return this;\n      } // remove existing\n\n\n      var existing = this.get(recognizer.options.event);\n\n      if (existing) {\n        this.remove(existing);\n      }\n\n      this.recognizers.push(recognizer);\n      recognizer.manager = this;\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 remove(recognizer) {\n      if (invokeArrayArg(recognizer, 'remove', this)) {\n        return this;\n      }\n\n      recognizer = this.get(recognizer); // let's make sure this recognizer exists\n\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 on(events, handler) {\n      if (events === undefined) {\n        return;\n      }\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 off(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 emit(event, data) {\n      // we also want to trigger dom events\n      if (this.options.domEvents) {\n        triggerDomEvent(event, data);\n      } // no handlers, so skip it all\n\n\n      var handlers = this.handlers[event] && this.handlers[event].slice();\n\n      if (!handlers || !handlers.length) {\n        return;\n      }\n\n      data.type = event;\n\n      data.preventDefault = function () {\n        data.srcEvent.preventDefault();\n      };\n\n      var i = 0;\n\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 destroy() {\n      this.element && toggleCssProps(this, false);\n      this.handlers = {};\n      this.session = {};\n      this.input.destroy();\n      this.element = null;\n    }\n  };\n  /**\n   * add/remove the css properties as defined in manager.options.cssProps\n   * @param {Manager} manager\n   * @param {Boolean} add\n   */\n\n  function toggleCssProps(manager, add) {\n    var element = manager.element;\n\n    if (!element.style) {\n      return;\n    }\n\n    var prop;\n    each(manager.options.cssProps, function (value, name) {\n      prop = prefixed(element.style, name);\n\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\n    if (!add) {\n      manager.oldCssProps = {};\n    }\n  }\n  /**\n   * trigger dom event\n   * @param {String} event\n   * @param {Object} data\n   */\n\n\n  function 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\n  assign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\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    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    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\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    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  }); // this prevents errors when Hammer is loaded in the presence of an AMD\n  //  style loader but by script tag, not by the loader.\n\n  var freeGlobal = typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}; // jshint ignore:line\n\n  freeGlobal.Hammer = Hammer;\n\n  if (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})(window, document, 'Hammer');"],"sourceRoot":""}