https://www.stanleyworks.pl/sites/g/files/xnuzat2116/files/cohesion/scripts/drupal-menu/pep.js?tm46jx

1/*!
2 * @sitestudioexcludesonar
3 * PEP v0.4.3 | https://github.com/jquery/PEP
4 * Copyright jQuery Foundation and other contributors | http://jquery.org/license
5 */
6
7(function (global, factory) {
8  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
9    typeof define === 'function' && define.amd ? define(factory) :
10      (global.PointerEventsPolyfill = factory());
11}(this, function () { 'use strict';
12
13  /**
14   * This is the constructor for new PointerEvents.
15   *
16   * New Pointer Events must be given a type, and an optional dictionary of
17   * initialization properties.
18   *
19   * Due to certain platform requirements, events returned from the constructor
20   * identify as MouseEvents.
21   *
22   * @constructor
23   * @param {String} inType The type of the event to create.
24   * @param {Object} [inDict] An optional dictionary of initial event properties.
25   * @return {Event} A new PointerEvent of type `inType`, initialized with properties from `inDict`.
26   */
27  var MOUSE_PROPS = [
28    'bubbles',
29    'cancelable',
30    'view',
31    'detail',
32    'screenX',
33    'screenY',
34    'clientX',
35    'clientY',
36    'ctrlKey',
37    'altKey',
38    'shiftKey',
39    'metaKey',
40    'button',
41    'relatedTarget',
42    'pageX',
43    'pageY'
44  ];
45
46  var MOUSE_DEFAULTS = [
47    false,
48    false,
49    null,
50    null,
51    0,
52    0,
53    0,
54    0,
55    false,
56    false,
57    false,
58    false,
59    0,
60    null,
61    0,
62    0
63  ];
64
65  function PointerEvent(inType, inDict) {
66    inDict = inDict || Object.create(null);
67
68    var e = document.createEvent('Event');
69    e.initEvent(inType, inDict.bubbles || false, inDict.cancelable || false);
70
71    // define inherited MouseEvent properties
72    // skip bubbles and cancelable since they're set above in initEvent()
73    for (var i = 2, p; i < MOUSE_PROPS.length; i++) {
74      p = MOUSE_PROPS[i];
75      e[p] = inDict[p] || MOUSE_DEFAULTS[i];
76    }
77    e.buttons = inDict.buttons || 0;
78
79    // Spec requires that pointers without pressure specified use 0.5 for down
80    // state and 0 for up state.
81    var pressure = 0;
82
83    if (inDict.pressure && e.buttons) {
84      pressure = inDict.pressure;
85    } else {
86      pressure = e.buttons ? 0.5 : 0;
87    }
88
89    // add x/y properties aliased to clientX/Y
90    e.x = e.clientX;
91    e.y = e.clientY;
92
93    // define the properties of the PointerEvent interface
94    e.pointerId = inDict.pointerId || 0;
95    e.width = inDict.width || 0;
96    e.height = inDict.height || 0;
97    e.pressure = pressure;
98    e.tiltX = inDict.tiltX || 0;
99    e.tiltY = inDict.tiltY || 0;
100    e.twist = inDict.twist || 0;
101    e.tangentialPressure = inDict.tangentialPressure || 0;
102    e.pointerType = inDict.pointerType || '';
103    e.hwTimestamp = inDict.hwTimestamp || 0;
104    e.isPrimary = inDict.isPrimary || false

104;
105    return e;
106  }
107
108  /**
109   * This module implements a map of pointer states
110   */
111  var USE_MAP = window.Map && window.Map.prototype.forEach;
112  var PointerMap = USE_MAP ? Map : SparseArrayMap;
113
114  function SparseArrayMap() {
115    this.array = [];
116    this.size = 0;
117  }
118
119  SparseArrayMap.prototype = {
120    set: function(k, v) {
121      if (v === undefined) {
122        return this.delete(k);
123      }
124      if (!this.has(k)) {
125        this.size++;
126      }
127      this.array[k] = v;
128    },
129    has: function(k) {
130      return this.array[k] !== undefined;
131    },
132    delete: function(k) {
133      if (this.has(k)) {
134        delete this.array[k];
135        this.size--;
136      }
137    },
138    get: function(k) {
139      return this.array[k];
140    },
141    clear: function() {
142      this.array.length = 0;
143      this.size = 0;
144    },
145
146    // return value, key, map
147    forEach: function(callback, thisArg) {
148      return this.array.forEach(function(v, k) {
149        callback.call(thisArg, v, k, this);
150      }, this);
151    }
152  };
153
154  var CLONE_PROPS = [
155
156    // MouseEvent
157    'bubbles',
158    'cancelable',
159    'view',
160    'detail',
161    'screenX',
162    'screenY',
163    'clientX',
164    'clientY',
165    'ctrlKey',
166    'altKey',
167    'shiftKey',
168    'metaKey',
169    'button',
170    'relatedTarget',
171
172    // DOM Level 3
173    'buttons',
174
175    // PointerEvent
176    'pointerId',
177    'width',
178    'height',
179    'pressure',
180    'tiltX',
181    'tiltY',
182    'pointerType',
183    'hwTimestamp',
184    'isPrimary',
185
186    // event instance
187    'type',
188    'target',
189    'currentTarget',
190    'which',
191    'pageX',
192    'pageY',
193    'timeStamp'
194  ];
195
196  var CLONE_DEFAULTS = [
197
198    // MouseEvent
199    false,
200    false,
201    null,
202    null,
203    0,
204    0,
205    0,
206    0,
207    false,
208    false,
209    false,
210    false,
211    0,
212    null,
213
214    // DOM Level 3
215    0,
216
217    // PointerEvent
218    0,
219    0,
220    0,
221    0,
222    0,
223    0,
224    '',
225    0,
226    false,
227
228    // event instance
229    '',
230    null,
231    null,
232    0,
233    0,
234    0,
235    0
236  ];
237
238  var BOUNDARY_EVENTS = {
239    'pointerover': 1,
240    'pointerout': 1,
241    'pointerenter': 1,
242    'pointerleave': 1
243  };
244
245  var HAS_SVG_INSTANCE = (typeof SVGElementInstance !== 'undefined');
246
247  /**
248   * This module is for normalizing events. Mouse and Touch events will be
249   * collected here, and fire PointerEvents that have the same semantics, no
250   * matter the source.
251   * Events fired:
252   *   - pointerdown: a pointing is added
253   *   - pointerup: a pointer is removed
254   *   - pointermove: a pointer is moved
255   *   - pointerover: a pointer crosses into an element
256   *   - pointerout: a pointer leaves an element
257   *   - pointercancel: a pointer will no longer generate events
258   */
259  var dispatcher = {
260    pointermap: new PointerMap(),
261    eventMap: Object.create(null),
262    captureInfo: Object.create(null),
263
264    // Scope objects for native events.
265    // This exists for ease of testing.
266    eventSources: Object.create(null),
267    eventSourceList: [],
268    /**
269     * Add a new event source that will generate pointer events.
270     *
271     * `inSource` must contain an array of event names named `events`, and
272     * functions with the names specified in the `events` array.
273     * @param {string} name A name for the event source
274     * @param {Object} source A new source of platform events.
275     */
276    registerSource: function(name, source) {
277      var s = source;
278      var newEvents = s.events;
279      if (newEvents) {
280        newEvents.forEach(function(e) {
281          if (s[e]) {
282            this.eventMap[e] = s[e].bind(s);
283          }
284        }, this);
285        this.eventSources[name] = s;
286        this.eventSourceList.push(s);
287      }
288    },
289    register: function(element) {
290      var l = this.eventSourceList.length;
291      for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
292
293        // call eventsource register
294        es.register.call(es, element);
295      }
296    },
297    unregister: function(element) {
298      var l = this.eventSourceList.length;
299      for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
300
301        // call eventsource register
302        es.unregister.call(es, element);
303      }
304    },
305    contains: /*scope.external.contains || */function(container, contained) {
306      try {
307        return container.contains(contained);
308      } catch (ex) {
309
310        // most likely: https://bugzilla.mozilla.org/show_bug.cgi?id=208427
311        return false;
312      }
313    },
314
315    // EVENTS
316    down: function(inEvent) {
317      inEvent.bubbles = true;
318      this.fireEvent('pointerdown', inEvent);
319    },
320    move: function(inEvent) {
321      inEvent.bubbles = true;
322      this.fireEvent('pointermove', inEvent);
323    },
324    up: function(inEvent) {
325      inEvent.bubbles = true;
326      this.fireEvent('pointerup', inEvent);
327    },
328    enter: function(inEvent) {
329      inEvent.bubbles = false;
330      this.fireEvent('pointerenter', inEvent);
331    },
332    leave: function(inEvent) {
333      inEvent.bubbles = false;
334      this.fireEvent('pointerleave', inEvent);
335    },
336    over: function(inEvent) {
337      inEvent.bubbles = true;
338      this.fireEvent('pointerover', inEvent);
339    },
340    out: function(inEvent) {
341      inEvent.bubbles = true;
342      this.fireEvent('pointerout', inEvent);
343    },
344    cancel: function(inEvent) {
345      inEvent.bubbles = true;
346      this.fireEvent('pointercancel', inEvent);
347    },
348    leaveOut: function(event) {
349      this.out(event);
350      this.propagate(event, this.leave, false);
351    },
352    enterOver: function(event) {
353      this.over(event);
354      this.propagate(event, this.enter, true);
355    },
356
357    // LISTENER LOGIC
358    eventHandler: function(inEvent) {
359
360      // This is used to prevent multiple dispatch of pointerevents from
361      // platform events. This can happen when two elements in different scopes
362      // are set up to create pointer events, which is relevant to Shadow DOM.
363      if (inEvent._handledByPE) {
364        return;
365      }
366      var type = inEvent.type;
367      var fn = this.eventMap && this.eventMap[type];
368      if (fn) {
369        fn(inEvent);
370      }
371      inEvent._handledByPE = true;
372    },
373
374    // set up event listeners
375    listen: function(target, events) {
376      events.forEach(function(e) {
377        this.addEvent(target, e);
378      }, this);
379    },
380
381    // remove event listeners
382    unlisten: function(target, events) {
383      events.forEach(function(e) {
384        this.removeEvent(target, e);
385      }, this);
386    },
387    addEvent: /*scope.external.addEvent || */function(target, eventName) {
388      target.addEventListener(eventName, this.boundHandler);
389    },
390    removeEvent: /*scope.external.removeEvent || */function(target, eventName) {
391      target.removeEventListener(eventName, this.boundHandler);
392    },
393
394    // EVENT CREATION AND TRACKING
395    /**
396     * Creates a new Event of type `inType`, based on the information in
397     * `inEvent`.
398     *
399     * @param {string} inType A string representing the type of event to create
400     * @param {Event} inEvent A platform event with a target
401     * @return {Event} A PointerEvent of type `inType`
402     */
403    makeEvent: function(inType, inEvent) {
404
405      // relatedTarget must be null if pointer is captured
406      if (this.captureInfo[inEvent.pointerId]) {
407        inEvent.relatedTarget = null;
408      }
409      var e = new PointerEvent(inType, inEvent);
410      if (inEvent.preventDefault) {
411        e.preventDefault = inEvent.preventDefault;
412      }
413      e._target = e._target || inEvent.target;
414      return e;
415    },
416
417    // make and dispatch an event in one call
418    fireEvent: function(inType, inEvent) {
419      var e = this.makeEvent(inType, inEvent);
420      return this.dispatchEvent(e);
421    },
422    /**
423     * Returns a snapshot of inEvent, with writable properties.
424     *
425     * @param {Event} inEvent An event that contains properties to copy.
426     * @return {Object} An object containing shallow copies of `inEvent`'s
427     *    properties.
428     */
429    cloneEvent: function(inEvent) {
430      var eventCopy = Object.create(null);
431      var p;
432      for (var i = 0; i < CLONE_PROPS.length; i++) {
433        p = CLONE_PROPS[i];
434        eventCopy[p] = inEvent[p] || CLONE_DEFAULTS[i];
435
436        // Work around SVGInstanceElement shadow tree
437        // Return the <use> element that is represented by the instance for Safari, Chrome, IE.
438        // This is the behavior implemented by Firefox.
439        if (HAS_SVG_INSTANCE && (p === 'target' || p === 'relatedTarget')) {
440          if (eventCopy[p] instanceof SVGElementInstance) {
441            eventCopy[p] = eventCopy[p].correspondingUseElement;
442          }
443        }
444      }
445
446      // keep the semantics of preventDefault
447      if (inEvent.preventDefault) {
448        eventCopy.preventDefault = function() {
449          inEvent.preventDefault();
450        };
451      }
452      return eventCopy;
453    },
454    getTarget: function(inEvent) {
455      var capture = this.captureInfo[inEvent.pointerId];
456      if (!capture) {
457        return inEvent._target;
458      }
459      if (inEvent._target === capture || !(inEvent.type in BOUNDARY_EVENTS)) {
460        return capture;
461      }
462    },
463    propagate: function(event, fn, propagateDown) {
464      var target = event.target;
465      var targets = [];
466
467      // Order of conditions due to document.contains() missing in IE.
468      while (target !=

468= document && !target.contains(event.relatedTarget)) {
469        targets.push(target);
470        target = target.parentNode;
471
472        // Touch: Do not propagate if node is detached.
473        if (!target) {
474          return;
475        }
476      }
477      if (propagateDown) {
478        targets.reverse();
479      }
480      targets.forEach(function(target) {
481        event.target = target;
482        fn.call(this, event);
483      }, this);
484    },
485    setCapture: function(inPointerId, inTarget, skipDispatch) {
486      if (this.captureInfo[inPointerId]) {
487        this.releaseCapture(inPointerId, skipDispatch);
488      }
489
490      this.captureInfo[inPointerId] = inTarget;
491      this.implicitRelease = this.releaseCapture.bind(this, inPointerId, skipDispatch);
492      document.addEventListener('pointerup', this.implicitRelease);
493      document.addEventListener('pointercancel', this.implicitRelease);
494
495      var e = new PointerEvent('gotpointercapture');
496      e.pointerId = inPointerId;
497      e._target = inTarget;
498
499      if (!skipDispatch) {
500        this.asyncDispatchEvent(e);
501      }
502    },
503    releaseCapture: function(inPointerId, skipDispatch) {
504      var t = this.captureInfo[inPointerId];
505      if (!t) {
506        return;
507      }
508
509      this.captureInfo[inPointerId] = undefined;
510      document.removeEventListener('pointerup', this.implicitRelease);
511      document.removeEventListener('pointercancel', this.implicitRelease);
512
513      var e = new PointerEvent('lostpointercapture');
514      e.pointerId = inPointerId;
515      e._target = t;
516
517      if (!skipDispatch) {
518        this.asyncDispatchEvent(e);
519      }
520    },
521    /**
522     * Dispatches the event to its target.
523     *
524     * @param {Event} inEvent The event to be dispatched.
525     * @return {Boolean} True if an event handler returns true, false otherwise.
526     */
527    dispatchEvent: /*scope.external.dispatchEvent || */function(inEvent) {
528      var t = this.getTarget(inEvent);
529      if (t) {
530        return t.dispatchEvent(inEvent);
531      }
532    },
533    asyncDispatchEvent: function(inEvent) {
534      requestAnimationFrame(this.dispatchEvent.bind(this, inEvent));
535    }
536  };
537  dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher);
538
539  var targeting = {
540    shadow: function(inEl) {
541      if (inEl) {
542        return inEl.shadowRoot || inEl.webkitShadowRoot;
543      }
544    },
545    canTarget: function(shadow) {
546      return shadow && Boolean(shadow.elementFromPoint);
547    },
548    targetingShadow: function(inEl) {
549      var s = this.shadow(inEl);
550      if (this.canTarget(s)) {
551        return s;
552      }
553    },
554    olderShadow: function(shadow) {
555      var os = shadow.olderShadowRoot;
556      if (!os) {
557        var se = shadow.querySelector('shadow');
558        if (se) {
559          os = se.olderShadowRoot;
560        }
561      }
562      return os;
563    },
564    allShadows: function(element) {
565      var shadows = [];
566      var s = this.shadow(element);
567      while (s) {
568        shadows.push(s);
569        s = this.olderShadow(s);
570      }
571      return shadows;
572    },
573    searchRoot: function(inRoot, x, y) {
574      if (inRoot) {
575        var t = inRoot.elementFromPoint(x, y);
576        var st, sr;
577
578        // is element a shadow host?
579        sr = this.targetingShadow(t);
580        while (sr) {
581
582          // find the the element inside the shadow root
583          st = sr.elementFromPoint(x, y);
584          if (!st) {
585
586            // check for older shadows
587            sr = this.olderShadow(sr);
588          } else {
589
590            // shadowed element may contain a shadow root
591            var ssr = this.targetingShadow(st);
592            return this.searchRoot(ssr, x, y) || st;
593          }
594        }
595
596        // light dom element is the target
597        return t;
598      }
599    },
600    owner: function(element) {
601      var s = element;
602
603      // walk up until you hit the shadow root or document
604      while (s.parentNode) {
605        s = s.parentNode;
606      }
607
608      // the owner element is expected to be a Document or ShadowRoot
609      if (s.nodeType !== Node.DOCUMENT_NODE && s.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {
610        s = document;
611      }
612      return s;
613    },
614    findTarget: function(inEvent) {
615      var x = inEvent.clientX;
616      var y = inEvent.clientY;
617
618      // if the listener is in the shadow root, it is much faster to start there
619      var s = this.owner(inEvent.target);
620
621      // if x, y is not in this root, fall back to document search
622      if (!s.elementFromPoint(x, y)) {
623        s = document;
624      }
625      return this.searchRoot(s, x, y);
626    }
627  };
628

794  try {
795    HAS_BUTTONS = new MouseEvent('test', { buttons: 1 }).buttons === 1;
796  } catch (e) {}
797
798  // handler block for native mouse events
799  var mouseEvents = {
800    POINTER_ID: 1,
801    POINTER_TYPE: 'mouse',
802    events: [
803      'mousedown',
804      'mousemove',
805      'mouseup',
806      'mouseover',
807      'mouseout'
808    ],
809    register: function(target) {
810      dispatcher.listen(target, this.events);
811    },
812    unregister: function(target) {
813      dispatcher.unlisten(target, this.events);
814    },
815    lastTouches: [],
816
817    // collide with the global mouse listener
818    isEventSimulatedFromTouch: function(inEvent) {
819      var lts = this.lastTouches;
820      var x = inEvent.clientX;
821      var y = inEvent.clientY;
822      for (var i = 0, l = lts.length, t; i < l && (t = lts[i]); i++) {
823
824        // simulated mouse events will be swallowed near a primary touchend
825        var dx = Math.abs(x - t.x);
826        var dy = Math.abs(y - t.y);
827        if (dx <= DEDUP_DIST && dy <= DEDUP_DIST) {
828          return true;
829        }
830      }
831    },
832    prepareEvent: function(inEvent) {
833      var e = dispatcher.cloneEvent(inEvent);
834
835      // forward mouse preventDefault
836      var pd = e.preventDefault;
837      e.preventDefault = function() {
838        inEvent.preventDefault();
839        pd();
840      };
841      e.pointerId = this.POINTER_ID;
842      e.isPrimary = true;
843      e.pointerType = this.POINTER_TYPE;
844      return e;
845    },
846    prepareButtonsForMove: function(e, inEvent) {
847      var p = pointermap.get(this.POINTER_ID);
848
849      // Update buttons state after possible out-of-document mouseup.
850      if (inEvent.which === 0 || !p) {
851        e.buttons = 0;
852      } else {
853        e.buttons = p.buttons;
854      }
855      inEvent.buttons = e.buttons;
856    },
857    mousedown: function(inEvent) {
858      if (!this.isEventSimulatedFromTouch(inEvent)) {
859        var p = pointermap.get(this.POINTER_ID);
860        var e = this.prepareEvent(inEvent);
861        if (!HAS_BUTTONS) {
862          e.buttons = BUTTON_TO_BUTTONS[e.button];
863          if (p) { e.buttons |= p.buttons; }
864          inEvent.buttons = e.buttons;
865        }
866        pointermap.set(this.POINTER_ID, inEvent);
867        if (!p || p.buttons === 0) {
868          dispatcher.down(e);
869        } else {
870          dispatcher.move(e);
871        }
872      }
873    },
874    mousemove: function(inEvent) {
875      if (!this.isEventSimulatedFromTouch(inEvent)) {
876        var e = this.prepareEvent(inEvent);
877        if (!HAS_BUTTONS) { this.prepareButtonsForMove(e, inEvent); }
878        e.button = -1;
879        pointermap.set(this.POINTER_ID, inEvent);
880        dispatcher.move(e);
881      }
882    },
883    mouseup: function(inEvent) {
884      if (!this.isEventSimulatedFromTouch(inEvent)) {
885        var p = pointermap.get(this.POINTER_ID);
886        var e = this.prepareEvent(inEvent);
887        if (!HAS_BUTTONS) {
888          var up = BUTTON_TO_BUTTONS[e.button];
889
890          // Produces wrong state of buttons in Browsers without `buttons` support
891          // when a mouse button that was pressed outside the document is released
892          // inside and other buttons are still pressed down.
893          e.buttons = p ? p.buttons & ~up : 0;
894          inEvent.buttons = e.buttons;
895        }
896        pointermap.set(this.POINTER_ID, inEvent);
897
898        // Support: Firefox <=44 only
899        // FF Ubuntu includes the lifted button in the `buttons` property on
900        // mouseup.
901        // https://bugzilla.mozilla.org/show_bug.cgi?id=1223366
902        e.buttons &= ~BUTTON_TO_BUTTONS[e.button];
903        if (e.buttons === 0) {
904          dispatcher.up(e);
905        } else {
906          dispatcher.move(e);
907        }
908      }
909    },
910    mouseover: function(inEvent) {
911      if (!this.isEventSimulatedFromTouch(inEvent)) {
912        var e = this.prepareEvent(inEvent);
913        if (!HAS_BUTTONS) { this.prepareButtonsForMove(e, inEvent); }
914        e.button = -1;
915        pointermap.set(this.POINTER_ID, inEvent);
916        dispatcher.enterOver(e);
917      }
918    },
919    mouseout: function(inEvent) {
920      if (!this.isEventSimulatedFromTouch(inEvent)) {
921        var e = this.prepareEvent(inEvent);
922        if (!HAS_BUTTONS) { this.prepareButtonsForMove(e, inEvent); }
923        e.button = -1;
924        dispatcher.leaveOut(e);
925      }
926    },
927    cancel: function(inEvent) {
928      var e = this.prepareEvent(inEvent);
929      dispatcher.cancel(e);
930      this.deactivateMouse();
931    },
932    deactivateMouse: function() {
933      pointermap.delete(this.POINTER_ID);
934    }
935  };
936

1377        dispatcher.registerSource('mouse', mouseEvents);
1378        if (window.ontouchstart !== undefined) {
1379          dispatcher.registerSource('touch', touchEvents);
1380        }
1381      }
1382
1383      dispatcher.register(document);
1384    }
1385  }
1386
1387  var n = window.navigator;
1388  var s;
1389  var r;
1390  var h;
1391  function assertActive(id) {
1392    if (!dispatcher.pointermap.has(id)) {
1393      var error = new Error('InvalidPointerId');
1394      error.name = 'InvalidPointerId';
1395      throw error;
1396    }
1397  }
1398  function assertConnected(elem) {
1399    var parent = elem.parentNode;
1400    while (parent && parent !== elem.ownerDocument) {
1401      parent = parent.parentNode;
1402    }
1403    if (!parent) {
1404      var error = new Error('InvalidStateError');
1405      error.name = 'InvalidStateError';
1406      throw error;
1407    }
1408  }
1409  function inActiveButtonState(id) {
1410    var p = dispatcher.pointermap.get(id);
1411    return p.buttons !== 0;
1412  }
1413  if (n.msPointerEnabled) {
1414    s = function(pointerId) {
1415      assertActive(pointerId);
1416      assertConnected(this);
1417      if (inActiveButtonState(pointerId)) {
1418        dispatcher.setCapture(pointerId, this, true);
1419        this.msSetPointerCapture(pointerId);
1420      }
1421    };
1422    r = function(pointerId) {
1423      assertActive(pointerId);
1424      dispatcher.releaseCapture(pointerId, true);
1425      this.msReleasePointerCapture(pointerId);
1426    };
1427  } else {
1428    s = function setPointerCapture(pointerId) {
1429      assertActive(pointerId);
1430      assertConnected(this);
1431      if (inActiveButtonState(pointerId)) {
1432        dispatcher.setCapture(pointerId, this);
1433      }
1434    };
1435    r = function releasePointerCapture(pointerId) {
1436      assertActive(pointerId);
1437      dispatcher.releaseCapture(pointerId);
1438    };
1439  }
1440  h = function hasPointerCapture(pointerId) {
1441    return !!dispatcher.captureInfo[pointerId];
1442  };
1443
1444  function applyPolyfill$1() {
1445    if (window.Element && !Element.prototype.setPointerCapture) {
1446      Object.defineProperties(Element.prototype, {
1447        'setPointerCapture': {
1448          value: s
1449        },
1450        'releasePointerCapture': {
1451          value: r
1452        },
1453        'hasPointerCapture': {
1454          value: h
1455        }
1456      });
1457    }
1458  }
1459
1460  applyAttributeStyles();
1461  applyPolyfill();
1462  applyPolyfill$1();
1463
1464  var pointerevents = {
1465    dispatcher: dispatcher,
1466    Installer: Installer,
1467    PointerEvent: PointerEvent,
1468    PointerMap: PointerMap,
1469    targetFinding: targeting
1470  };
1471
1472  return pointerevents;
1473
1474}));