@baloise/ds-core 20.0.0-next.4 → 20.0.0-next.7

package/dist/cjs/contact-SPfz2A_q.js

@@ -1,1647 +0,0 @@
-/*!
- * (C) Helvetia Design System https://design.baloise.dev/ - Apache License 2.0
- */
-'use strict';
-
-exports.Direction = void 0;
-(function(Direction) {
-    Direction["None"] = "0";
-    Direction["Left"] = "left";
-    Direction["Right"] = "right";
-    Direction["Up"] = "up";
-    Direction["Down"] = "down";
-})(exports.Direction || (exports.Direction = {}));
-const $a2188ba8c266b376$export$86ae6e8ac17a67c6 = Object.freeze({
-    Horizontal: [
-        exports.Direction.Left,
-        exports.Direction.Right
-    ],
-    Vertical: [
-        exports.Direction.Up,
-        exports.Direction.Down
-    ],
-    All: [
-        exports.Direction.Left,
-        exports.Direction.Right,
-        exports.Direction.Up,
-        exports.Direction.Down,
-        exports.Direction.None, 
-    ]
-});
-exports.GestureState = void 0;
-(function(GestureState) {
-    GestureState["Inactive"] = "inactive";
-    GestureState["Active"] = "active";
-    GestureState["Blocked"] = "blocked";
-})(exports.GestureState || (exports.GestureState = {}));
-exports.PointerManagerState = void 0;
-(function(PointerManagerState) {
-    PointerManagerState["NoPointer"] = "nopointer";
-    PointerManagerState["SinglePointer"] = "singlepointer";
-    PointerManagerState["DualPointer"] = "dualpointer";
-})(exports.PointerManagerState || (exports.PointerManagerState = {}));
-exports.PointerListenerState = void 0;
-(function(PointerListenerState) {
-    PointerListenerState["NoActiveGesture"] = "noactivegesture";
-    PointerListenerState["ActiveGesture"] = "activegesture";
-})(exports.PointerListenerState || (exports.PointerListenerState = {}));
-
-
-class $07c7ab2351895186$export$baf26146a414f24a {
-    constructor(x, y){
-        this.x = x;
-        this.y = y;
-    }
-}
-
-
-
-class $c0ee1a209fd4fc8d$export$9b781de7bf37bf48 {
-    // vector between 2 points: START(x,y) and END(x,y)
-    constructor(startPoint, endPoint){
-        this.startPoint = startPoint;
-        this.endPoint = endPoint;
-        this.direction = (exports.Direction).None;
-        this.deltaX = this.endPoint.x - this.startPoint.x;
-        this.deltaY = this.endPoint.y - this.startPoint.y;
-        this.x = this.deltaX;
-        this.y = this.deltaY;
-        // determine length
-        this.vectorLength = Math.sqrt(Math.pow(this.deltaX, 2) + Math.pow(this.deltaY, 2));
-        // determine direction
-        if (Math.abs(this.deltaX) > Math.abs(this.deltaY)) {
-            // left or right
-            if (this.startPoint.x < this.endPoint.x) this.direction = (exports.Direction).Right;
-            else if (this.startPoint.x > this.endPoint.x) this.direction = (exports.Direction).Left;
-        } else {
-            // up or down
-            if (this.startPoint.y < this.endPoint.y) this.direction = (exports.Direction).Down;
-            else if (this.startPoint.y > this.endPoint.y) this.direction = (exports.Direction).Up;
-        }
-    }
-}
-
-
-class $1f7944f1763e45ce$export$2db6c17465f94a2 {
-    static getVector(startPointerEvent, endPointerEvent) {
-        const startPoint = new ($07c7ab2351895186$export$baf26146a414f24a)(startPointerEvent.clientX, startPointerEvent.clientY);
-        const endPoint = new ($07c7ab2351895186$export$baf26146a414f24a)(endPointerEvent.clientX, endPointerEvent.clientY);
-        const vector = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(startPoint, endPoint);
-        return vector;
-    }
-    // update speed. speed = distance / time
-    static getSpeed(vector, startTimestamp, endTimestamp) {
-        let speed = 0;
-        const timespan_ms = endTimestamp - startTimestamp;
-        const timespan_s = timespan_ms / 1000;
-        if (vector != null && timespan_s != 0) // px/s
-        speed = vector.vectorLength / timespan_s;
-        return speed;
-    }
-    /*
-  * CALCULATE ROTATION
-  * this is not a trivial problem
-  * required output is: angle and direction (cw //ccw)
-  * direction is relative to the first touch with two fingers, not absolute to the screens default coordinate system
-  * to determine rotation direction, 3 points on the circle - with timestamps - are required
-  * imagine a steering wheel
-  * - initial state is 0 deg (0)
-  * - if the wheel has been turned ccw, its state has a negative angle
-  * - if the wheel has been turned cw, its state has a positive angle
-  * - possible values for the angle: [-360,360]
-  */ static calculateRotationAngle(vector_1, vector_2) {
-        // vector_ are vectors between 2 points in time, same finger
-        // angleAector_ are vectors between 2 fingers
-        const angleVector_1 = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(vector_1.startPoint, vector_2.startPoint); // in time: occured first
-        const angleVector_2 = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(vector_1.endPoint, vector_2.endPoint); // in time: occured second
-        const origin = new ($07c7ab2351895186$export$baf26146a414f24a)(0, 0);
-        // translate the points of the vector, so that their startPoints are attached to (0,0)
-        /*
-
-          ^
-         /
-        /
-         /
-        x
-        0
-
-    */ const translationVector_1 = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(angleVector_1.startPoint, origin);
-        const translatedEndPoint_1 = this.translatePoint(angleVector_1.endPoint, translationVector_1);
-        //var v_1_translated = new Vector(origin, translatedEndPoint_1);
-        const translationVector_2 = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(angleVector_2.startPoint, origin);
-        const translatedEndPoint_2 = this.translatePoint(angleVector_2.endPoint, translationVector_2);
-        //var v2_translated = new Vector(origin, translatedEndPoint_2);
-        // rotate the first angle vector so its y-coordinate becomes 0
-        /*
-
-      x------->
-      0
-
-    */ const rotationAngle = this.calcAngleRad(translatedEndPoint_1) * -1;
-        // rottation matrix
-        //var x_1_rotated =  ( translatedEndPoint_1.x * Math.cos(rotationAngle) ) - ( translatedEndPoint_1.y * Math.sin(rotationAngle) );
-        //var y_1_rotated = Math.round(( translatedEndPoint_1.x * Math.sin(rotationAngle) ) + ( translatedEndPoint_1.y * Math.cos(rotationAngle) )); // should be 0
-        //var v_1_rotated = new Vector(origin, new Point(x_1_rotated, y_1_rotated));
-        // rotate the second vector (in time: after 1st)
-        const x_2_rotated = translatedEndPoint_2.x * Math.cos(rotationAngle) - translatedEndPoint_2.y * Math.sin(rotationAngle);
-        const y_2_rotated = Math.round(translatedEndPoint_2.x * Math.sin(rotationAngle) + translatedEndPoint_2.y * Math.cos(rotationAngle));
-        //var v_2_rotated = new Vector(origin, new Point(x_2_rotated, y_2_rotated));
-        // calculate the angle between v_1 and v_2
-        const angleDeg = Math.atan2(y_2_rotated, x_2_rotated) * 180 / Math.PI;
-        return angleDeg;
-    }
-    static calculateVectorAngle(vector_1, vector_2) {
-        let angleDeg = 0;
-        if (vector_1.vectorLength > 0 && vector_2.vectorLength > 0) {
-            const cos = (vector_1.x * vector_2.x + vector_1.y * vector_2.y) / (vector_1.vectorLength * vector_2.vectorLength);
-            const angleRad = Math.acos(cos);
-            angleDeg = this.rad2deg(angleRad);
-        }
-        return angleDeg;
-    }
-    static translatePoint(point, vector) {
-        const newX = point.x + vector.x;
-        const newY = point.y + vector.y;
-        const translatedPoint = new ($07c7ab2351895186$export$baf26146a414f24a)(newX, newY);
-        return translatedPoint;
-    }
-    // return the counter-clockwise angle between the positive x-axis and a point.
-    // from 0 degrees to 360 degrees
-    // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2
-    static calcAngleDegrees(point) {
-        // angle in degrees between -180 and 180
-        let angle = Math.atan2(point.y, point.x) * 180 / Math.PI;
-        if (angle < 0) angle = 360 + angle;
-        return angle;
-    }
-    static calcAngleRad(point) {
-        let angle = Math.atan2(point.y, point.x); // [-PI, PI]
-        if (angle < 0) angle = 2 * Math.PI + angle;
-        return angle;
-    }
-    static deg2rad(angleDeg) {
-        const rad = Math.PI / 180 * angleDeg;
-        return rad;
-    }
-    static rad2deg(angleRad) {
-        const deg = angleRad / (Math.PI / 180);
-        return deg;
-    }
-    // DualPointerInput calculations
-    // center between start points
-    static getCenter(pointA, pointB) {
-        const centerX = (pointA.x + pointB.x) / 2;
-        const centerY = (pointA.y + pointB.y) / 2;
-        const center = new ($07c7ab2351895186$export$baf26146a414f24a)(centerX, centerY);
-        return center;
-    }
-    static getCenterMovementVector(vector_1, vector_2) {
-        // start point is the center between the starting points of the 2 vectors
-        const startPoint = this.getCenter(vector_1.startPoint, vector_2.startPoint);
-        // center between the end points of the vectors
-        const endPoint = this.getCenter(vector_1.endPoint, vector_2.endPoint);
-        const vectorBetweenCenterPoints = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(startPoint, endPoint);
-        return vectorBetweenCenterPoints;
-    }
-    static calculateDistanceChange(vector_1, vector_2) {
-        const vectorBetweenStartPoints = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(vector_1.startPoint, vector_2.startPoint);
-        const vectorBetweenEndPoints = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(vector_1.endPoint, vector_2.endPoint);
-        const distanceChange = vectorBetweenEndPoints.vectorLength - vectorBetweenStartPoints.vectorLength;
-        return distanceChange;
-    }
-    static calculateAbsoluteDistanceChange(vector_1, vector_2) {
-        const distanceChange = this.calculateDistanceChange(vector_1, vector_2);
-        const absoluteDistanceChange = Math.abs(distanceChange);
-        return absoluteDistanceChange;
-    }
-    static calculateRelativeDistanceChange(vector_1, vector_2) {
-        const vectorBetweenStartPoints = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(vector_1.startPoint, vector_2.startPoint);
-        const vectorBetweenEndPoints = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(vector_1.endPoint, vector_2.endPoint);
-        const relativeDistanceChange = vectorBetweenEndPoints.vectorLength / vectorBetweenStartPoints.vectorLength;
-        return relativeDistanceChange;
-    }
-}
-
-
-exports.PointerState = void 0;
-(function(PointerState) {
-    PointerState["Active"] = "active";
-    PointerState["Removed"] = "removed";
-    PointerState["Canceled"] = "canceled";
-})(exports.PointerState || (exports.PointerState = {}));
-class $d25d2392b002d8dc$export$b56007f12edf0c17 {
-    constructor(pointerEvent, options){
-        this.options = {
-            DEBUG: false,
-            ...options
-        };
-        this.DEBUG = this.options.DEBUG;
-        const now = new Date().getTime();
-        this.pointerId = pointerEvent.pointerId;
-        this.vectorTimespan = this.options.vectorTimespan ?? 100; // milliseconds
-        this.initialPointerEvent = pointerEvent;
-        this.currentPointerEvent = pointerEvent;
-        this.recognizedEvents = [
-            pointerEvent
-        ];
-        this.state = exports.PointerState.Active;
-        const nullVector = ($1f7944f1763e45ce$export$2db6c17465f94a2).getVector(pointerEvent, pointerEvent);
-        const globalParameters = {
-            startX: this.initialPointerEvent.clientX,
-            startY: this.initialPointerEvent.clientY,
-            vector: nullVector,
-            deltaX: 0,
-            deltaY: 0,
-            startTimestampUTC: now,
-            startTimestamp: this.initialPointerEvent.timeStamp,
-            currentTimestamp: this.initialPointerEvent.timeStamp,
-            endTimestamp: null,
-            maximumSpeed: 0,
-            currentSpeed: 0,
-            distance: 0,
-            maximumDistance: 0,
-            averageSpeed: 0,
-            finalSpeed: 0,
-            traveledDistance: 0,
-            hasBeenMoved: false,
-            duration: 0
-        };
-        const liveParameters = {
-            duration: 0,
-            speed: 0,
-            vector: nullVector,
-            distance: 0,
-            isMoving: false
-        };
-        const parameters = {
-            global: globalParameters,
-            live: liveParameters
-        };
-        this.parameters = parameters;
-    }
-    getTarget() {
-        return this.initialPointerEvent.target;
-    }
-    reset() {}
-    onIdle() {
-        const now = new Date().getTime();
-        // currentTimestamp is not an UTC millisecond timestamp.
-        // this.globalParameters.currentTimestamp = now;
-        const duration = now - this.parameters.global.startTimestampUTC;
-        this.parameters.global.duration = duration;
-    }
-    onPointerMove(pointermoveEvent) {
-        this.parameters.global.hasBeenMoved = true;
-        this.parameters.live.isMoving = true;
-        this.update(pointermoveEvent);
-    }
-    onPointerUp(pointerupEvent) {
-        this.parameters.global.finalSpeed = this.parameters.live.speed;
-        this.parameters.live.speed = 0;
-        this.parameters.live.isMoving = false;
-        this.state = exports.PointerState.Removed;
-        this.parameters.global.endTimestamp = pointerupEvent.timeStamp;
-        this.update(pointerupEvent);
-        if (this.DEBUG === true) console.log(`[PointerInput] pointerdown ended. pointerdown duration: ${this.parameters.global.duration}ms`);
-    }
-    onPointerLeave(pointerleaveEvent) {
-        this.onPointerUp(pointerleaveEvent);
-    }
-    onPointerCancel(pointercancelEvent) {
-        this.update(pointercancelEvent);
-        this.parameters.live.speed = 0;
-        this.state = exports.PointerState.Canceled;
-        this.parameters.live.isMoving = false;
-        this.parameters.global.endTimestamp = pointercancelEvent.timeStamp;
-        if (this.DEBUG === true) console.log(`[PointerInput] canceled, pointerdown duration:${this.parameters.global.duration}ms`);
-    }
-    update(pointerEvent) {
-        // update general parameters
-        this.currentPointerEvent = pointerEvent;
-        this.recognizedEvents.push(pointerEvent);
-        // update liveParameters
-        // maybe check if clientX and clientY are present
-        const timedPointerEvents = this.getTimedPointerEvents();
-        const liveVector = ($1f7944f1763e45ce$export$2db6c17465f94a2).getVector(timedPointerEvents[0], timedPointerEvents[1]);
-        this.parameters.live.vector = liveVector;
-        this.parameters.live.distance = liveVector.vectorLength;
-        this.parameters.live.speed = ($1f7944f1763e45ce$export$2db6c17465f94a2).getSpeed(liveVector, timedPointerEvents[0].timeStamp, timedPointerEvents[1].timeStamp);
-        // update global parameters
-        if (this.parameters.live.speed > this.parameters.global.maximumSpeed) this.parameters.global.maximumSpeed = this.parameters.live.speed;
-        this.parameters.global.currentTimestamp = pointerEvent.timeStamp;
-        this.parameters.global.duration = pointerEvent.timeStamp - this.parameters.global.startTimestamp;
-        this.parameters.global.deltaX = liveVector.endPoint.x - this.parameters.global.startX;
-        this.parameters.global.deltaY = liveVector.endPoint.y - this.parameters.global.startY;
-        const globalVector = ($1f7944f1763e45ce$export$2db6c17465f94a2).getVector(this.initialPointerEvent, this.currentPointerEvent);
-        this.parameters.global.vector = globalVector;
-        this.parameters.global.distance = globalVector.vectorLength;
-        if (globalVector.vectorLength > this.parameters.global.maximumDistance) this.parameters.global.maximumDistance = globalVector.vectorLength;
-        if (this.DEBUG === true) {
-            console.log(`[PointerInput] current speed: ${this.parameters.live.speed}px/s`);
-            console.log(`[PointerInput] pointerdown duration: ${this.parameters.global.duration}ms`);
-            console.log(`[PointerInput] live vector length within vectorTimespan: ${this.parameters.live.vector.vectorLength}px`);
-        }
-    }
-    /*
-   * Get the two events which are necessary for vector calculation. This is based on this.vectorTimespan.
-   * vectorTimespan defines the timespan which actually defines the "live" vector
-   */ getTimedPointerEvents() {
-        // if the duration is lower than the vectorTimespan, startPointerEvent would be null
-        // if so, use this.initialPointerEvent as a fallback
-        let startPointerEvent = this.initialPointerEvent;
-        const endPointerEvent = this.recognizedEvents[this.recognizedEvents.length - 1];
-        let startIndex = this.recognizedEvents.length - 1;
-        let elapsedTime = 0;
-        const endTimeStamp = endPointerEvent.timeStamp;
-        while(elapsedTime < this.vectorTimespan){
-            startIndex = startIndex - 1;
-            if (startIndex < 0) break;
-            startPointerEvent = this.recognizedEvents[startIndex];
-            elapsedTime = endTimeStamp - startPointerEvent.timeStamp;
-        }
-        const pointerEvents = [
-            startPointerEvent,
-            endPointerEvent
-        ];
-        this.recognizedEvents = this.recognizedEvents.slice(-20);
-        return pointerEvents;
-    }
-}
-
-
-
-class $5fe7e4b452e08fad$export$bbcc47898202c6b8 {
-    constructor(pointer){
-        this.pointer = pointer;
-        this.parameters = pointer.parameters;
-    }
-    getTarget() {
-        return this.pointer.initialPointerEvent.target;
-    }
-    getCurrentPointerEvent() {
-        return this.pointer.currentPointerEvent;
-    }
-    // string is not good, it should be Direction
-    getCurrentDirection() {
-        return this.parameters.live.vector.direction;
-    }
-    onIdle() {}
-    onPointerMove(pointermoveEvent) {}
-    onPointerUp(pointerupEvent) {}
-    onPointerLeave(pointerleaveEvent) {}
-    onPointerCancel(pointercancelEvent) {}
-}
-
-
-
-
-const $24f1c062f8ef0b30$var$window = globalThis["window"];
-let $24f1c062f8ef0b30$export$9d2aa32114ab0612;
-if ($24f1c062f8ef0b30$var$window?.CustomEvent) // If we're in a browser environment forward the existing CustomEvent ctor
-$24f1c062f8ef0b30$export$9d2aa32114ab0612 = $24f1c062f8ef0b30$var$window.CustomEvent;
-else // eslint-disable-next-line @typescript-eslint/no-explicit-any
-$24f1c062f8ef0b30$export$9d2aa32114ab0612 = class _ extends Event {
-    constructor(type, eventInitDict){
-        super(type, eventInitDict);
-        this.detail = eventInitDict?.detail;
-    }
-    initCustomEvent() {
-        throw new Error("Unsupported deprecated method");
-    }
-};
-
-
-class $f752273e736c5336$export$6e9c3b1e1fa2b597 extends ($24f1c062f8ef0b30$export$9d2aa32114ab0612) {
-}
-class $f752273e736c5336$export$61ce360501d38a6f {
-    constructor(domElement, options){
-        this.state = (exports.GestureState).Inactive;
-        this.validPointerManagerState = null;
-        this.validPointerInputConstructor = ($5fe7e4b452e08fad$export$bbcc47898202c6b8);
-        this.domElement = domElement;
-        this.initialPointerEvent = null;
-        this.initialParameters = null;
-        this.activeStateParameters = null;
-        this.options = {
-            bubbles: true,
-            blocks: [],
-            supportedDirections: [],
-            supportedButtons: [],
-            DEBUG: false,
-            ...options
-        };
-        this.DEBUG = this.options.DEBUG;
-    }
-    getEmptyGestureParameters() {
-        const nullRecognitionParameters = {
-            global: {
-                min: {},
-                max: {},
-                boolean: {}
-            },
-            live: {
-                min: {},
-                max: {},
-                boolean: {}
-            }
-        };
-        return nullRecognitionParameters;
-    }
-    getGestureParameters() {
-        let gestureParameters;
-        if (this.state == (exports.GestureState).Active) {
-            gestureParameters = this.activeStateParameters;
-            if (this.DEBUG == true) {
-                console.log(`[${this.eventBaseName}] validating using activeStateParameters`);
-                console.log(gestureParameters);
-            }
-        } else {
-            if (this.DEBUG == true) console.log(`[${this.eventBaseName}] validating using initialParameters`);
-            gestureParameters = this.initialParameters;
-        }
-        if (gestureParameters == null) throw new Error("[Gesture] no gesture parameters found. Do not call .getGestureParameters on abstract class Gesture");
-        return gestureParameters;
-    }
-    validateGestureParameters(pointerInput) {
-        const gestureParameters = this.getGestureParameters();
-        let isValid = true;
-        let timespan;
-        for(timespan in gestureParameters){
-            const timedGestureParameters = gestureParameters[timespan];
-            const timedPointerInputValues = pointerInput.parameters[timespan];
-            let minOrMaxOrBoolean;
-            for(minOrMaxOrBoolean in timedGestureParameters){
-                const evaluationParameters = timedGestureParameters[minOrMaxOrBoolean];
-                let gestureParameterName;
-                for(gestureParameterName in evaluationParameters){
-                    const gestureParameter = evaluationParameters[gestureParameterName];
-                    const pointerInputValue = timedPointerInputValues[gestureParameterName];
-                    if (this.DEBUG == true) console.log(`[${this.eventBaseName}] validating ${timespan} ${minOrMaxOrBoolean}: required: ${gestureParameter}, pointer: ${pointerInputValue}`);
-                    if (typeof gestureParameter == "boolean" && typeof pointerInputValue == "boolean") isValid = this.validateBooleanParameter(gestureParameter, pointerInputValue);
-                    else if (typeof gestureParameter == "number" && typeof pointerInputValue == "number") isValid = this.validateMinMaxParameter(gestureParameter, pointerInputValue, minOrMaxOrBoolean);
-                    if (isValid == false) {
-                        if (this.DEBUG == true) console.log(`[${this.eventBaseName}] invalidated `);
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    validateBooleanParameter(gestureParameter, pointerInputValue) {
-        if (gestureParameter == null) return true;
-        else if (gestureParameter == pointerInputValue) {
-            if (this.DEBUG == true) console.log(`validated: required value: ${gestureParameter}, current value: ${pointerInputValue}`);
-            return true;
-        }
-        if (this.DEBUG == true) console.log(`dismissing ${this.eventBaseName}: required value: ${gestureParameter}, current value: ${pointerInputValue}`);
-        return false;
-    }
-    validateMinMaxParameter(gestureParameter, pointerInputValue, minOrMax) {
-        if (minOrMax == "min") {
-            if (pointerInputValue >= gestureParameter) return true;
-        } else if (minOrMax == "max") {
-            if (pointerInputValue <= gestureParameter) return true;
-        }
-        return false;
-    }
-    validateDirection(pointerInput) {
-        const currentDirection = pointerInput.getCurrentDirection();
-        if (this.options.supportedDirections.length && !this.options.supportedDirections.includes(currentDirection)) {
-            if (this.DEBUG == true) console.log(`[Gestures] dismissing ${this.eventBaseName}: supported directions: ${this.options.supportedDirections}, current direction: ${currentDirection}`);
-            return false;
-        }
-        return true;
-    }
-    validateGestureState() {
-        if (this.state == (exports.GestureState).Blocked) return false;
-        return true;
-    }
-    validatePointerManagerState(pointerManager) {
-        if (pointerManager.state == this.validPointerManagerState) return true;
-        if (this.DEBUG == true) console.log(`[Gesture] PointerManagerState invalidated ${this.eventBaseName}: ${pointerManager.state}`);
-        return false;
-    }
-    validatePointerInputConstructor(pointerInput) {
-        if (pointerInput instanceof this.validPointerInputConstructor) return true;
-        if (this.DEBUG == true) console.log(`[Gesture] PointerInputConstructor invalidated ${this.eventBaseName}: ${this.validPointerInputConstructor}`);
-        return false;
-    }
-    // validate pointerCount and GestureState.Blocked
-    validate(pointerManager) {
-        let isValid = this.validateGestureState();
-        if (isValid == true) isValid = this.validatePointerManagerState(pointerManager);
-        const pointerInput = pointerManager.activePointerInput;
-        if (isValid == true && pointerInput != null) {
-            isValid = this.validatePointerInputConstructor(pointerInput);
-            if (isValid == true) isValid = this.validateDirection(pointerInput);
-            if (isValid == true) isValid = this.validateGestureParameters(pointerInput);
-        }
-        return isValid;
-    }
-    recognize(pointerManager) {
-        const isValid = this.validate(pointerManager);
-        if (isValid == true && this.state == (exports.GestureState).Inactive) this.onStart(pointerManager);
-        if (isValid == true && this.state == (exports.GestureState).Active) {
-            if (this.initialPointerEvent == null) this.setInitialPointerEvent(pointerManager);
-            this.emit(pointerManager);
-        } else if (this.state == (exports.GestureState).Active && isValid == false) this.onEnd(pointerManager);
-        else if (this.DEBUG == true) console.log(`not firing event ${this.eventBaseName}. No SinglePointerInput found`);
-    }
-    /*
-   * The PointerInput for recognition has to be pointerManager.lastRemovedPointer if there is no active pointer left
-   */ getPointerInput(pointerManager) {
-        if (pointerManager.hasPointersOnSurface() == true && pointerManager.activePointerInput instanceof this.validPointerInputConstructor) return pointerManager.activePointerInput;
-        else if (pointerManager.lastRemovedPointer instanceof ($d25d2392b002d8dc$export$b56007f12edf0c17)) {
-            const pointerInput = pointerManager.getlastRemovedPointerInput();
-            if (pointerInput instanceof this.validPointerInputConstructor) return pointerInput;
-        }
-        return null;
-    }
-    setInitialPointerEvent(pointerManager) {
-        const pointerInput = this.getPointerInput(pointerManager);
-        if (pointerInput instanceof this.validPointerInputConstructor) {
-            const pointerEvent = pointerInput.getCurrentPointerEvent();
-            this.initialPointerEvent = pointerEvent;
-        }
-    }
-    emit(pointerManager, eventName) {
-        // fire general event like "tap", "press", "pan"
-        eventName = eventName || this.eventBaseName;
-        if (this.DEBUG === true) console.log(`[Gestures] detected and firing event ${eventName}`);
-        const pointerInput = this.getPointerInput(pointerManager);
-        if (pointerInput != null) {
-            const target = pointerInput.getTarget();
-            if (target instanceof EventTarget) {
-                const eventData = this.getEventData(pointerInput, pointerManager);
-                const eventOptions = {
-                    detail: eventData,
-                    bubbles: this.options.bubbles
-                };
-                if (this.DEBUG === true) console.log(eventOptions);
-                const event = new $f752273e736c5336$export$6e9c3b1e1fa2b597(eventName, eventOptions);
-                if (eventOptions.bubbles == true) target.dispatchEvent(event);
-                else this.domElement.dispatchEvent(event);
-                // fire direction specific events
-                const currentDirection = eventData.live.direction;
-                const hasSupportedDirections = !!this.options.supportedDirections;
-                // do not fire events like "panendleft"
-                // only fire directional events if eventName == this.eventBaseName
-                if (hasSupportedDirections == true && currentDirection != (exports.Direction).None && (eventName == this.eventBaseName || eventName == "swipe")) for(let d = 0; d < this.options.supportedDirections.length; d++){
-                    const direction = this.options.supportedDirections[d];
-                    if (direction == currentDirection) {
-                        const directionEventName = eventName + direction;
-                        if (this.DEBUG == true) console.log(`[Gestures] detected and firing event ${directionEventName}`);
-                        const directionEvent = new $f752273e736c5336$export$6e9c3b1e1fa2b597(directionEventName, eventOptions);
-                        if (eventOptions.bubbles == true) target.dispatchEvent(directionEvent);
-                        else this.domElement.dispatchEvent(directionEvent);
-                    }
-                }
-            }
-        }
-    }
-    onStart(pointerManager) {
-        this.blockGestures();
-        this.state = (exports.GestureState).Active;
-        this.setInitialPointerEvent(pointerManager);
-        const eventName = `${this.eventBaseName}start`;
-        this.emit(pointerManager, eventName);
-    }
-    onEnd(pointerManager) {
-        this.unblockGestures();
-        if (this.DEBUG == true) console.log(`[${this.eventBaseName}] ended. Setting ${this.eventBaseName}.state = ${(exports.GestureState).Inactive}`);
-        this.state = (exports.GestureState).Inactive;
-        const eventName = `${this.eventBaseName}end`;
-        this.emit(pointerManager, eventName);
-    }
-    // provide the ability to react (eg block) to touch events
-    /* eslint-disable @typescript-eslint/no-unused-vars */ onTouchStart(event) {}
-    onTouchMove(event) {}
-    onTouchEnd(event) {}
-    onTouchCancel(event) {}
-    /* eslint-enable @typescript-eslint/no-unused-vars */ block(gesture) {
-        if (this.options.blocks.indexOf(gesture) == -1) this.options.blocks.push(gesture);
-    }
-    unblock(gesture) {
-        if (this.options.blocks.indexOf(gesture) != -1) this.options.blocks.splice(this.options.blocks.indexOf(gesture), 1);
-    }
-    blockGestures() {
-        for(let g = 0; g < this.options.blocks.length; g++){
-            const gesture = this.options.blocks[g];
-            if (gesture.state == (exports.GestureState).Inactive) {
-                if (this.DEBUG == false) console.log(`[Gesture] blocking ${gesture.eventBaseName}`);
-                gesture.state = (exports.GestureState).Blocked;
-            }
-        }
-    }
-    unblockGestures() {
-        for(let g = 0; g < this.options.blocks.length; g++){
-            const gesture = this.options.blocks[g];
-            gesture.state = (exports.GestureState).Inactive;
-        }
-    }
-    getEventData(pointerInput, pointerManager) {
-        throw new Error("Gesture subclasses require a getEventData method()");
-    }
-}
-
-
-
-
-
-class $e8978caba4d46d00$export$718b85c80185d86e extends ($f752273e736c5336$export$61ce360501d38a6f) {
-    constructor(domElement, options){
-        super(domElement, options);
-        this.initialPointerEvent = null;
-        this.validPointerManagerState = (exports.PointerManagerState).SinglePointer;
-        const nullRecognitionParameters = this.getEmptyGestureParameters();
-        this.initialParameters = {
-            ...nullRecognitionParameters
-        };
-        // a deep copy of the parameters is needed as they can have different values
-        this.activeStateParameters = JSON.parse(JSON.stringify({
-            ...nullRecognitionParameters
-        }));
-    }
-    getEventData(singlePointerInput, pointerManager) {
-        // provide short-cuts to the values collected in the Contact object
-        // match this to the event used by hammer.js
-        const globalParameters = singlePointerInput.parameters.live;
-        const liveParameters = singlePointerInput.parameters.live;
-        let globalVector = globalParameters.vector;
-        let globalDuration = globalParameters.duration;
-        // gesture specific - dependant on the beginning of the gesture (when the gesture has initially been recognized)
-        if (this.initialPointerEvent != null) {
-            const globalStartPoint = new ($07c7ab2351895186$export$baf26146a414f24a)(this.initialPointerEvent.clientX, this.initialPointerEvent.clientY);
-            const globalEndPoint = new ($07c7ab2351895186$export$baf26146a414f24a)(singlePointerInput.pointer.currentPointerEvent.clientX, singlePointerInput.pointer.currentPointerEvent.clientY);
-            globalVector = new ($c0ee1a209fd4fc8d$export$9b781de7bf37bf48)(globalStartPoint, globalEndPoint);
-            globalDuration = singlePointerInput.pointer.currentPointerEvent.timeStamp - this.initialPointerEvent.timeStamp;
-        }
-        // global: global for this recognizer, not the Contact object
-        const globalGestureEventData = {
-            deltaX: globalVector.x,
-            deltaY: globalVector.y,
-            distance: globalVector.vectorLength,
-            speedX: globalVector.x / globalDuration,
-            speedY: globalVector.y / globalDuration,
-            speed: globalVector.vectorLength / globalDuration,
-            direction: globalVector.direction,
-            scale: 1,
-            rotation: 0,
-            center: {
-                x: globalParameters.vector.endPoint.x,
-                y: globalParameters.vector.endPoint.y
-            },
-            srcEvent: singlePointerInput.pointer.currentPointerEvent
-        };
-        const liveGestureEventData = {
-            deltaX: liveParameters.vector.x,
-            deltaY: liveParameters.vector.y,
-            distance: liveParameters.vector.vectorLength,
-            speedX: liveParameters.vector.x / singlePointerInput.pointer.vectorTimespan,
-            speedY: liveParameters.vector.y / singlePointerInput.pointer.vectorTimespan,
-            speed: liveParameters.speed,
-            direction: liveParameters.vector.direction,
-            scale: 1,
-            rotation: 0,
-            center: {
-                x: liveParameters.vector.endPoint.x,
-                y: liveParameters.vector.endPoint.y
-            },
-            srcEvent: singlePointerInput.pointer.currentPointerEvent /*,
-      target : primaryPointerInput.touch.target,
-      pointerType : ,
-      eventType : ,
-      isFirst : ,
-      isFinal :,
-      pointers : ,*/ 
-        };
-        const eventData = {
-            recognizer: this,
-            global: globalGestureEventData,
-            live: liveGestureEventData,
-            pointerManager: pointerManager
-        };
-        return eventData;
-    }
-    validateButton(pointerManager) {
-        if (this.options.supportedButtons.length > 0) {
-            const activePointerInput = pointerManager.activePointerInput;
-            const lastRemovedPointer = pointerManager.lastRemovedPointer;
-            let pointerEvent = null;
-            if (activePointerInput != null) pointerEvent = activePointerInput.getCurrentPointerEvent();
-            else if (lastRemovedPointer != null) pointerEvent = lastRemovedPointer.currentPointerEvent;
-            if (pointerEvent != null && pointerEvent.pointerType == "mouse" && this.options.supportedButtons.indexOf(pointerEvent.buttons) == -1) {
-                if (this.DEBUG == true) console.log(`dismissing ${this.eventBaseName}: supportedButtons: ${this.options.supportedButtons.toString()}, poinerEvent.buttons: ${pointerEvent.buttons}`);
-                return false;
-            }
-        }
-        return true;
-    }
-    validate(pointerManager) {
-        let isValid = this.validateButton(pointerManager);
-        if (isValid == true) isValid = super.validate(pointerManager);
-        return isValid;
-    }
-}
-
-
-
-
-class $b6ec4e8a6d9d51ec$export$4451a18ddc7083b7 extends ($e8978caba4d46d00$export$718b85c80185d86e) {
-    constructor(domElement, options){
-        super(domElement, options);
-        this.validPointerManagerState = (exports.PointerManagerState).NoPointer;
-        this.eventBaseName = "tap";
-        let globalMaxDuration = 499;
-        let liveMaxDistance = 30;
-        let globalMaxDistance = 30;
-        if (options) {
-            if ("maxDuration" in options) globalMaxDuration = options["maxDuration"];
-            if ("maxDistance" in options) {
-                liveMaxDistance = options["maxDistance"];
-                globalMaxDistance = options["maxDistance"];
-            }
-        }
-        this.initialParameters.global.max["duration"] = globalMaxDuration; // milliseconds. after a certain touch duration, it is not a TAP anymore
-        this.initialParameters.live.max["distance"] = liveMaxDistance; // if a certain distance is detected, TAP becomes impossible
-        this.initialParameters.global.max["distance"] = globalMaxDistance; // if a certain distance is detected, TAP becomes impossible
-    }
-    validateButton(pointerManager) {
-        if (this.options.supportedButtons.length > 0) {
-            const lastRemovedPointer = pointerManager.lastRemovedPointer;
-            if (lastRemovedPointer != null) {
-                const pointerEvent = lastRemovedPointer.currentPointerEvent;
-                // pointerEvent.button instead of pointerEvent.buttons
-                if (pointerEvent.pointerType == "mouse" && this.options.supportedButtons.indexOf(pointerEvent.button) == -1) {
-                    if (this.DEBUG == true) console.log(`dismissing ${this.eventBaseName}: supportedButtons: ${this.options.supportedButtons.toString()}, poinerEvent.button: ${pointerEvent.button}`);
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    validate(pointerManager) {
-        let isValid = this.validateGestureState();
-        if (isValid == true) isValid = this.validatePointerManagerState(pointerManager);
-        if (isValid == true) isValid = this.validateButton(pointerManager);
-        if (isValid === true) {
-            if (pointerManager.lastInputSessionPointerCount != 1) return false;
-            else {
-                const singlePointerInput = pointerManager.getlastRemovedPointerInput();
-                if (singlePointerInput instanceof ($5fe7e4b452e08fad$export$bbcc47898202c6b8)) isValid = this.validateGestureParameters(singlePointerInput);
-                else isValid = false;
-            }
-        }
-        return isValid;
-    }
-    // do not set Tap.state = GestureState.active as Tap has no active state
-    onStart(pointerManager) {
-        this.setInitialPointerEvent(pointerManager);
-        this.emit(pointerManager);
-    }
-}
-
-
-
-
-
-class $5653a1f5fdc2db30$export$90610caf6d8d0242 extends ($e8978caba4d46d00$export$718b85c80185d86e) {
-    static minDuration = 500;
-    constructor(domElement, options){
-        super(domElement, options);
-        this.eventBaseName = "press";
-        let globalMinDuration = 500;
-        let globalMaxDistance = 10;
-        let globalMaxMaximumDistance = 20;
-        if (options) {
-            if ("minDuration" in options) globalMinDuration = options["minDuration"];
-            if ("maxDistance" in options) {
-                globalMaxMaximumDistance = options["maxDistance"];
-                globalMaxDistance = options["maxDistance"];
-            }
-        }
-        this.initialParameters.global.min["duration"] = globalMinDuration; // milliseconds. after a certain touch duration, it is not a TAP anymore
-        this.initialParameters.global.max["distance"] = globalMaxDistance; // if the pointer moved a certain distance, Press becomes impossible
-        this.initialParameters.global.max["maximumDistance"] = globalMaxMaximumDistance;
-        // only Press has this parameter
-        this.hasBeenEmitted = false;
-    }
-    recognize(pointerManager) {
-        const isValid = this.validate(pointerManager);
-        const singlePointerInput = this.getPointerInput(pointerManager);
-        // is this line really necessary? ESLint complains if it is not present, although its value is set in the constructor
-        // adding Object.freeze(this.initialParameters) in the constructor did not resolve the ESLint error
-        const minDuration = this.initialParameters.global.min["duration"] || $5653a1f5fdc2db30$export$90610caf6d8d0242.minDuration;
-        if (singlePointerInput instanceof ($5fe7e4b452e08fad$export$bbcc47898202c6b8)) {
-            if (isValid == true && this.hasBeenEmitted == false) {
-                this.setInitialPointerEvent(pointerManager);
-                this.emit(pointerManager);
-                this.hasBeenEmitted = true;
-                this.state = (exports.GestureState).Active;
-                this.blockGestures();
-            } else if (isValid == false && this.hasBeenEmitted == true) {
-                this.onEnd(pointerManager);
-                this.state = (exports.GestureState).Inactive;
-                this.hasBeenEmitted = false;
-            } else {
-                const duration = singlePointerInput.parameters.global.duration;
-                if (this.hasBeenEmitted == true && duration <= minDuration) this.hasBeenEmitted = false;
-            }
-        }
-        if (singlePointerInput == null) this.hasBeenEmitted = false;
-    }
-}
-
-
-
-
-
-
-class $7a0f7fd2f33d0212$export$f86166cd6057c2d1 extends ($e8978caba4d46d00$export$718b85c80185d86e) {
-    constructor(domElement, options){
-        super(domElement, options);
-        this.validPointerManagerState = (exports.PointerManagerState).SinglePointer;
-        this.eventBaseName = "pan";
-        this.initialParameters.global.min["duration"] = 0;
-        this.initialParameters.live.min["distance"] = 10;
-        this.initialParameters.global.boolean["hasBeenMoved"] = true;
-        this.swipeFinalSpeed = 600;
-        this.isSwipe = false;
-        this.options.supportedDirections = options?.supportedDirections ?? ($a2188ba8c266b376$export$86ae6e8ac17a67c6).All;
-        this.initialSupportedDirections = this.options.supportedDirections;
-    }
-    validate(pointerManager) {
-        // on second recognition allow all directions. otherwise, the "pan" mode would end if the finger was moved right and then down during "panleft" mode
-        if (this.state == (exports.GestureState).Active) this.options.supportedDirections = ($a2188ba8c266b376$export$86ae6e8ac17a67c6).All;
-        const isValid = super.validate(pointerManager);
-        return isValid;
-    }
-    onStart(pointerManager) {
-        this.isSwipe = false;
-        super.onStart(pointerManager);
-    }
-    // check if it was a swipe
-    onEnd(pointerManager) {
-        const singlePointerInput = pointerManager.getlastRemovedPointerInput();
-        if (singlePointerInput instanceof ($5fe7e4b452e08fad$export$bbcc47898202c6b8)) {
-            if (this.swipeFinalSpeed < singlePointerInput.parameters.global.finalSpeed && singlePointerInput.parameters.live.vector.direction != (exports.Direction).None) {
-                this.isSwipe = true;
-                this.emit(pointerManager, "swipe");
-            } else if (this.DEBUG == true) {
-                if (singlePointerInput.parameters.global.finalSpeed < this.swipeFinalSpeed) console.log(`[Pan] dismissing swipe. Final speed: ${singlePointerInput.parameters.global.finalSpeed} < ${this.swipeFinalSpeed}`);
-                else console.log(`[Pan] dismissing swipe. Direction: ${singlePointerInput.parameters.live.vector.direction}`);
-            }
-        }
-        super.onEnd(pointerManager);
-        this.options.supportedDirections = this.initialSupportedDirections;
-    }
-    onTouchMove(event) {
-        if (this.state == (exports.GestureState).Active) {
-            if (this.DEBUG == true) console.log("[Pan] preventing touchmove default");
-            event.preventDefault();
-            event.stopPropagation();
-        }
-    }
-}
-
-
-
-
-class $ba0aae203ff6b3f9$export$bdba51b3ce92d5f1 {
-    constructor(pointer_1, pointer_2){
-        this.pointerIds = new Set([
-            pointer_1.pointerId,
-            pointer_2.pointerId
-        ]);
-        this.startTimestamp = new Date().getTime();
-        this.pointerMap = {};
-        this.pointerMap[pointer_1.pointerId] = pointer_1;
-        this.pointerMap[pointer_2.pointerId] = pointer_2;
-        this.pointer_1 = pointer_1;
-        this.pointer_2 = pointer_2;
-        this.initialPointerEvent = pointer_1.initialPointerEvent;
-        this.currentPointerEvent = pointer_1.initialPointerEvent;
-        const globalVector_1 = this.pointer_1.parameters.global.vector;
-        const globalVector_2 = this.pointer_2.parameters.global.vector;
-        const globalCenter = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenter(globalVector_1.startPoint, globalVector_2.startPoint);
-        const globalCenterMovementVector = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenterMovementVector(globalVector_1, globalVector_2);
-        const globalParameters = {
-            duration: 0,
-            center: globalCenter,
-            centerHasBeenMoved: false,
-            centerMovementDistance: 0,
-            centerMovementVector: globalCenterMovementVector,
-            absolutePointerDistanceChange: 0,
-            relativePointerDistanceChange: 0,
-            rotationAngle: 0,
-            absoluteRotationAngle: 0,
-            vectorAngle: 0,
-            absoluteVectorAngle: 0
-        };
-        const liveVector_1 = this.pointer_1.parameters.live.vector;
-        const liveVector_2 = this.pointer_2.parameters.live.vector;
-        const liveCenter = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenter(liveVector_1.startPoint, liveVector_2.startPoint);
-        const liveCenterMovementVector = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenterMovementVector(liveVector_1, liveVector_2);
-        const liveParameters = {
-            center: liveCenter,
-            centerIsMoving: false,
-            centerMovementDistance: 0,
-            centerMovementVector: liveCenterMovementVector,
-            absolutePointerDistanceChange: 0,
-            relativePointerDistanceChange: 0,
-            rotationAngle: 0,
-            absoluteRotationAngle: 0,
-            vectorAngle: 0,
-            absoluteVectorAngle: 0
-        };
-        const parameters = {
-            global: globalParameters,
-            live: liveParameters
-        };
-        this.parameters = parameters;
-    }
-    removePointer(pointerId) {
-        if (pointerId == this.pointer_1.pointerId) return this.pointer_2;
-        else if (pointerId == this.pointer_2.pointerId) return this.pointer_1;
-        else throw new Error(`[DualPointerInput] cannot remove Pointer #${pointerId}. The pointer is not part of this DualPointerInput`);
-    }
-    getTarget() {
-        return this.initialPointerEvent.target;
-    }
-    update(pointerEvent) {
-        if (pointerEvent instanceof PointerEvent) this.currentPointerEvent = pointerEvent;
-        const now = new Date().getTime();
-        this.parameters.global["duration"] = now - this.startTimestamp;
-        const globalVector_1 = this.pointer_1.parameters.global.vector;
-        const globalVector_2 = this.pointer_2.parameters.global.vector;
-        const globalCenter = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenter(globalVector_1.startPoint, globalVector_2.startPoint);
-        const globalCenterMovementVector = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenterMovementVector(globalVector_1, globalVector_2);
-        const globalAbsoluteDistanceChange = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateAbsoluteDistanceChange(globalVector_1, globalVector_2);
-        const globalRelativeDistanceChange = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateRelativeDistanceChange(globalVector_1, globalVector_2);
-        const globalRotationAngle = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateRotationAngle(globalVector_1, globalVector_2);
-        const globalVectorAngle = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateVectorAngle(globalVector_1, globalVector_2);
-        this.parameters.global["center"] = globalCenter;
-        this.parameters.global["centerMovementVector"] = globalCenterMovementVector;
-        this.parameters.global["centerMovementDistance"] = globalCenterMovementVector.vectorLength;
-        this.parameters.global["absolutePointerDistanceChange"] = globalAbsoluteDistanceChange;
-        this.parameters.global["relativePointerDistanceChange"] = globalRelativeDistanceChange;
-        this.parameters.global["rotationAngle"] = globalRotationAngle;
-        this.parameters.global["absoluteRotationAngle"] = Math.abs(globalRotationAngle);
-        this.parameters.global["vectorAngle"] = globalVectorAngle;
-        this.parameters.global["absoluteVectorAngle"] = Math.abs(globalVectorAngle);
-        const liveVector_1 = this.pointer_1.parameters.live.vector;
-        const liveVector_2 = this.pointer_2.parameters.live.vector;
-        const liveCenter = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenter(liveVector_1.startPoint, liveVector_2.startPoint);
-        const liveCenterMovementVector = ($1f7944f1763e45ce$export$2db6c17465f94a2).getCenterMovementVector(liveVector_1, liveVector_2);
-        const liveAbsoluteDistanceChange = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateAbsoluteDistanceChange(liveVector_1, liveVector_2);
-        const liveRelativeDistanceChange = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateRelativeDistanceChange(liveVector_1, liveVector_2);
-        // calculate rotation angle. imagine the user turning a wheel with 2 fingers
-        const liveRotationAngle = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateRotationAngle(liveVector_1, liveVector_2);
-        const liveVectorAngle = ($1f7944f1763e45ce$export$2db6c17465f94a2).calculateVectorAngle(liveVector_1, liveVector_2);
-        if (liveCenterMovementVector.vectorLength > 0) {
-            this.parameters.live.centerIsMoving = true;
-            this.parameters.global.centerHasBeenMoved = true;
-        } else this.parameters.live.centerIsMoving = false;
-        this.parameters.live["center"] = liveCenter;
-        this.parameters.live["centerMovementDistance"] = liveCenterMovementVector.vectorLength;
-        this.parameters.live["centerMovementVector"] = liveCenterMovementVector;
-        this.parameters.live["absolutePointerDistanceChange"] = liveAbsoluteDistanceChange;
-        this.parameters.live["relativePointerDistanceChange"] = liveRelativeDistanceChange;
-        this.parameters.live["rotationAngle"] = liveRotationAngle;
-        this.parameters.live["absoluteRotationAngle"] = Math.abs(liveRotationAngle);
-        this.parameters.live["vectorAngle"] = liveVectorAngle;
-        this.parameters.live["absoluteVectorAngle"] = Math.abs(liveVectorAngle);
-    }
-    onPointerMove(pointermoveEvent) {
-        this.update(pointermoveEvent);
-    }
-    onPointerUp(pointerupEvent) {
-        this.update(pointerupEvent);
-    }
-    onPointerLeave(pointerleaveEvent) {
-        this.update(pointerleaveEvent);
-    }
-    onPointerCancel(pointercancelEvent) {
-        this.update(pointercancelEvent);
-    }
-    onIdle() {
-        this.update();
-    }
-    // string is not good, it should be Direction
-    getCurrentDirection() {
-        return this.parameters.live.centerMovementVector.direction;
-    }
-    getCurrentPointerEvent() {
-        return this.currentPointerEvent;
-    }
-}
-
-
-
-class $a1a4c2869495e604$export$f9d89efe4b7795e7 extends ($f752273e736c5336$export$61ce360501d38a6f) {
-    constructor(domElement, options){
-        super(domElement, options);
-        this.initialPointerEvent_1 = null;
-        this.initialPointerEvent_2 = null;
-        this.validPointerManagerState = (exports.PointerManagerState).DualPointer;
-        this.validPointerInputConstructor = ($ba0aae203ff6b3f9$export$bdba51b3ce92d5f1);
-        const nullRecognitionParameters = this.getEmptyGestureParameters();
-        this.initialParameters = {
-            ...nullRecognitionParameters
-        };
-        this.activeStateParameters = JSON.parse(JSON.stringify({
-            ...nullRecognitionParameters
-        }));
-    }
-    getEventData(dualPointerInput, pointerManager) {
-        // provide short-cuts to the values collected in the Contact object
-        // match this to the event used by hammer.js
-        const globalParameters = dualPointerInput.parameters.global;
-        const liveParameters = dualPointerInput.parameters.live;
-        const globalGestureEventData = {
-            deltaX: globalParameters.centerMovementVector.x,
-            deltaY: globalParameters.centerMovementVector.y,
-            distance: globalParameters.centerMovementDistance,
-            speedX: globalParameters.centerMovementVector.x / globalParameters.duration,
-            speedY: globalParameters.centerMovementVector.y / globalParameters.duration,
-            speed: globalParameters.centerMovementVector.vectorLength / globalParameters.duration,
-            direction: globalParameters.centerMovementVector.direction,
-            scale: globalParameters.relativePointerDistanceChange,
-            rotation: globalParameters.rotationAngle,
-            center: globalParameters.center,
-            srcEvent: dualPointerInput.currentPointerEvent
-        };
-        const liveGestureEventData = {
-            deltaX: liveParameters.centerMovementVector.x,
-            deltaY: liveParameters.centerMovementVector.y,
-            distance: liveParameters.centerMovementDistance,
-            speedX: liveParameters.centerMovementVector.x / globalParameters.duration,
-            speedY: liveParameters.centerMovementVector.y / globalParameters.duration,
-            speed: liveParameters.centerMovementVector.vectorLength / globalParameters.duration,
-            direction: liveParameters.centerMovementVector.direction,
-            scale: liveParameters.relativePointerDistanceChange,
-            rotation: liveParameters.rotationAngle,
-            center: {
-                x: liveParameters.centerMovementVector.startPoint.x,
-                y: liveParameters.centerMovementVector.startPoint.y
-            },
-            srcEvent: dualPointerInput.currentPointerEvent
-        };
-        const gestureEventData = {
-            recognizer: this,
-            global: globalGestureEventData,
-            live: liveGestureEventData,
-            pointerManager: pointerManager
-        };
-        return gestureEventData;
-    }
-}
-
-
-class $ed7931f1d96d5294$export$826ae541ddf1527b extends ($a1a4c2869495e604$export$f9d89efe4b7795e7) {
-    constructor(domElement, options){
-        super(domElement, options);
-        this.eventBaseName = "pinch";
-        this.initialParameters.live.min["centerMovementDistance"] = 0;
-        this.initialParameters.live.max["centerMovementDistance"] = 50; //px
-        this.initialParameters.live.min["absolutePointerDistanceChange"] = 5; // distance between 2 fingers
-        this.initialParameters.live.max["absoluteRotationAngle"] = 20;
-        this.initialParameters.live.min["absoluteVectorAngle"] = 10;
-    }
-}
-
-
-
-class $9fe2bb90b337f66c$export$152db69a76b6b79e extends ($a1a4c2869495e604$export$f9d89efe4b7795e7) {
-    constructor(domElement, options){
-        super(domElement, options);
-        this.eventBaseName = "rotate";
-        this.initialParameters.live.min["centerMovementDistance"] = 0;
-        this.initialParameters.live.max["centerMovementDistance"] = 50;
-        this.initialParameters.live.max["absolutePointerDistanceChange"] = 50;
-        this.initialParameters.live.min["absoluteRotationAngle"] = 5;
-        this.activeStateParameters.live.min["absoluteRotationAngle"] = 0;
-    }
-}
-
-
-
-class $59226122237c359c$export$8847187e02a498e8 extends ($a1a4c2869495e604$export$f9d89efe4b7795e7) {
-    constructor(domElement, options){
-        super(domElement, options);
-        this.eventBaseName = "twofingerpan";
-        this.initialParameters.live.min["centerMovementDistance"] = 10;
-        this.initialParameters.live.max["absolutePointerDistanceChange"] = 50;
-        this.initialParameters.live.max["absoluteVectorAngle"] = 150;
-        this.activeStateParameters.live.min["centerMovementDistance"] = 0;
-    }
-}
-
-
-
-
-
-
-class $4f5a7b355079efa2$export$af6d1be017a420a {
-    constructor(options){
-        options = options || {};
-        this.options = {
-            DEBUG: false,
-            ...options
-        };
-        this.DEBUG = this.options.DEBUG;
-        this.state = (exports.PointerManagerState).NoPointer;
-        this.activePointerInput = null;
-        this.lastRemovedPointer = null;
-        this.lastInputSessionPointerCount = 0;
-        this.pointerAllocation = {};
-        this.unusedPointers = {}; // pointers on the surface that are not interpreted right now
-        this.onSurfacePointers = {};
-    }
-    addPointer(pointerdownEvent) {
-        if (this.DEBUG == true) console.log(`[PointerManager] adding Pointer #${pointerdownEvent.pointerId.toString()}`);
-        const pointerOptions = {
-            DEBUG: this.DEBUG
-        };
-        const pointer = new ($d25d2392b002d8dc$export$b56007f12edf0c17)(pointerdownEvent, pointerOptions);
-        this.onSurfacePointers[pointer.pointerId] = pointer;
-        if (this.activePointerInput == null) this.setActiveSinglePointerInput(pointer);
-        else if (this.activePointerInput instanceof ($5fe7e4b452e08fad$export$bbcc47898202c6b8)) this.setActiveDualPointerInput(this.activePointerInput.pointer, pointer);
-        else if (this.activePointerInput instanceof ($ba0aae203ff6b3f9$export$bdba51b3ce92d5f1)) this.unusedPointers[pointer.pointerId] = pointer;
-        this.lastInputSessionPointerCount = this.currentPointerCount();
-    }
-    /**
-   * called on the following events: pointerup, pointerleave(?), pointercancel
-   * 1 -> 0 : SinglePointerInput -> null
-   * 2 -> 1 : DualPointerInput -> SinglePointerInput
-   * 3 -> 2 : DualPointerInput -> DualPointerInput (new combination or no change)
-   */ removePointer(pointerId) {
-        if (this.DEBUG == true) {
-            console.log(`[PointerManager] starting to remove Pointer #${pointerId}`);
-            console.log(`[PointerManager] state: ${this.state}`);
-        }
-        const pointer = this.onSurfacePointers[pointerId];
-        this.lastRemovedPointer = pointer;
-        // remove from registries
-        delete this.onSurfacePointers[pointerId];
-        if (pointerId in this.unusedPointers) delete this.unusedPointers[pointerId];
-        // set this.activePointerInput to null if the Pointer was part of it
-        // DualPointerInput -> SinglePointerInput
-        // OR DualPointerInput -> new DualPointerInput
-        if (this.activePointerInput instanceof ($ba0aae203ff6b3f9$export$bdba51b3ce92d5f1)) {
-            if (this.activePointerInput.pointerIds.has(pointerId)) {
-                if (this.DEBUG == true) console.log(`[PointerManager] removing Pointer #${pointerId} from DualPointerInput`);
-                const remainingPointer = this.activePointerInput.removePointer(pointerId);
-                this.activePointerInput = null;
-                // remainingPointer should be used for the next this.activePointerInput
-                const unusedPointerInput = this.getUnusedPointer();
-                if (unusedPointerInput instanceof ($d25d2392b002d8dc$export$b56007f12edf0c17)) this.setActiveDualPointerInput(remainingPointer, unusedPointerInput);
-                else this.setActiveSinglePointerInput(remainingPointer);
-            }
-        // a 3rd pointer which has not been part of DualPointerInput has been removed
-        } else if (this.activePointerInput instanceof ($5fe7e4b452e08fad$export$bbcc47898202c6b8)) {
-            if (this.DEBUG == true) console.log(`[PointerManager] removing Pointer #${pointerId} from SinglePointerInput`);
-            this.activePointerInput = null;
-            this.state = (exports.PointerManagerState).NoPointer;
-            // this should not be necessary
-            if (Object.keys(this.unusedPointers).length > 0) {
-                this.unusedPointers = {};
-                throw new Error("[PointerManager] found unused Pointers although there should not be any");
-            }
-            if (Object.keys(this.onSurfacePointers).length > 0) {
-                this.onSurfacePointers = {};
-                throw new Error("[PointerManager] found onSurfacePointers although there should not be any");
-            }
-        }
-        if (this.DEBUG == true) console.log(`[PointerManager] state: ${this.state}`);
-    }
-    setActiveSinglePointerInput(pointer) {
-        pointer.reset();
-        const singlePointerInput = new ($5fe7e4b452e08fad$export$bbcc47898202c6b8)(pointer);
-        this.activePointerInput = singlePointerInput;
-        this.pointerAllocation[pointer.pointerId] = singlePointerInput;
-        delete this.unusedPointers[pointer.pointerId];
-        this.state = (exports.PointerManagerState).SinglePointer;
-        if (this.DEBUG == true) console.log(`[PointerManager] state: ${this.state}`);
-    }
-    setActiveDualPointerInput(pointer_1, pointer_2) {
-        pointer_1.reset();
-        pointer_2.reset();
-        const dualPointerInput = new ($ba0aae203ff6b3f9$export$bdba51b3ce92d5f1)(pointer_1, pointer_2);
-        this.activePointerInput = dualPointerInput;
-        this.pointerAllocation[pointer_1.pointerId] = dualPointerInput;
-        this.pointerAllocation[pointer_2.pointerId] = dualPointerInput;
-        delete this.unusedPointers[pointer_1.pointerId];
-        delete this.unusedPointers[pointer_2.pointerId];
-        this.state = (exports.PointerManagerState).DualPointer;
-        if (this.DEBUG == true) console.log(`[PointerManager] state: ${this.state}`);
-    }
-    hasPointersOnSurface() {
-        if (Object.keys(this.onSurfacePointers).length > 0) return true;
-        return false;
-    }
-    currentPointerCount() {
-        return Object.keys(this.onSurfacePointers).length;
-    }
-    getUnusedPointer() {
-        if (Object.keys(this.unusedPointers).length > 0) {
-            const pointer = Object.values(this.unusedPointers)[0];
-            return pointer;
-        }
-        return null;
-    }
-    getPointerFromId(pointerId) {
-        if (pointerId in this.onSurfacePointers) return this.onSurfacePointers[pointerId];
-        return null;
-    }
-    getlastRemovedPointerInput() {
-        if (this.lastRemovedPointer instanceof ($d25d2392b002d8dc$export$b56007f12edf0c17)) return this.pointerAllocation[this.lastRemovedPointer.pointerId];
-        return null;
-    }
-    onIdle() {
-        for(const pointerId in this.onSurfacePointers){
-            const pointer = this.onSurfacePointers[pointerId];
-            pointer.onIdle();
-        }
-        this.activePointerInput?.onIdle();
-    }
-    /**
-   * PointerEvent handlers
-   * - the Pointer is always updated firs
-   * - afterwards, the current activePointerInput is updated
-   */ onPointerMove(pointermoveEvent) {
-        const pointer = this.getPointerFromId(pointermoveEvent.pointerId);
-        if (pointer instanceof ($d25d2392b002d8dc$export$b56007f12edf0c17)) pointer.onPointerMove(pointermoveEvent);
-        this.activePointerInput?.onPointerMove(pointermoveEvent);
-    }
-    onPointerUp(pointerupEvent) {
-        if (this.DEBUG == true) console.log("[PointerManager] pointerup detected");
-        const pointer = this.getPointerFromId(pointerupEvent.pointerId);
-        if (pointer instanceof ($d25d2392b002d8dc$export$b56007f12edf0c17)) pointer.onPointerUp(pointerupEvent);
-        this.activePointerInput?.onPointerUp(pointerupEvent);
-        this.removePointer(pointerupEvent.pointerId);
-    }
-    /*onPointerOver(pointeroverEvent: PointerEvent): void {
-
-  }
-
-  onPointerLeave(pointerleaveEvent: PointerEvent): void {
-    if (this.DEBUG == true) {
-      console.log(`[PointerManager] pointerLeave detected`);
-    }
-    const pointer = this.getPointerFromId(pointerleaveEvent.pointerId);
-    if (pointer instanceof Pointer) {
-      pointer.onPointerLeave(pointerleaveEvent);
-    }
-    this.activePointerInput?.onPointerLeave(pointerleaveEvent);
-    // pointerleave does not mean th pointer left the surface
-    // the pointer left the bound element
-    this.removePointer(pointerleaveEvent.pointerId);
-  }
-
-  onPointerOut(pointeroutEvent: PointerEvent): void {
-    if (this.DEBUG == true) {
-      console.log(`[PointerManager] pointerout detected`);
-    }
-    const pointer = this.getPointerFromId(pointeroutEvent.pointerId);
-    if (pointer instanceof Pointer) {
-      pointer.onPointerLeave(pointeroutEvent);
-    }
-    this.activePointerInput?.onPointerLeave(pointeroutEvent);
-    // pointerleave does not mean th pointer left the surface
-    // the pointer left the bound element
-    this.removePointer(pointeroutEvent.pointerId);
-  }*/ onPointerCancel(pointercancelEvent) {
-        if (this.DEBUG == true) console.log("[PointerManager] pointercancel detected");
-        const pointer = this.getPointerFromId(pointercancelEvent.pointerId);
-        if (pointer instanceof ($d25d2392b002d8dc$export$b56007f12edf0c17)) pointer.onPointerCancel(pointercancelEvent);
-        this.activePointerInput?.onPointerCancel(pointercancelEvent);
-        this.removePointer(pointercancelEvent.pointerId);
-    }
-}
-
-
-
-const $03c52e54621b9b86$var$ALL_GESTURE_CLASSES = [
-    ($b6ec4e8a6d9d51ec$export$4451a18ddc7083b7),
-    ($5653a1f5fdc2db30$export$90610caf6d8d0242),
-    ($7a0f7fd2f33d0212$export$f86166cd6057c2d1),
-    ($ed7931f1d96d5294$export$826ae541ddf1527b),
-    ($9fe2bb90b337f66c$export$152db69a76b6b79e),
-    ($59226122237c359c$export$8847187e02a498e8)
-];
-class $03c52e54621b9b86$export$9371bd96776f4e82 {
-    constructor(domElement, options){
-        this.state = (exports.PointerListenerState).NoActiveGesture;
-        this.activeGestures = [];
-        this.hadActiveGestureDuringCurrentContact = false;
-        // registry for events like "pan", "rotate", which have to be removed on this.destroy();
-        this.gestureEventHandlers = {};
-        this.lastRecognitionTimestamp = null;
-        this.idleRecognitionIntervalId = null;
-        this.pointerEventHandlers = {};
-        this.touchEventHandlers = {};
-        options = options || {};
-        this.options = {
-            DEBUG: false,
-            DEBUG_GESTURES: false,
-            DEBUG_POINTERMANAGER: false,
-            bubbles: true,
-            handleTouchEvents: true,
-            consecutiveGestures: true,
-            simultaneousGestures: true,
-            supportedGestures: [],
-            ...options
-        };
-        this.DEBUG = this.options.DEBUG;
-        const supportedGestures = options.supportedGestures ?? $03c52e54621b9b86$var$ALL_GESTURE_CLASSES;
-        // instantiate gesture classes on domElement and add them to this.options
-        const instantiatedGestures = supportedGestures.map((GestureClass)=>{
-            if (typeof GestureClass === "function") {
-                const gestureOptions = {
-                    bubbles: this.options.bubbles,
-                    DEBUG: this.options.DEBUG_GESTURES
-                };
-                return new GestureClass(domElement, gestureOptions);
-            }
-            if (typeof GestureClass === "object") return GestureClass;
-            throw new Error(`unsupported gesture type: ${typeof GestureClass}`);
-        });
-        // this.supportedGestures have to be instantiated gestures
-        this.supportedGestures = instantiatedGestures;
-        this.domElement = domElement;
-        const pointerManagerOptions = {
-            DEBUG: this.options.DEBUG_POINTERMANAGER
-        };
-        this.pointerManager = new ($4f5a7b355079efa2$export$af6d1be017a420a)(pointerManagerOptions);
-        // disable context menu on long taps - this kills pointermove
-        /*domElement.addEventListener("contextmenu", (event) => {
-      event.preventDefault();
-      return false;
-    });*/ this.addPointerEventListeners();
-        this.addTouchEventListeners();
-    }
-    /* PointerEvent handling */ addPointerEventListeners() {
-        const domElement = this.domElement;
-        // create references, so the listener can be removed at a later time
-        // .bind(this): make sure that the instance of PointerListener is accessible in the EventHandler
-        const onPointerDown = this.onPointerDown.bind(this);
-        const onPointerMove = this.onPointerMove.bind(this);
-        const onPointerUp = this.onPointerUp.bind(this);
-        //const onPointerLeave = this.onPointerLeave.bind(this);
-        //const onPointerOut = this.onPointerOut.bind(this);
-        const onPointerCancel = this.onPointerCancel.bind(this);
-        domElement.addEventListener("pointerdown", onPointerDown, {
-            passive: true
-        });
-        domElement.addEventListener("pointermove", onPointerMove, {
-            passive: true
-        });
-        domElement.addEventListener("pointerup", onPointerUp, {
-            passive: true
-        });
-        /*
-     * case: user presses mouse button and moves element. while moving, the cursor leaves the element (fires pointerout)
-     *		while outside the element, the mouse button is released. pointerup is not fired.
-     *		during pan, pan should not end if the pointer leaves the element.
-     * MDN: Pointer capture allows events for a particular pointer event (PointerEvent) to be re-targeted to a particular element instead of the normal (or hit test) target at a pointer's location. This can be used to ensure that an element continues to receive pointer events even if the pointer device's contact moves off the element (such as by scrolling or panning).
-     *  this problem is solved by using setPointerCapture()
-     */ //domElement.addEventListener("pointerleave", onPointerLeave, { passive: true });
-        //domElement.addEventListener("pointerout", onPointerOut, { passive: true });
-        domElement.addEventListener("pointercancel", onPointerCancel, {
-            passive: true
-        });
-        this.pointerEventHandlers = {
-            pointerdown: onPointerDown,
-            pointermove: onPointerMove,
-            pointerup: onPointerUp,
-            //pointerleave: onPointerLeave,
-            //pointerout: onPointerOut,
-            pointercancel: onPointerCancel
-        };
-    }
-    // there may be more than one pointer. Each new pointer fires onPointerDown
-    onPointerDown(pointerdownEvent) {
-        if (this.DEBUG == true) console.log("[PointerListener] pointerdown event detected");
-        // re-target all pointerevents to the current element
-        // see https://developer.mozilla.org/en-US/docs/Web/API/Element/setPointerCapture
-        // setPointerCapture on pointerdownEvent.target to not disable native click events on elements inside of the element pointerListener is bound to
-        (pointerdownEvent.target || this.domElement).setPointerCapture(pointerdownEvent.pointerId);
-        this.pointerManager.addPointer(pointerdownEvent);
-        this.options.pointerdown?.(pointerdownEvent, this);
-        // before starting a new interval, make sure the old one is stopped if present
-        if (this.idleRecognitionIntervalId != null) this.clearIdleRecognitionInterval();
-        this.idleRecognitionIntervalId = setInterval(()=>{
-            this.onIdle();
-        }, 100);
-    }
-    onPointerMove(pointermoveEvent) {
-        // pointermove is also firing if the mouse button is not pressed
-        if (this.pointerManager.hasPointersOnSurface() == true) {
-            // this would disable vertical scrolling - which should only be disabled if a panup/down or swipeup/down listener has been triggered
-            // event.preventDefault();
-            this.pointerManager.onPointerMove(pointermoveEvent);
-            this.recognizeGestures();
-            this.options.pointermove?.(pointermoveEvent, this);
-        }
-    }
-    onPointerUp(pointerupEvent) {
-        if (this.DEBUG == true) console.log("[PointerListener] pointerup event detected");
-        this.domElement.releasePointerCapture(pointerupEvent.pointerId);
-        if (this.pointerManager.hasPointersOnSurface() == true) {
-            this.pointerManager.onPointerUp(pointerupEvent);
-            this.recognizeGestures();
-            this.options.pointerup?.(pointerupEvent, this);
-        }
-        this.clearIdleRecognitionInterval();
-    }
-    /*private onPointerLeave(event: PointerEvent) {
-    if (this.DEBUG == true) {
-      console.log("[PointerListener] pointerleave detected");
-    }
-
-    if (this.pointerManager.hasPointersOnSurface() == true) {
-      this.pointerManager.onPointerLeave(event);
-      this.recognizeGestures();
-    }
-
-    this.clearIdleRecognitionInterval();
-  }
-
-  private onPointerOut(pointeroutEvent: PointerEvent) {
-    if (this.DEBUG == true) {
-      console.log("[PointerListener] pointerout detected");
-    }
-
-    if (this.pointerManager.hasPointersOnSurface() == true) {
-      this.pointerManager.onPointerOut(pointeroutEvent);
-      this.recognizeGestures();
-    }
-
-    this.clearIdleRecognitionInterval();
-  }*/ onPointerCancel(pointercancelEvent) {
-        this.domElement.releasePointerCapture(pointercancelEvent.pointerId);
-        if (this.DEBUG == true) console.log("[PointerListener] pointercancel detected");
-        this.pointerManager.onPointerCancel(pointercancelEvent);
-        this.recognizeGestures();
-        this.clearIdleRecognitionInterval();
-        this.options.pointercancel?.(pointercancelEvent, this);
-    }
-    removePointerEventListeners() {
-        for(const event in this.pointerEventHandlers){
-            const handler = this.pointerEventHandlers[event];
-            this.domElement.removeEventListener(event, handler);
-        }
-    }
-    // provide the ability to interact/prevent touch events
-    // scrolling (touchmove event) results in pointerCancel event, stopping horizontal panning if user scrolls vertically
-    // the better solution is using eg css: touch-action: pan-y;
-    addTouchEventListeners() {
-        if (this.options.handleTouchEvents == true) {
-            const onTouchMove = this.onTouchMove.bind(this);
-            // do NOT make the touchmove listener passive, as this listener might block touch events from
-            // interfering with pan/swipe. Passive listeners make the promise not to block scrolling.
-            this.domElement.addEventListener("touchmove", onTouchMove);
-            this.touchEventHandlers["touchmove"] = onTouchMove;
-        /*this.domElement.addEventListener("touchstart", (event) => {
-
-      }, { passive: true });*/ /*this.domElement.addEventListener("touchend", (event) => {
-      }, { passive: true });
-
-      this.domElement.addEventListener("touchcancel", (event) => {
-      }, { passive: true });*/ }
-    }
-    removeTouchEventListeners() {
-        for(const event in this.touchEventHandlers){
-            const handler = this.touchEventHandlers[event];
-            this.domElement.removeEventListener(event, handler);
-        }
-    }
-    onTouchMove(event) {
-        // fire onTouchMove for all gestures
-        for(let g = 0; g < this.supportedGestures.length; g++){
-            const gesture = this.supportedGestures[g];
-            gesture.onTouchMove(event);
-        }
-    }
-    // to recognize Press, recognition has to be run if the user does nothing while having contact with the surface (no pointermove, no pointerup, no pointercancel)
-    onIdle() {
-        if (this.pointerManager.hasPointersOnSurface() == false) this.clearIdleRecognitionInterval();
-        else {
-            const now = new Date().getTime();
-            let timedelta = null;
-            if (this.lastRecognitionTimestamp != null) timedelta = now - this.lastRecognitionTimestamp;
-            if (timedelta == null || timedelta > 100) {
-                this.pointerManager.onIdle();
-                if (this.DEBUG == true) console.log("[PointerListener] onIdle - running idle recognition");
-                this.recognizeGestures();
-            }
-        }
-    }
-    clearIdleRecognitionInterval() {
-        if (this.idleRecognitionIntervalId != null) {
-            clearInterval(this.idleRecognitionIntervalId);
-            this.idleRecognitionIntervalId = null;
-        }
-    }
-    /**
-   * respect the options "consecutiveGestures" and "simultaneousGestures"
-   */ recognizeGestures() {
-        this.lastRecognitionTimestamp = new Date().getTime();
-        let gesturesForRecognition = this.supportedGestures;
-        if (this.options.simultaneousGestures == false && this.state == (exports.PointerListenerState).ActiveGesture) gesturesForRecognition = [
-            this.activeGestures[0]
-        ];
-        else if (this.options.consecutiveGestures == false && this.state == (exports.PointerListenerState).ActiveGesture) gesturesForRecognition = [
-            this.activeGestures[0]
-        ];
-        else if (this.options.consecutiveGestures == false && this.state == (exports.PointerListenerState).NoActiveGesture) {
-            if (this.hadActiveGestureDuringCurrentContact == true && this.pointerManager.hasPointersOnSurface() == true) gesturesForRecognition = [];
-        }
-        for(let g = 0; g < gesturesForRecognition.length; g++){
-            const gesture = gesturesForRecognition[g];
-            gesture.recognize(this.pointerManager);
-            this.updateActiveGestures(gesture);
-            if (this.options.simultaneousGestures == false && this.state == (exports.PointerListenerState).ActiveGesture) break;
-        }
-        if (this.DEBUG == true) console.log(`[PointerListener] hadActiveGestureDuringCurrentContact: ${this.hadActiveGestureDuringCurrentContact}`);
-        if (this.pointerManager.hasPointersOnSurface() == false) this.hadActiveGestureDuringCurrentContact = false;
-    }
-    updateActiveGestures(gesture) {
-        if (gesture.state == (exports.GestureState).Active) {
-            this.hadActiveGestureDuringCurrentContact = true;
-            if (this.activeGestures.indexOf(gesture) < 0) this.activeGestures.push(gesture);
-        } else {
-            // remove from active gestures
-            const index = this.activeGestures.indexOf(gesture);
-            if (index >= 0) this.activeGestures.splice(index, 1);
-        }
-        if (this.activeGestures.length > 0) this.state = (exports.PointerListenerState).ActiveGesture;
-        else this.state = (exports.PointerListenerState).NoActiveGesture;
-    }
-    /*
-   *	handler management
-   *	eventsString: one or more events: "tap" or "pan twofingerpan pinchend"
-   *	currently, it is not supported to add the same handlerReference twice (once with useCapture = true, and once with useCapture = false)
-   *	useCapture defaults to false
-   */ parseEventsString(eventsString) {
-        return eventsString.trim().split(/\s+/g);
-    }
-    on(eventsString, handlerReference) {
-        const eventTypes = this.parseEventsString(eventsString);
-        for(let e = 0; e < eventTypes.length; e++){
-            const eventType = eventTypes[e];
-            if (!(eventType in this.gestureEventHandlers)) this.gestureEventHandlers[eventType] = [];
-            if (this.gestureEventHandlers[eventType].indexOf(handlerReference) == -1) this.gestureEventHandlers[eventType].push(handlerReference);
-            this.domElement.addEventListener(eventType, handlerReference, {
-                capture: false,
-                passive: true
-            });
-        }
-    }
-    off(eventsString, handlerReference) {
-        const eventTypes = this.parseEventsString(eventsString);
-        if (this.DEBUG == true) {
-            console.log(`[PointerListener] turning off events: ${eventsString}`);
-            console.log(this.gestureEventHandlers);
-        }
-        for(let e = 0; e < eventTypes.length; e++){
-            const eventType = eventTypes[e];
-            if (eventType in this.gestureEventHandlers) {
-                const handlerList = this.gestureEventHandlers[eventType];
-                const index = handlerList.indexOf(handlerReference);
-                if (this.DEBUG == true) console.log(`[PointerListener] turning off ${eventType}. Index on handlerList: ${index}`);
-                if (index >= 0) {
-                    handlerList.splice(index, 1);
-                    this.gestureEventHandlers[eventType] = handlerList;
-                }
-                this.domElement.removeEventListener(eventType, handlerReference, false);
-            }
-        }
-    }
-    destroy() {
-        // remove all EventListeners from this.domElement
-        for(const eventType in this.gestureEventHandlers){
-            const handlerList = this.gestureEventHandlers[eventType];
-            for(let h = 0; h < handlerList.length; h++){
-                const handler = handlerList[h];
-                this.domElement.removeEventListener(eventType, handler);
-            }
-            delete this.gestureEventHandlers[eventType];
-        }
-        this.removePointerEventListeners();
-        this.removeTouchEventListeners();
-    }
-}
-
-exports.Directions = $a2188ba8c266b376$export$86ae6e8ac17a67c6;
-exports.Geometry = $1f7944f1763e45ce$export$2db6c17465f94a2;
-exports.GestureEvent = $f752273e736c5336$export$6e9c3b1e1fa2b597;
-exports.Pan = $7a0f7fd2f33d0212$export$f86166cd6057c2d1;
-exports.Pinch = $ed7931f1d96d5294$export$826ae541ddf1527b;
-exports.PointerListener = $03c52e54621b9b86$export$9371bd96776f4e82;
-exports.Press = $5653a1f5fdc2db30$export$90610caf6d8d0242;
-exports.Rotate = $9fe2bb90b337f66c$export$152db69a76b6b79e;
-exports.Tap = $b6ec4e8a6d9d51ec$export$4451a18ddc7083b7;
-exports.TwoFingerPan = $59226122237c359c$export$8847187e02a498e8;