https://www.hokuyobank.co.jp/person/service/app/lp/hokuyo_app/assets/libs/gsap/Observer.js

1function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
2
3function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
4
5/*!
6 * Observer 3.12.7
7 * https://gsap.com
8 *
9 * @license Copyright 2008-2025, GreenSock. All rights reserved.
10 * Subject to the terms at https://gsap.com/standard-license or for
11 * Club GSAP members, the agreement issued with that membership.
12 * @author: Jack Doyle, [email protected]
13*/
14
15/* eslint-disable */
16var gsap,
17    _coreInitted,
18    _clamp,
19    _win,
20    _doc,
21    _docEl,
22    _body,
23    _isTouch,
24    _pointerType,
25    ScrollTrigger,
26    _root,
27    _normalizer,
28    _eventTypes,
29    _context,
30    _getGSAP = function _getGSAP() {
31  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
32},
33    _startup = 1,
34    _observers = [],
35    _scrollers = [],
36    _proxies = [],
37    _getTime = Date.now,
38    _bridge = function _bridge(name, value) {
39  return value;
40},
41    _integrate = function _integrate() {
42  var core = ScrollTrigger.core,
43      data = core.bridge || {},
44      scrollers = core._scrollers,
45      proxies = core._proxies;
46  scrollers.push.apply(scrollers, _scrollers);
47  proxies.push.apply(proxies, _proxies);
48  _scrollers = scrollers;
49  _proxies = proxies;
50
51  _bridge = function _bridge(name, value) {
52    return data[name](value);
53  };
54},
55    _getProxyProp = function _getProxyProp(element, property) {
56  return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];
57},
58    _isViewport = function _isViewport(el) {
59  return !!~_root.indexOf(el);
60},
61    _addListener = function _addListener(element, type, func, passive, capture) {
62  return element.addEventListener(type, func, {
63    passive: passive !== false,
64    capture: !!capture
65  });
66},
67    _removeListener = function _removeListener(element, type, func, capture) {
68  return element.removeEventListener(type, func, !!capture);
69},
70    _scrollLeft = "scrollLeft",
71    _scrollTop = "scrollTop",
72    _onScroll = function _onScroll() {
73  return _normalizer && _normalizer.isPressed || _scrollers.cache++;
74},
75    _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {
76  var cachingFunc = function cachingFunc(value) {
77    // since reading the scrollTop/scrollLeft/pageOffsetY/pageOffsetX can trigger a layout, this function allows us to cache the value so it only gets read fresh after a "scroll" event fires (or while we're refreshing because that can lengthen the page and alter the scroll position). when "soft" is true, that means don't actually set the scroll, but cache the new value instead (useful in ScrollSmoother)
78    if (value || value === 0) {
79      _startup && (_win.history.scrollRestoration = "manual"); // otherwise the new position will get overwritten by the browser onload.
80
81      var isNormalizing = _normalizer && _normalizer.isPressed;
82      value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0); //TODO: iOS Bug: if you allow it to go to 0, Safari can start to report super strange (wildly inaccurate) touch positions!
83
84      f(value);
85      cachingFunc.cacheID = _scrollers.cache;
86      isNormalizing && _bridge("ss", value); // set scroll (notify ScrollTrigger so it can dispatch a "scrollStart" event if necessary
87    } else if (doNotCache || _scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) {
88      cachingFunc.cacheID = _scrollers.cache;
89      cachingFunc.v = f();
90    }
91
92    return cachingFunc.v + cachingFunc.offset;
93  };
94
95  cachingFunc.offset = 0;
96  return f && cachingFunc;
97},
98    _horizontal = {
99  s: _scrollLeft,
100  p: "left",
101  p2: "Left",
102  os: "right",
103  os2: "Right",
104  d: "width",
105  d2: "Width",
106  a: "x",
107  sc: _scrollCacheFunc(function (value) {
108    return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;
109  })
110},
111    _vertical = {
112  s: _scrollTop,
113  p: "top",
114  p2: "Top",
115  os: "bottom",
116  os2: "Bottom",
117  d: "height",
118  d2: "Height",
119  a: "y",
120  op: _horizontal,
121  sc: _scrollCacheFunc(function (value) {
122    return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;
123  })
124},
125    _getTarget = function _getTarget(t, self) {
126  return (self && self._ctx && self._ctx.selector || gsap.utils.toArray)(t)[0] || (typeof t === "string" && gsap.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null);
127},
128    _getScrollFunc = function _getScrollFunc(element, _ref) {
129  var s = _ref.s,
130      sc = _ref.sc;
131  // we store the scroller functions in an alternating sequenced Array like [element, verticalScrollFunc, horizontalScrollFunc, ...] so that we can minimize memory, maximize performance, and we also record the last position as a ".rec" property in order to revert to that after refreshing to ensure things don't shift around.
132  _isViewport(element) && (element = _doc.scrollingElement || _docEl);
133
134  var i = _scrollers.indexOf(element),
135      offset = sc === _vertical.sc ? 1 : 2;
136
137  !~i && (i = _scrollers.push(element) - 1);
138  _scrollers[i + offset] || _addListener(element, "scroll", _onScroll); // clear the cache when a scroll occurs
139
140  var prev = _scrollers[i + offset],
141      func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {
142    return arguments.length ? element[s] = value : element[s];
143  })));
144  func.target = element;
145  prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth"); // only set it the first time (don't reset every time a scrollFunc is requested because perhaps it happens during a refresh() when it's disabled in ScrollTrigger.
146
147  return func;
148},
149    _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
150  var v1 = value,
151      v2 = value,
152      t1 = _getTime(),
153      t2 = t1,
154      min = minTimeRefresh || 50,
155      dropToZeroTime = Math.max(500, min * 3),
156      update = function update(value, force) {
157    var t = _getTime();
158
159    if (force || t - t1 > min) {
160      v2 = v1;
161      v1 = value;
162      t2 = t1;
163      t1 = t;
164    } else if (useDelta) {
165      v1 += value;
166    } else {
167      // not totally necessary, but makes it a bit more accurate by adjusting the v1 value according to the new slope. This way we're not just ignoring the incoming data. Removing for now because it doesn't seem to make much practical difference and it's probably not worth the kb.
168      v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);
169    }
170  },
171      reset = function reset() {
172    v2 = v1 = useDelta ? 0 : v1;
173    t2 = t1 = 0;
174  },
175      getVelocity = function getVelocity(latestValue) {
176    var tOld = t2,
177        vOld = v2,
178        t = _getTime();
179
180    (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
181    return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;
182  };
183
184  return {
185    update: update,
186    reset: reset,
187    getVelocity: getVelocity
188  };
189},
190    _getEvent = function _getEvent(e, preventDefault) {
191  preventDefault && !e._gsapAllow && e.preventDefault();
192  return e.changedTouches ? e.changedTouches[0] : e;
193},
194    _getAbsoluteMax = function _getAbsoluteMax(a) {
195  var max = Math.max.apply(Math, a),
196      min = Math.min.apply(Math, a);
197  return Math.abs(max) >= Math.abs(min) ? max : min;
198},
199    _setScrollTrigger = function _setScrollTrigger() {
200  ScrollTrigger = gsap.core.globals().ScrollTrigger;
201  ScrollTrigger && ScrollTrigger.core && _integrate();
202},
203    _initCore = function _initCore(core) {
204  gsap = core || _getGSAP();
205
206  if (!_coreInitted && gsap && typeof document !== "undefined" && document.body) {
207    _win = window;
208    _doc = document;
209    _docEl = _doc.documentElement;
210    _body = _doc.body;
211    _root = [_win, _doc, _docEl, _body];
212    _clamp = gsap.utils.clamp;
213
214    _context = gsap.core.context || function () {};
215
216    _pointerType = "onpointerenter" in _body ? "pointer" : "mouse"; // isTouch is 0 if no touch, 1 if ONLY touch, and 2 if it can accommodate touch but also other types like mouse/pointer.
217
218    _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
219    _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
220    setTimeout(function () {
221      return _startup = 0;
222    }, 500);
223
224    _setScrollTrigger();
225
226    _coreInitted = 1;
227  }
228
229  return _coreInitted;
230};
231
232_horizontal.op = _vertical;
233_scrollers.cache = 0;
234export var Observer = /*#__PURE__*/function () {
235  function Observer(vars) {
236    this.init(vars);
237  }
238
239  var _proto = Observer.prototype;
240
241  _proto.init = function init(vars) {
242    _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)");
243    ScrollTrigger || _setScrollTrigger();
244    var tolerance = vars.tolerance,
245        dragMinimum = vars.dragMinimum,
246        type = vars.type,
247        target = vars.target,
248        lineHeight = vars.lineHeight,
249        debounce = vars.debounce,
250        preventDefault = vars.preventDefault,
251        onStop = vars.onStop,
252        onStopDelay = vars.onStopDelay,
253        ignore = vars.ignore,
254        wheelSpeed = vars.wheelSpeed,
255        event = vars.event,
256        onDragStart = vars.onDragStart,
257        onDragEnd = vars.onDragEnd,
258        onDrag = vars.onDrag,
259        onPress = vars.onPress,
260        onRelease = vars.onRelease,
261        onRight = vars.onRight,
262        onLeft = vars.onLeft,
263        onUp = vars.onUp,
264        onDown = vars.onDown,
265        onChangeX = vars.onChangeX,
266        onChangeY = vars.onChangeY,
267        onChange = vars.onChange,
268        onToggleX = vars.onToggleX,
269        onToggleY = vars.onToggleY,
270        onHover = vars.onHover,
271        onHoverEnd = vars.onHoverEnd,
272        onMove = vars.onMove,
273        ignoreCheck = vars.ignoreCheck,
274        isNormalizer = vars.isNormalizer,
275        onGestureStart = vars.onGestureStart,
276        onGestureEnd = vars.onGestureEnd,
277        onWheel = vars.onWheel,
278        onEnable = vars.onEnable,
279        onDisable = vars.onDisable,
280        onClick = vars.onClick,
281        scrollSpeed = vars.scrollSpeed,
282        capture = vars.capture,
283        allowClicks = vars.allowClicks,
284        lockAxis = vars.lockAxis,
285        onLockAxis = vars.onLockAxis;
286    this.target = target = _getTarget(target) || _docEl;
287    this.vars = vars;
288    ignore && (ignore = gsap.utils.toArray(ignore));
289    tolerance = tolerance || 1e-9;
290    dragMinimum = dragMinimum || 0;
291    wheelSpeed = wheelSpeed || 1;
292    scrollSpeed = scrollSpeed || 1;
293    type = type || "wheel,touch,pointer";
294    debounce = debounce !== false;
295    lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22); // note: browser may report "normal", so default to 22.
296
297    var id,
298        onStopDelayedCall,
299        dragged,
300        moved,
301        wheeled,
302        locked,
303        axis,
304        self = this,
305        prevDeltaX = 0,
306        prevDeltaY = 0,
307        passive = vars.passive || !preventDefault && vars.passive !== false,
308        scrollFuncX = _getScrollFunc(target, _horizontal),
309        scrollFuncY = _getScrollFunc(target, _vertical),
310        scrollX = scrollFuncX(),
311        scrollY = scrollFuncY(),
312        limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown",
313        // for devices that accommodate mouse events and touch events, we need to distinguish.
314    isViewport = _isViewport(target),
315        ownerDoc = target.ownerDocument || _doc,
316        deltaX = [0, 0, 0],
317        // wheel, scroll, pointer/touch
318    deltaY = [0, 0, 0],
319        onClickTime = 0,
320        clickCapture = function clickCapture() {
321      return onClickTime = _getTime();
322    },
323        _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {
324      return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
325    },
326        onStopFunc = function onStopFunc() {
327      self._vx.reset();
328
329      self._vy.reset();
330
331      onStopDelayedCall.pause();
332      onStop && onStop(self);
333    },
334        update = function update() {
335      var dx = self.deltaX = _getAbsoluteMax(deltaX),
336          dy = self.deltaY = _getAbsoluteMax(deltaY),
337          changedX = Math.abs(dx) >= tolerance,
338          changedY = Math.abs(dy) >= tolerance;
339
340      onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY); // in ScrollTrigger.normalizeScroll(), we need to know if it was touch/pointer so we need access to the deltaX/deltaY Arrays before we clear them out.
341
342      if (changedX) {
343        onRight && self.deltaX > 0 && onRight(self);
344        onLeft && self.deltaX < 0 && onLeft(self);
345        onChangeX && onChangeX(self);
346        onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
347        prevDeltaX = self.deltaX;
348        deltaX[0] = deltaX[1] = deltaX[2] = 0;
349      }
350
351      if (changedY) {
352        onDown && self.deltaY > 0 && onDown(self);
353        onUp && self.deltaY < 0 && onUp(self);
354        onChangeY && onChangeY(self);
355        onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
356        prevDeltaY = self.deltaY;
357        deltaY[0] = deltaY[1] = deltaY[2] = 0;
358      }
359
360      if (moved || dragged) {
361        onMove && onMove(self);
362
363        if (dragged) {
364          onDragStart && dragged === 1 && onDragStart(self);
365          onDrag && onDrag(self);
366          dragged = 0;
367        }
368
369        moved = false;
370      }
371
372      locked && !(locked = false) && onLockAxis && onLockAxis(self);
373
374      if (wheeled) {
375        onWheel(self);
376        wheeled = false;
377      }
378
379      id = 0;
380    },
381        onDelta = function onDelta(x, y, index) {
382      deltaX[index] += x;
383      deltaY[index] += y;
384
385      self._vx.update(x);
386
387      self._vy.update(y);
388
389      debounce ? id || (id = requestAnimationFrame(update)) : update();
390    },
391        onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {
392      if (lockAxis && !axis) {
393        self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
394        locked = true;
395      }
396
397      if (axis !== "y") {
398        deltaX[2] += x;
399
400        self._vx.update(x, true); // update the velocity as frequently as possible instead of in the debounced function so that very quick touch-scrolls (flicks) feel natural. If it's the mouse/touch/pointer, force it so that we get snappy/accurate momentum scroll.
401
402      }
403
404      if (axis !== "x") {
405        deltaY[2] += y;
406
407        self._vy.update(y, true);
408      }
409
410      debounce ? id || (id = requestAnimationFrame(update)) : update();
411    },
412        _onDrag = function _onDrag(e) {
413      if (_ignoreCheck(e, 1)) {
414        return;
415      }
416
417      e = _getEvent(e, preventDefault);
418      var x = e.clientX,
419          y = e.clientY,
420          dx = x - self.x,
421          dy = y - self.y,
422          isDragging = self.isDragging;
423      self.x = x;
424      self.y = y;
425
426      if (isDragging || (dx || dy) && (Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum)) {
427        dragged = isDragging ? 2 : 1

427; // dragged: 0 = not dragging, 1 = first drag, 2 = normal drag
428
429        isDragging || (self.isDragging = true);
430        onTouchOrPointerDelta(dx, dy);
431      }
432    },
433        _onPress = self.onPress = function (e) {
434      if (_ignoreCheck(e, 1) || e && e.button) {
435        return;
436      }
437
438      self.axis = axis = null;
439      onStopDelayedCall.pause();
440      self.isPressed = true;
441      e = _getEvent(e); // note: may need to preventDefault(?) Won't side-scroll on iOS Safari if we do, though.
442
443      prevDeltaX = prevDeltaY = 0;
444      self.startX = self.x = e.clientX;
445      self.startY = self.y = e.clientY;
446
447      self._vx.reset(); // otherwise the t2 may be stale if the user touches and flicks super fast and releases in less than 2 requestAnimationFrame ticks, causing velocity to be 0.
448
449
450      self._vy.reset();
451
452      _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);
453
454      self.deltaX = self.deltaY = 0;
455      onPress && onPress(self);
456    },
457        _onRelease = self.onRelease = function (e) {
458      if (_ignoreCheck(e, 1)) {
459        return;
460      }
461
462      _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
463
464      var isTrackingDrag = !isNaN(self.y - self.startY),
465          wasDragging = self.isDragging,
466          isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),
467          // some touch devices need some wiggle room in terms of sensing clicks - the finger may move a few pixels.
468      eventData = _getEvent(e);
469
470      if (!isDragNotClick && isTrackingDrag) {
471        self._vx.reset();
472
473        self._vy.reset(); //if (preventDefault && allowClicks && self.isPressed) { // check isPressed because in a rare edge case, the inputObserver in ScrollTrigger may stopPropagation() on the press/drag, so the onRelease may get fired without the onPress/onDrag ever getting called, thus it could trigger a click to occur on a link after scroll-dragging it.
474
475
476        if (preventDefault && allowClicks) {
477          gsap.delayedCall(0.08, function () {
478            // some browsers (like Firefox) won't trust script-generated clicks, so if the user tries to click on a video to play it, for example, it simply won't work. Since a regular "click" event will most likely be generated anyway (one that has its isTrusted flag set to true), we must slightly delay our script-generated click so that the "real"/trusted one is prioritized. Remember, when there are duplicate events in quick succession, we suppress all but the first one. Some browsers don't even trigger the "real" one at all, so our synthetic one is a safety valve that ensures that no matter what, a click event does get dispatched.
479            if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {
480              if (e.target.click) {
481                //some browsers (like mobile Safari) don't properly trigger the click event
482                e.target.click();
483              } else if (ownerDoc.createEvent) {
484                var syntheticEvent = ownerDoc.createEvent("MouseEvents");
485                syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
486                e.target.dispatchEvent(syntheticEvent);
487              }
488            }
489          });
490        }
491      }
492
493      self.isDragging = self.isGesturing = self.isPressed = false;
494      onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);
495      dragged && update(); // in case debouncing, we don't want onDrag to fire AFTER onDragEnd().
496
497      onDragEnd && wasDragging && onDragEnd(self);
498      onRelease && onRelease(self, isDragNotClick);
499    },
500        _onGestureStart = function _onGestureStart(e) {
501      return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
502    },
503        _onGestureEnd = function _onGestureEnd() {
504      return (self.isGesturing = false) || onGestureEnd(self);
505    },
506        onScroll = function onScroll(e) {
507      if (_ignoreCheck(e)) {
508        return;
509      }
510
511      var x = scrollFuncX(),
512          y = scrollFuncY();
513      onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
514      scrollX = x;
515      scrollY = y;
516      onStop && onStopDelayedCall.restart(true);
517    },
518        _onWheel = function _onWheel(e) {
519      if (_ignoreCheck(e)) {
520        return;
521      }
522
523      e = _getEvent(e, preventDefault);
524      onWheel && (wheeled = true);
525      var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;
526      onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
527      onStop && !isNormalizer && onStopDelayedCall.restart(true);
528    },
529        _onMove = function _onMove(e) {
530      if (_ignoreCheck(e)) {
531        return;
532      }
533
534      var x = e.clientX,
535          y = e.clientY,
536          dx = x - self.x,
537          dy = y - self.y;
538      self.x = x;
539      self.y = y;
540      moved = true;
541      onStop && onStopDelayedCall.restart(true);
542      (dx || dy) && onTouchOrPointerDelta(dx, dy);
543    },
544        _onHover = function _onHover(e) {
545      self.event = e;
546      onHover(self);
547    },
548        _onHoverEnd = function _onHoverEnd(e) {
549      self.event = e;
550      onHoverEnd(self);
551    },
552        _onClick = function _onClick(e) {
553      return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
554    };
555
556    onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
557    self.deltaX = self.deltaY = 0;
558    self._vx = _getVelocityProp(0, 50, true);
559    self._vy = _getVelocityProp(0, 50, true);
560    self.scrollX = scrollFuncX;
561    self.scrollY = scrollFuncY;
562    self.isDragging = self.isGesturing = self.isPressed = false;
563
564    _context(this);
565
566    self.enable = function (e) {
567      if (!self.isEnabled) {
568        _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
569
570        type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, passive, capture);
571        type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, passive, capture);
572
573        if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
574          _addListener(target, _eventTypes[0], _onPress, passive, capture);
575
576          _addListener(ownerDoc, _eventTypes[2], _onRelease);
577
578          _addListener(ownerDoc, _eventTypes[3], _onRelease);
579
580          allowClicks && _addListener(target, "click", clickCapture, true, true);
581          onClick && _addListener(target, "click", _onClick);
582          onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart);
583          onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd);
584          onHover && _addListener(target, _pointerType + "enter", _onHover);
585          onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd);
586          onMove && _addListener(target, _pointerType + "move", _onMove);
587        }
588
589        self.isEnabled = true;
590        self.isDragging = self.isGesturing = self.isPressed = moved = dragged = false;
591
592        self._vx.reset();
593
594        self._vy.reset();
595
596        scrollX = scrollFuncX();
597        scrollY = scrollFuncY();
598        e && e.type && _onPress(e);
599        onEnable && onEnable(self);
600      }
601
602      return self;
603    };
604
605    self.disable = function () {
606      if (self.isEnabled) {
607        // only remove the _onScroll listener if there aren't any others that rely on the functionality.
608        _observers.filter(function (o) {
609          return o !== self && _isViewport(o.target);
610        }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
611
612        if (self.isPressed) {
613          self._vx.reset();
614
615          self._vy.reset();
616
617          _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
618        }
619
620        _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture);
621
622        _removeListener(target, "wheel", _onWheel, capture);
623
624        _removeListener(target, _eventTypes[0], _onPress, capture);
625
626        _removeListener(ownerDoc, _eventTypes[2], _onRelease);
627
628        _removeListener(ownerDoc, _eventTypes[3], _onRelease);
629
630        _removeListener(target, "click", clickCapture, true);
631
632        _removeListener(target, "click", _onClick);
633
634        _removeListener(ownerDoc, "gesturestart", _onGestureStart);
635
636        _removeListener(ownerDoc, "gestureend", _onGestureEnd);
637
638        _removeListener(target, _pointerType + "enter", _onHover);
639
640        _removeListener(target, _pointerType + "leave", _onHoverEnd);
641
642        _removeListener(target, _pointerType + "move", _onMove);
643
644        self.isEnabled = self.isPressed = self.isDragging = false;
645        onDisable && onDisable(self);
646      }
647    };
648
649    self.kill = self.revert = function () {
650      self.disable();
651
652      var i = _observers.indexOf(self);
653
654      i >= 0 && _observers.splice(i, 1);
655      _normalizer === self && (_normalizer = 0);
656    };
657
658    _observers.push(self);
659
660    isNormalizer && _isViewport(target) && (_normalizer = self);
661    self.enable(event);
662  };
663
664  _createClass(Observer, [{
665    key: "velocityX",
666    get: function get() {
667      return this._vx.getVelocity();
668    }
669  }, {
670    key: "velocityY",
671    get: function get() {
672      return this._vy.getVelocity();
673    }
674  }]);
675
676  return Observer;
677}();
678Observer.version = "3.1