\n \n ![]()
\n
\n null\n * @param top {Number?null} Vertical scroll position, keeps current if value is null\n * @param animate {Boolean?false} Whether the scrolling should happen using an animation\n * @param zoom {Number?null} Zoom level to go to\n */\n Scroller.prototype.scrollTo = function (left, top, animate, zoom) {\n // Stop deceleration\n if (this.__isDecelerating) {\n Animate_1.core.effect.Animate.stop(this.__isDecelerating);\n this.__isDecelerating = false;\n }\n // Correct coordinates based on new zoom level\n if (zoom != null && zoom !== this.__zoomLevel) {\n if (!this.options.zooming) {\n throw new Error('Zooming is not enabled!');\n }\n left *= zoom;\n top *= zoom;\n // Recompute maximum values while temporary tweaking maximum scroll ranges\n this.__computeScrollMax(zoom);\n }\n else {\n // Keep zoom when not defined\n zoom = this.__zoomLevel;\n }\n if (!this.options.scrollingX) {\n left = this.__scrollLeft;\n }\n else {\n if (this.options.paging) {\n left = Math.round(left / this.__clientWidth) * this.__clientWidth;\n }\n else if (this.options.snapping) {\n left = Math.round(left / this.__snapWidth) * this.__snapWidth;\n }\n }\n if (!this.options.scrollingY) {\n top = this.__scrollTop;\n }\n else {\n if (this.options.paging) {\n top = Math.round(top / this.__clientHeight) * this.__clientHeight;\n }\n else if (this.options.snapping) {\n top = Math.round(top / this.__snapHeight) * this.__snapHeight;\n }\n }\n // Limit for allowed ranges\n left = Math.max(Math.min(this.__maxScrollLeft, left), 0);\n top = Math.max(Math.min(this.__maxScrollTop, top), 0);\n // Don't animate when no change detected, still call publish to make sure\n // that rendered position is really in-sync with internal data\n if (left === this.__scrollLeft && top === this.__scrollTop) {\n animate = false;\n }\n // Publish new values\n if (!this.__isTracking) {\n this.__publish(left, top, zoom, animate);\n }\n };\n /**\n * Scroll by the given offset\n *\n * @param left {Number ? 0} Scroll x-axis by given offset\n * @param top {Number ? 0} Scroll x-axis by given offset\n * @param animate {Boolean ? false} Whether to animate the given change\n */\n Scroller.prototype.scrollBy = function (left, top, animate) {\n var startLeft = this.__isAnimating ? this.__scheduledLeft : this.__scrollLeft;\n var startTop = this.__isAnimating ? this.__scheduledTop : this.__scrollTop;\n this.scrollTo(startLeft + (left || 0), startTop + (top || 0), animate);\n };\n /*\n ---------------------------------------------------------------------------\n EVENT CALLBACKS\n ---------------------------------------------------------------------------\n */\n /**\n * Mouse wheel handler for zooming support\n */\n Scroller.prototype.doMouseZoom = function (wheelDelta, timeStamp, pageX, pageY) {\n var change = wheelDelta > 0 ? 0.97 : 1.03;\n return this.zoomTo(this.__zoomLevel * change, false, pageX - this.__clientLeft, pageY - this.__clientTop);\n };\n /**\n * Touch start handler for scrolling support\n */\n Scroller.prototype.doTouchStart = function (touches, timeStamp) {\n // Array-like check is enough here\n if (touches.length == null) {\n throw new Error('Invalid touch list: ' + touches);\n }\n if (timeStamp instanceof Date) {\n timeStamp = timeStamp.valueOf();\n }\n if (typeof timeStamp !== 'number') {\n throw new Error('Invalid timestamp value: ' + timeStamp);\n }\n // Reset interruptedAnimation flag\n this.__interruptedAnimation = true;\n // Stop deceleration\n if (this.__isDecelerating) {\n Animate_1.core.effect.Animate.stop(this.__isDecelerating);\n this.__isDecelerating = false;\n this.__interruptedAnimation = true;\n }\n // Stop animation\n if (this.__isAnimating) {\n Animate_1.core.effect.Animate.stop(this.__isAnimating);\n this.__isAnimating = false;\n this.__interruptedAnimation = true;\n }\n // Use center point when dealing with two fingers\n var currentTouchLeft, currentTouchTop;\n var isSingleTouch = touches.length === 1;\n if (isSingleTouch) {\n currentTouchLeft = touches[0].pageX;\n currentTouchTop = touches[0].pageY;\n }\n else {\n currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;\n currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;\n }\n // Store initial positions\n this.__initialTouchLeft = currentTouchLeft;\n this.__initialTouchTop = currentTouchTop;\n // Store initial touchList for scale calculation\n this.__initialTouches = touches;\n // Store current zoom level\n this.__zoomLevelStart = this.__zoomLevel;\n // Store initial touch positions\n this.__lastTouchLeft = currentTouchLeft;\n this.__lastTouchTop = currentTouchTop;\n // Store initial move time stamp\n this.__lastTouchMove = timeStamp;\n // Reset initial scale\n this.__lastScale = 1;\n // Reset locking flags\n this.__enableScrollX = !isSingleTouch && this.options.scrollingX;\n this.__enableScrollY = !isSingleTouch && this.options.scrollingY;\n // Reset tracking flag\n this.__isTracking = true;\n // Reset deceleration complete flag\n this.__didDecelerationComplete = false;\n // Dragging starts directly with two fingers, otherwise lazy with an offset\n this.__isDragging = !isSingleTouch;\n // Some features are disabled in multi touch scenarios\n this.__isSingleTouch = isSingleTouch;\n // Clearing data structure\n this.__positions = [];\n };\n /**\n * Touch move handler for scrolling support\n */\n Scroller.prototype.doTouchMove = function (touches, timeStamp, scale) {\n // Array-like check is enough here\n if (touches.length == null) {\n throw new Error('Invalid touch list: ' + touches);\n }\n if (timeStamp instanceof Date) {\n timeStamp = timeStamp.valueOf();\n }\n if (typeof timeStamp !== 'number') {\n throw new Error('Invalid timestamp value: ' + timeStamp);\n }\n // Ignore event when tracking is not enabled (event might be outside of element)\n if (!this.__isTracking) {\n return;\n }\n var currentTouchLeft, currentTouchTop;\n // Compute move based around of center of fingers\n if (touches.length === 2) {\n currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;\n currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;\n // Calculate scale when not present and only when touches are used\n if (!scale && this.options.zooming) {\n scale = this.__getScale(this.__initialTouches, touches);\n }\n }\n else {\n currentTouchLeft = touches[0].pageX;\n currentTouchTop = touches[0].pageY;\n }\n var positions = this.__positions;\n // Are we already is dragging mode?\n if (this.__isDragging) {\n // Compute move distance\n var moveX = currentTouchLeft - this.__lastTouchLeft;\n var moveY = currentTouchTop - this.__lastTouchTop;\n // Read previous scroll position and zooming\n var scrollLeft = this.__scrollLeft;\n var scrollTop = this.__scrollTop;\n var level = this.__zoomLevel;\n // Work with scaling\n if (scale != null && this.options.zooming) {\n var oldLevel = level;\n // Recompute level based on previous scale and new scale\n level = (level / this.__lastScale) * scale;\n // Limit level according to configuration\n level = Math.max(Math.min(level, this.options.maxZoom), this.options.minZoom);\n // Only do further compution when change happened\n if (oldLevel !== level) {\n // Compute relative event position to container\n var currentTouchLeftRel = currentTouchLeft - this.__clientLeft;\n var currentTouchTopRel = currentTouchTop - this.__clientTop;\n // Recompute left and top coordinates based on new zoom level\n scrollLeft = ((currentTouchLeftRel + scrollLeft) * level) / oldLevel - currentTouchLeftRel;\n scrollTop = ((currentTouchTopRel + scrollTop) * level) / oldLevel - currentTouchTopRel;\n // Recompute max scroll values\n this.__computeScrollMax(level);\n }\n }\n if (this.__enableScrollX) {\n scrollLeft -= moveX * this.options.speedMultiplier;\n var maxScrollLeft = this.__maxScrollLeft;\n if (scrollLeft > maxScrollLeft || scrollLeft < 0) {\n // Slow down on the edges\n if (this.options.bouncing) {\n scrollLeft += (moveX / 2) * this.options.speedMultiplier;\n }\n else if (scrollLeft > maxScrollLeft) {\n scrollLeft = maxScrollLeft;\n }\n else {\n scrollLeft = 0;\n }\n }\n }\n // Compute new vertical scroll position\n if (this.__enableScrollY) {\n scrollTop -= moveY * this.options.speedMultiplier;\n var maxScrollTop = this.__maxScrollTop;\n if (scrollTop > maxScrollTop || scrollTop < 0) {\n // Slow down on the edges\n if (this.options.bouncing) {\n scrollTop += (moveY / 2) * this.options.speedMultiplier;\n // Support pull-to-refresh (only when only y is scrollable)\n if (!this.__enableScrollX && this.__refreshHeight != null) {\n if (!this.__refreshActive && scrollTop <= -this.__refreshHeight) {\n this.__refreshActive = true;\n if (this.__refreshActivate) {\n this.__refreshActivate();\n }\n }\n else if (this.__refreshActive && scrollTop > -this.__refreshHeight) {\n this.__refreshActive = false;\n if (this.__refreshDeactivate) {\n this.__refreshDeactivate();\n }\n }\n }\n }\n else if (scrollTop > maxScrollTop) {\n scrollTop = maxScrollTop;\n }\n else {\n scrollTop = 0;\n }\n }\n }\n // Keep list from growing infinitely (holding min 10, max 20 measure points)\n if (positions.length > 60) {\n positions.splice(0, 30);\n }\n // Track scroll movement for decleration\n positions.push(scrollLeft, scrollTop, timeStamp);\n // Sync scroll position\n this.__publish(scrollLeft, scrollTop, level);\n // Otherwise figure out whether we are switching into dragging mode now.\n }\n else {\n var minimumTrackingForScroll = this.options.locking ? 3 : 0;\n var minimumTrackingForDrag = 5;\n var distanceX = Math.abs(currentTouchLeft - this.__initialTouchLeft);\n var distanceY = Math.abs(currentTouchTop - this.__initialTouchTop);\n this.__enableScrollX = this.options.scrollingX && distanceX >= minimumTrackingForScroll;\n this.__enableScrollY = this.options.scrollingY && distanceY >= minimumTrackingForScroll;\n positions.push(this.__scrollLeft, this.__scrollTop, timeStamp);\n this.__isDragging =\n (this.__enableScrollX || this.__enableScrollY) &&\n (distanceX >= minimumTrackingForDrag || distanceY >= minimumTrackingForDrag);\n if (this.__isDragging) {\n this.__interruptedAnimation = false;\n }\n }\n // Update last touch positions and time stamp for next event\n this.__lastTouchLeft = currentTouchLeft;\n this.__lastTouchTop = currentTouchTop;\n this.__lastTouchMove = timeStamp;\n this.__lastScale = scale;\n };\n /**\n * Touch end handler for scrolling support\n */\n Scroller.prototype.doTouchEnd = function (timeStamp) {\n if (timeStamp instanceof Date) {\n timeStamp = timeStamp.valueOf();\n }\n if (typeof timeStamp !== 'number') {\n throw new Error('Invalid timestamp value: ' + timeStamp);\n }\n // Ignore event when tracking is not enabled (no touchstart event on element)\n // This is required as this listener ('touchmove') sits on the document and not on the element itthis.\n if (!this.__isTracking) {\n return;\n }\n // Not touching anymore (when two finger hit the screen there are two touch end events)\n this.__isTracking = false;\n // Be sure to reset the dragging flag now. Here we also detect whether\n // the finger has moved fast enough to switch into a deceleration animation.\n if (this.__isDragging) {\n // Reset dragging flag\n this.__isDragging = false;\n // Start deceleration\n // Verify that the last move detected was in some relevant time frame\n if (this.__isSingleTouch && this.options.animating && timeStamp - this.__lastTouchMove <= 100) {\n // Then figure out what the scroll position was about 100ms ago\n var positions = this.__positions;\n var endPos = positions.length - 1;\n var startPos = endPos;\n // Move pointer to position measured 100ms ago\n for (var i = endPos; i > 0 && positions[i] > this.__lastTouchMove - 100; i -= 3) {\n startPos = i;\n }\n // If start and stop position is identical in a 100ms timeframe,\n // we cannot compute any useful deceleration.\n if (startPos !== endPos) {\n // Compute relative movement between these two points\n var timeOffset = positions[endPos] - positions[startPos];\n var movedLeft = this.__scrollLeft - positions[startPos - 2];\n var movedTop = this.__scrollTop - positions[startPos - 1];\n // Based on 50ms compute the movement to apply for each render step\n this.__decelerationVelocityX = (movedLeft / timeOffset) * (1000 / 60);\n this.__decelerationVelocityY = (movedTop / timeOffset) * (1000 / 60);\n // How much velocity is required to start the deceleration\n var minVelocityToStartDeceleration = this.options.paging || this.options.snapping ? 4 : 1;\n // Verify that we have enough velocity to start deceleration\n if (Math.abs(this.__decelerationVelocityX) > minVelocityToStartDeceleration ||\n Math.abs(this.__decelerationVelocityY) > minVelocityToStartDeceleration) {\n // Deactivate pull-to-refresh when decelerating\n if (!this.__refreshActive) {\n this.__startDeceleration(timeStamp);\n }\n }\n else {\n this.options.scrollingComplete();\n }\n }\n else {\n this.options.scrollingComplete();\n }\n }\n else if (timeStamp - this.__lastTouchMove > 100) {\n this.options.scrollingComplete();\n }\n }\n // If this was a slower move it is per default non decelerated, but this\n // still means that we want snap back to the bounds which is done here.\n // This is placed outside the condition above to improve edge case stability\n // e.g. touchend fired without enabled dragging. This should normally do not\n // have modified the scroll positions or even showed the scrollbars though.\n if (!this.__isDecelerating) {\n if (this.__refreshActive && this.__refreshStart) {\n // Use publish instead of scrollTo to allow scrolling to out of boundary position\n // We don't need to normalize scrollLeft, zoomLevel, etc. here because we only y-scrolling when pull-to-refresh is enabled\n this.__publish(this.__scrollLeft, -this.__refreshHeight, this.__zoomLevel, true);\n if (this.__refreshStart) {\n this.__refreshStart();\n }\n }\n else {\n if (this.__interruptedAnimation || this.__isDragging) {\n this.options.scrollingComplete();\n }\n this.scrollTo(this.__scrollLeft, this.__scrollTop, true, this.__zoomLevel);\n // Directly signalize deactivation (nothing todo on refresh?)\n if (this.__refreshActive) {\n this.__refreshActive = false;\n if (this.__refreshDeactivate) {\n this.__refreshDeactivate();\n }\n }\n }\n }\n // Fully cleanup list\n this.__positions.length = 0;\n };\n /*\n ---------------------------------------------------------------------------\n PRIVATE API\n ---------------------------------------------------------------------------\n */\n /**\n * Applies the scroll position to the content element\n *\n * @param left {Number} Left scroll position\n * @param top {Number} Top scroll position\n * @param animate {Boolean?false} Whether animation should be used to move to the new coordinates\n */\n Scroller.prototype.__publish = function (left, top, zoom, animate) {\n var _this = this;\n // Remember whether we had an animation, then we try to continue based on the current \"drive\" of the animation\n var wasAnimating = this.__isAnimating;\n if (wasAnimating) {\n Animate_1.core.effect.Animate.stop(wasAnimating);\n this.__isAnimating = false;\n }\n if (animate && this.options.animating) {\n // Keep scheduled positions for scrollBy/zoomBy functionality\n this.__scheduledLeft = left;\n this.__scheduledTop = top;\n this.__scheduledZoom = zoom;\n var oldLeft = this.__scrollLeft;\n var oldTop = this.__scrollTop;\n var oldZoom = this.__zoomLevel;\n var diffLeft = left - oldLeft;\n var diffTop = top - oldTop;\n var diffZoom = zoom - oldZoom;\n var step = function (percent, now, render) {\n if (render) {\n _this.__scrollLeft = oldLeft + diffLeft * percent;\n _this.__scrollTop = oldTop + diffTop * percent;\n _this.__zoomLevel = oldZoom + diffZoom * percent;\n // Push values out\n if (_this.__callback) {\n _this.__callback(_this.__scrollLeft, _this.__scrollTop, _this.__zoomLevel);\n }\n }\n };\n var verify = function (id) {\n return _this.__isAnimating === id;\n };\n var completed = function (renderedFramesPerSecond, animationId, wasFinished) {\n if (animationId === _this.__isAnimating) {\n _this.__isAnimating = false;\n }\n if (_this.__didDecelerationComplete || wasFinished) {\n _this.options.scrollingComplete();\n }\n if (_this.options.zooming) {\n _this.__computeScrollMax();\n if (_this.__zoomComplete) {\n _this.__zoomComplete();\n _this.__zoomComplete = null;\n }\n }\n };\n // When continuing based on previous animation we choose an ease-out animation instead of ease-in-out\n this.__isAnimating = Animate_1.core.effect.Animate.start(step, verify, completed, this.options.animationDuration, wasAnimating ? this.easeOutCubic : this.easeInOutCubic);\n }\n else {\n this.__scheduledLeft = this.__scrollLeft = left;\n this.__scheduledTop = this.__scrollTop = top;\n this.__scheduledZoom = this.__zoomLevel = zoom;\n // Push values out\n if (this.__callback) {\n this.__callback(left, top, zoom);\n }\n // Fix max scroll ranges\n if (this.options.zooming) {\n this.__computeScrollMax();\n if (this.__zoomComplete) {\n this.__zoomComplete();\n this.__zoomComplete = null;\n }\n }\n }\n };\n /**\n * Recomputes scroll minimum values based on client dimensions and content dimensions.\n */\n Scroller.prototype.__computeScrollMax = function (zoomLevel) {\n if (zoomLevel === void 0) { zoomLevel = this.__zoomLevel; }\n this.__maxScrollLeft = Math.max(this.__contentWidth * zoomLevel - this.__clientWidth, 0);\n this.__maxScrollTop = Math.max(this.__contentHeight * zoomLevel - this.__clientHeight, 0);\n };\n /*\n ---------------------------------------------------------------------------\n ANIMATION (DECELERATION) SUPPORT\n ---------------------------------------------------------------------------\n */\n /**\n * Called when a touch sequence end and the speed of the finger was high enough\n * to switch into deceleration mode.\n */\n Scroller.prototype.__startDeceleration = function (timeStamp) {\n var _this = this;\n if (this.options.paging) {\n var scrollLeft = Math.max(Math.min(this.__scrollLeft, this.__maxScrollLeft), 0);\n var scrollTop = Math.max(Math.min(this.__scrollTop, this.__maxScrollTop), 0);\n var clientWidth = this.__clientWidth;\n var clientHeight = this.__clientHeight;\n // We limit deceleration not to the min/max values of the allowed range, but to the size of the visible client area.\n // Each page should have exactly the size of the client area.\n this.__minDecelerationScrollLeft = Math.floor(scrollLeft / clientWidth) * clientWidth;\n this.__minDecelerationScrollTop = Math.floor(scrollTop / clientHeight) * clientHeight;\n this.__maxDecelerationScrollLeft = Math.ceil(scrollLeft / clientWidth) * clientWidth;\n this.__maxDecelerationScrollTop = Math.ceil(scrollTop / clientHeight) * clientHeight;\n }\n else {\n this.__minDecelerationScrollLeft = 0;\n this.__minDecelerationScrollTop = 0;\n this.__maxDecelerationScrollLeft = this.__maxScrollLeft;\n this.__maxDecelerationScrollTop = this.__maxScrollTop;\n }\n // Wrap class method\n var step = function (percent, now, render) {\n _this.__stepThroughDeceleration(render);\n };\n // How much velocity is required to keep the deceleration running\n var minVelocityToKeepDecelerating = this.options.snapping ? 4 : 0.001;\n // Detect whether it's still worth to continue animating steps\n // If we are already slow enough to not being user perceivable anymore, we stop the whole process here.\n var verify = function () {\n var shouldContinue = Math.abs(_this.__decelerationVelocityX) >= minVelocityToKeepDecelerating ||\n Math.abs(_this.__decelerationVelocityY) >= minVelocityToKeepDecelerating;\n if (!shouldContinue) {\n _this.__didDecelerationComplete = true;\n }\n return shouldContinue;\n };\n var completed = function (renderedFramesPerSecond, animationId, wasFinished) {\n _this.__isDecelerating = false;\n if (_this.__didDecelerationComplete) {\n _this.options.scrollingComplete();\n }\n // Animate to grid when snapping is active, otherwise just fix out-of-boundary positions\n _this.scrollTo(_this.__scrollLeft, _this.__scrollTop, _this.options.snapping);\n };\n // Start animation and switch on flag\n this.__isDecelerating = Animate_1.core.effect.Animate.start(step, verify, completed);\n };\n /**\n * Called on every step of the animation\n *\n * @param inMemory {Boolean?false} Whether to not render the current step, but keep it in memory only. Used internally only!\n */\n Scroller.prototype.__stepThroughDeceleration = function (render) {\n //\n // COMPUTE NEXT SCROLL POSITION\n //\n // Add deceleration to scroll position\n var scrollLeft = this.__scrollLeft + this.__decelerationVelocityX;\n var scrollTop = this.__scrollTop + this.__decelerationVelocityY;\n //\n // HARD LIMIT SCROLL POSITION FOR NON BOUNCING MODE\n //\n if (!this.options.bouncing) {\n var scrollLeftFixed = Math.max(Math.min(this.__maxDecelerationScrollLeft, scrollLeft), this.__minDecelerationScrollLeft);\n if (scrollLeftFixed !== scrollLeft) {\n scrollLeft = scrollLeftFixed;\n this.__decelerationVelocityX = 0;\n }\n var scrollTopFixed = Math.max(Math.min(this.__maxDecelerationScrollTop, scrollTop), this.__minDecelerationScrollTop);\n if (scrollTopFixed !== scrollTop) {\n scrollTop = scrollTopFixed;\n this.__decelerationVelocityY = 0;\n }\n }\n //\n // UPDATE SCROLL POSITION\n //\n if (render) {\n this.__publish(scrollLeft, scrollTop, this.__zoomLevel);\n }\n else {\n this.__scrollLeft = scrollLeft;\n this.__scrollTop = scrollTop;\n }\n //\n // SLOW DOWN\n //\n // Slow down velocity on every iteration\n if (!this.options.paging) {\n // This is the factor applied to every iteration of the animation\n // to slow down the process. This should emulate natural behavior where\n // objects slow down when the initiator of the movement is removed\n var frictionFactor = 0.95;\n this.__decelerationVelocityX *= frictionFactor;\n this.__decelerationVelocityY *= frictionFactor;\n }\n //\n // BOUNCING SUPPORT\n //\n if (this.options.bouncing) {\n var scrollOutsideX = 0;\n var scrollOutsideY = 0;\n // This configures the amount of change applied to deceleration/acceleration when reaching boundaries\n var penetrationDeceleration = this.options.penetrationDeceleration;\n var penetrationAcceleration = this.options.penetrationAcceleration;\n // Check limits\n if (scrollLeft < this.__minDecelerationScrollLeft) {\n scrollOutsideX = this.__minDecelerationScrollLeft - scrollLeft;\n }\n else if (scrollLeft > this.__maxDecelerationScrollLeft) {\n scrollOutsideX = this.__maxDecelerationScrollLeft - scrollLeft;\n }\n if (scrollTop < this.__minDecelerationScrollTop) {\n scrollOutsideY = this.__minDecelerationScrollTop - scrollTop;\n }\n else if (scrollTop > this.__maxDecelerationScrollTop) {\n scrollOutsideY = this.__maxDecelerationScrollTop - scrollTop;\n }\n // Slow down until slow enough, then flip back to snap position\n if (scrollOutsideX !== 0) {\n if (scrollOutsideX * this.__decelerationVelocityX <= 0) {\n this.__decelerationVelocityX += scrollOutsideX * penetrationDeceleration;\n }\n else {\n this.__decelerationVelocityX = scrollOutsideX * penetrationAcceleration;\n }\n }\n if (scrollOutsideY !== 0) {\n if (scrollOutsideY * this.__decelerationVelocityY <= 0) {\n this.__decelerationVelocityY += scrollOutsideY * penetrationDeceleration;\n }\n else {\n this.__decelerationVelocityY = scrollOutsideY * penetrationAcceleration;\n }\n }\n }\n };\n /**\n * calculate the distance between two touches\n * @param {Touch} touch1\n * @param {Touch} touch2\n * @returns {Number} distance\n */\n Scroller.prototype.__getDistance = function (touch1, touch2) {\n var x = touch2.pageX - touch1.pageX, y = touch2.pageY - touch1.pageY;\n return Math.sqrt(x * x + y * y);\n };\n /**\n * calculate the scale factor between two touchLists (fingers)\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start\n * @param {Array} end\n * @returns {Number} scale\n */\n Scroller.prototype.__getScale = function (start, end) {\n // need two fingers...\n if (start.length >= 2 && end.length >= 2) {\n return this.__getDistance(end[0], end[1]) / this.__getDistance(start[0], start[1]);\n }\n return 1;\n };\n return Scroller;\n}());\nexports.Scroller = Scroller;\n","\"use strict\";\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./EasyScroller\"));\n__export(require(\"./Scroller\"));\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"image-wraper\"},[_c('div',{staticClass:\"image-wiew\",attrs:{\"id\":_vm.domId}},[_c('img',{attrs:{\"src\":_vm.src}})])])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n