@inditextech/weave-sdk 0.46.0 → 0.46.1

package/dist/sdk.cjs

@@ -15768,12 +15768,8 @@ function getTargetedNode(instance) {
 	let selectedGroup = void 0;
 	const mousePos = stage.getPointerPosition();
 	if (mousePos) {
-		const allInter = stage.getAllIntersections(mousePos).reverse();
-		if (allInter.length === 1) selectedGroup = instance.getInstanceRecursive(allInter[0]);
-		else {
-			const allInterContainersFiltered = allInter.filter((ele) => typeof ele.getAttrs().containerElement === "undefined");
-			if (allInterContainersFiltered.length > 0) selectedGroup = instance.getInstanceRecursive(allInterContainersFiltered[0]);
-		}
+		const inter = stage.getIntersection(mousePos);
+		if (inter) selectedGroup = instance.getInstanceRecursive(inter);
 	}
 	return selectedGroup;
 }
@@ -16373,11 +16369,11 @@ var WeaveNodesSelectionPlugin = class extends WeavePlugin {
 		stage.on("pointerdown", (e) => {
 			this.setTapStart(e);
 			this.pointers[e.evt.pointerId] = e.evt;
-			if (!this.initialized) return;
-			if (!this.active) return;
+			if (e.evt.pointerType === "touch" && Object.keys(this.pointers).length > 1) return;
 			if (e.evt.pointerType === "mouse" && e.evt.button !== 0) return;
 			if (e.evt.pointerType === "pen" && e.evt.pressure <= .05) return;
-			if (e.evt.pointerType === "touch" && Object.keys(this.pointers).length > 1) return;
+			if (!this.initialized) return;
+			if (!this.active) return;
 			if (stage.mode() !== WEAVE_STAGE_DEFAULT_MODE) return;
 			const selectedGroup = getTargetedNode(this.instance);
 			if (selectedGroup?.getParent() instanceof konva.default.Transformer) {
@@ -16412,9 +16408,9 @@ var WeaveNodesSelectionPlugin = class extends WeavePlugin {
 		const handleMouseMove = (e) => {
 			const moved = this.checkMoved(e);
 			if (e.evt.buttons === 0) return;
+			if (e.evt.pointerType === "touch" && Object.keys(this.pointers).length > 1) return;
 			if (!this.initialized) return;
 			if (!this.active) return;
-			if (e.evt.pointerType === "touch" && Object.keys(this.pointers).length > 1) return;
 			const contextMenuPlugin = this.getContextMenuPlugin();
 			if (moved) contextMenuPlugin?.cancelLongPressTimer();
 			else this.hideSelectorArea();
@@ -18826,7 +18822,7 @@ var WeaveRegisterManager = class {
 
 //#endregion
 //#region package.json
-var version = "0.46.0";
+var version = "0.46.1";
 
 //#endregion
 //#region src/managers/setup.ts
@@ -22021,1672 +22017,6 @@ const WEAVE_STAGE_ZOOM_DEFAULT_CONFIG = {
 	fitToSelection: { padding: 40 }
 };
 
-//#endregion
-//#region ../../node_modules/hammerjs/hammer.js
-var require_hammer = __commonJS({ "../../node_modules/hammerjs/hammer.js"(exports, module) {
-	/*! Hammer.JS - v2.0.7 - 2016-04-22
-	* http://hammerjs.github.io/
-	*
-	* Copyright (c) 2016 Jorik Tangelder;
-	* Licensed under the MIT license */
-	(function(window$1, document$1, exportName, undefined$1) {
-		"use strict";
-		var VENDOR_PREFIXES = [
-			"",
-			"webkit",
-			"Moz",
-			"MS",
-			"ms",
-			"o"
-		];
-		var TEST_ELEMENT = document$1.createElement("div");
-		var TYPE_FUNCTION = "function";
-		var round = Math.round;
-		var abs = Math.abs;
-		var now = Date.now;
-		/**
-		* set a timeout with a given scope
-		* @param {Function} fn
-		* @param {Number} timeout
-		* @param {Object} context
-		* @returns {number}
-		*/
-		function setTimeoutContext(fn, timeout, context) {
-			return setTimeout(bindFn(fn, context), timeout);
-		}
-		/**
-		* if the argument is an array, we want to execute the fn on each entry
-		* if it aint an array we don't want to do a thing.
-		* this is used by all the methods that accept a single and array argument.
-		* @param {*|Array} arg
-		* @param {String} fn
-		* @param {Object} [context]
-		* @returns {Boolean}
-		*/
-		function invokeArrayArg(arg, fn, context) {
-			if (Array.isArray(arg)) {
-				each(arg, context[fn], context);
-				return true;
-			}
-			return false;
-		}
-		/**
-		* walk objects and arrays
-		* @param {Object} obj
-		* @param {Function} iterator
-		* @param {Object} context
-		*/
-		function each(obj, iterator$1, context) {
-			var i;
-			if (!obj) return;
-			if (obj.forEach) obj.forEach(iterator$1, context);
-			else if (obj.length !== undefined$1) {
-				i = 0;
-				while (i < obj.length) {
-					iterator$1.call(context, obj[i], i, obj);
-					i++;
-				}
-			} else for (i in obj) obj.hasOwnProperty(i) && iterator$1.call(context, obj[i], i, obj);
-		}
-		/**
-		* wrap a method with a deprecation warning and stack trace
-		* @param {Function} method
-		* @param {String} name
-		* @param {String} message
-		* @returns {Function} A new function wrapping the supplied method.
-		*/
-		function deprecate(method, name, message) {
-			var deprecationMessage = "DEPRECATED METHOD: " + name + "\n" + message + " AT \n";
-			return function() {
-				var e = new Error("get-stack-trace");
-				var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, "").replace(/^\s+at\s+/gm, "").replace(/^Object.<anonymous>\s*\(/gm, "{anonymous}()@") : "Unknown Stack Trace";
-				var log = window$1.console && (window$1.console.warn || window$1.console.log);
-				if (log) log.call(window$1.console, deprecationMessage, stack);
-				return method.apply(this, arguments);
-			};
-		}
-		/**
-		* extend object.
-		* means that properties in dest will be overwritten by the ones in src.
-		* @param {Object} target
-		* @param {...Object} objects_to_assign
-		* @returns {Object} target
-		*/
-		var assign;
-		if (typeof Object.assign !== "function") assign = function assign$1(target) {
-			if (target === undefined$1 || target === null) throw new TypeError("Cannot convert undefined or null to object");
-			var output = Object(target);
-			for (var index = 1; index < arguments.length; index++) {
-				var source = arguments[index];
-				if (source !== undefined$1 && source !== null) {
-					for (var nextKey in source) if (source.hasOwnProperty(nextKey)) output[nextKey] = source[nextKey];
-				}
-			}
-			return output;
-		};
-		else assign = Object.assign;
-		/**
-		* extend object.
-		* means that properties in dest will be overwritten by the ones in src.
-		* @param {Object} dest
-		* @param {Object} src
-		* @param {Boolean} [merge=false]
-		* @returns {Object} dest
-		*/
-		var extend = deprecate(function extend$1(dest, src, merge$1) {
-			var keys = Object.keys(src);
-			var i = 0;
-			while (i < keys.length) {
-				if (!merge$1 || merge$1 && dest[keys[i]] === undefined$1) dest[keys[i]] = src[keys[i]];
-				i++;
-			}
-			return dest;
-		}, "extend", "Use `assign`.");
-		/**
-		* merge the values from src in the dest.
-		* means that properties that exist in dest will not be overwritten by src
-		* @param {Object} dest
-		* @param {Object} src
-		* @returns {Object} dest
-		*/
-		var merge = deprecate(function merge$1(dest, src) {
-			return extend(dest, src, true);
-		}, "merge", "Use `assign`.");
-		/**
-		* simple class inheritance
-		* @param {Function} child
-		* @param {Function} base
-		* @param {Object} [properties]
-		*/
-		function inherit(child, base, properties) {
-			var baseP = base.prototype, childP;
-			childP = child.prototype = Object.create(baseP);
-			childP.constructor = child;
-			childP._super = baseP;
-			if (properties) assign(childP, properties);
-		}
-		/**
-		* simple function bind
-		* @param {Function} fn
-		* @param {Object} context
-		* @returns {Function}
-		*/
-		function bindFn(fn, context) {
-			return function boundFn() {
-				return fn.apply(context, arguments);
-			};
-		}
-		/**
-		* let a boolean value also be a function that must return a boolean
-		* this first item in args will be used as the context
-		* @param {Boolean|Function} val
-		* @param {Array} [args]
-		* @returns {Boolean}
-		*/
-		function boolOrFn(val, args) {
-			if (typeof val == TYPE_FUNCTION) return val.apply(args ? args[0] || undefined$1 : undefined$1, args);
-			return val;
-		}
-		/**
-		* use the val2 when val1 is undefined
-		* @param {*} val1
-		* @param {*} val2
-		* @returns {*}
-		*/
-		function ifUndefined(val1, val2) {
-			return val1 === undefined$1 ? val2 : val1;
-		}
-		/**
-		* addEventListener with multiple events at once
-		* @param {EventTarget} target
-		* @param {String} types
-		* @param {Function} handler
-		*/
-		function addEventListeners(target, types, handler) {
-			each(splitStr(types), function(type) {
-				target.addEventListener(type, handler, false);
-			});
-		}
-		/**
-		* removeEventListener with multiple events at once
-		* @param {EventTarget} target
-		* @param {String} types
-		* @param {Function} handler
-		*/
-		function removeEventListeners(target, types, handler) {
-			each(splitStr(types), function(type) {
-				target.removeEventListener(type, handler, false);
-			});
-		}
-		/**
-		* find if a node is in the given parent
-		* @method hasParent
-		* @param {HTMLElement} node
-		* @param {HTMLElement} parent
-		* @return {Boolean} found
-		*/
-		function hasParent(node, parent) {
-			while (node) {
-				if (node == parent) return true;
-				node = node.parentNode;
-			}
-			return false;
-		}
-		/**
-		* small indexOf wrapper
-		* @param {String} str
-		* @param {String} find
-		* @returns {Boolean} found
-		*/
-		function inStr(str, find) {
-			return str.indexOf(find) > -1;
-		}
-		/**
-		* split string on whitespace
-		* @param {String} str
-		* @returns {Array} words
-		*/
-		function splitStr(str) {
-			return str.trim().split(/\s+/g);
-		}
-		/**
-		* find if a array contains the object using indexOf or a simple polyFill
-		* @param {Array} src
-		* @param {String} find
-		* @param {String} [findByKey]
-		* @return {Boolean|Number} false when not found, or the index
-		*/
-		function inArray(src, find, findByKey) {
-			if (src.indexOf && !findByKey) return src.indexOf(find);
-			else {
-				var i = 0;
-				while (i < src.length) {
-					if (findByKey && src[i][findByKey] == find || !findByKey && src[i] === find) return i;
-					i++;
-				}
-				return -1;
-			}
-		}
-		/**
-		* convert array-like objects to real arrays
-		* @param {Object} obj
-		* @returns {Array}
-		*/
-		function toArray(obj) {
-			return Array.prototype.slice.call(obj, 0);
-		}
-		/**
-		* unique array with objects based on a key (like 'id') or just by the array's value
-		* @param {Array} src [{id:1},{id:2},{id:1}]
-		* @param {String} [key]
-		* @param {Boolean} [sort=False]
-		* @returns {Array} [{id:1},{id:2}]
-		*/
-		function uniqueArray(src, key, sort) {
-			var results = [];
-			var values = [];
-			var i = 0;
-			while (i < src.length) {
-				var val = key ? src[i][key] : src[i];
-				if (inArray(values, val) < 0) results.push(src[i]);
-				values[i] = val;
-				i++;
-			}
-			if (sort) if (!key) results = results.sort();
-			else results = results.sort(function sortUniqueArray(a, b) {
-				return a[key] > b[key];
-			});
-			return results;
-		}
-		/**
-		* get the prefixed property
-		* @param {Object} obj
-		* @param {String} property
-		* @returns {String|Undefined} prefixed
-		*/
-		function prefixed(obj, property) {
-			var prefix, prop;
-			var camelProp = property[0].toUpperCase() + property.slice(1);
-			var i = 0;
-			while (i < VENDOR_PREFIXES.length) {
-				prefix = VENDOR_PREFIXES[i];
-				prop = prefix ? prefix + camelProp : property;
-				if (prop in obj) return prop;
-				i++;
-			}
-			return undefined$1;
-		}
-		/**
-		* get a unique id
-		* @returns {number} uniqueId
-		*/
-		var _uniqueId = 1;
-		function uniqueId() {
-			return _uniqueId++;
-		}
-		/**
-		* get the window object of an element
-		* @param {HTMLElement} element
-		* @returns {DocumentView|Window}
-		*/
-		function getWindowForElement(element) {
-			var doc = element.ownerDocument || element;
-			return doc.defaultView || doc.parentWindow || window$1;
-		}
-		var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
-		var SUPPORT_TOUCH = "ontouchstart" in window$1;
-		var SUPPORT_POINTER_EVENTS = prefixed(window$1, "PointerEvent") !== undefined$1;
-		var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
-		var INPUT_TYPE_TOUCH = "touch";
-		var INPUT_TYPE_PEN = "pen";
-		var INPUT_TYPE_MOUSE = "mouse";
-		var INPUT_TYPE_KINECT = "kinect";
-		var COMPUTE_INTERVAL = 25;
-		var INPUT_START = 1;
-		var INPUT_MOVE = 2;
-		var INPUT_END = 4;
-		var INPUT_CANCEL = 8;
-		var DIRECTION_NONE = 1;
-		var DIRECTION_LEFT = 2;
-		var DIRECTION_RIGHT = 4;
-		var DIRECTION_UP = 8;
-		var DIRECTION_DOWN = 16;
-		var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
-		var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
-		var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
-		var PROPS_XY = ["x", "y"];
-		var PROPS_CLIENT_XY = ["clientX", "clientY"];
-		/**
-		* create new input type manager
-		* @param {Manager} manager
-		* @param {Function} callback
-		* @returns {Input}
-		* @constructor
-		*/
-		function Input(manager, callback) {
-			var self$1 = this;
-			this.manager = manager;
-			this.callback = callback;
-			this.element = manager.element;
-			this.target = manager.options.inputTarget;
-			this.domHandler = function(ev) {
-				if (boolOrFn(manager.options.enable, [manager])) self$1.handler(ev);
-			};
-			this.init();
-		}
-		Input.prototype = {
-			handler: function() {},
-			init: function() {
-				this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
-				this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
-				this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
-			},
-			destroy: function() {
-				this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
-				this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
-				this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
-			}
-		};
-		/**
-		* create new input type manager
-		* called by the Manager constructor
-		* @param {Hammer} manager
-		* @returns {Input}
-		*/
-		function createInputInstance(manager) {
-			var Type;
-			var inputClass = manager.options.inputClass;
-			if (inputClass) Type = inputClass;
-			else if (SUPPORT_POINTER_EVENTS) Type = PointerEventInput;
-			else if (SUPPORT_ONLY_TOUCH) Type = TouchInput;
-			else if (!SUPPORT_TOUCH) Type = MouseInput;
-			else Type = TouchMouseInput;
-			return new Type(manager, inputHandler);
-		}
-		/**
-		* handle input events
-		* @param {Manager} manager
-		* @param {String} eventType
-		* @param {Object} input
-		*/
-		function inputHandler(manager, eventType, input) {
-			var pointersLen = input.pointers.length;
-			var changedPointersLen = input.changedPointers.length;
-			var isFirst = eventType & INPUT_START && pointersLen - changedPointersLen === 0;
-			var isFinal = eventType & (INPUT_END | INPUT_CANCEL) && pointersLen - changedPointersLen === 0;
-			input.isFirst = !!isFirst;
-			input.isFinal = !!isFinal;
-			if (isFirst) manager.session = {};
-			input.eventType = eventType;
-			computeInputData(manager, input);
-			manager.emit("hammer.input", input);
-			manager.recognize(input);
-			manager.session.prevInput = input;
-		}
-		/**
-		* extend the data with some usable properties like scale, rotate, velocity etc
-		* @param {Object} manager
-		* @param {Object} input
-		*/
-		function computeInputData(manager, input) {
-			var session = manager.session;
-			var pointers = input.pointers;
-			var pointersLength = pointers.length;
-			if (!session.firstInput) session.firstInput = simpleCloneInputData(input);
-			if (pointersLength > 1 && !session.firstMultiple) session.firstMultiple = simpleCloneInputData(input);
-			else if (pointersLength === 1) session.firstMultiple = false;
-			var firstInput = session.firstInput;
-			var firstMultiple = session.firstMultiple;
-			var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
-			var center = input.center = getCenter(pointers);
-			input.timeStamp = now();
-			input.deltaTime = input.timeStamp - firstInput.timeStamp;
-			input.angle = getAngle(offsetCenter, center);
-			input.distance = getDistance(offsetCenter, center);
-			computeDeltaXY(session, input);
-			input.offsetDirection = getDirection(input.deltaX, input.deltaY);
-			var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
-			input.overallVelocityX = overallVelocity.x;
-			input.overallVelocityY = overallVelocity.y;
-			input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y;
-			input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
-			input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
-			input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;
-			computeIntervalInputData(session, input);
-			var target = manager.element;
-			if (hasParent(input.srcEvent.target, target)) target = input.srcEvent.target;
-			input.target = target;
-		}
-		function computeDeltaXY(session, input) {
-			var center = input.center;
-			var offset = session.offsetDelta || {};
-			var prevDelta = session.prevDelta || {};
-			var prevInput = session.prevInput || {};
-			if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
-				prevDelta = session.prevDelta = {
-					x: prevInput.deltaX || 0,
-					y: prevInput.deltaY || 0
-				};
-				offset = session.offsetDelta = {
-					x: center.x,
-					y: center.y
-				};
-			}
-			input.deltaX = prevDelta.x + (center.x - offset.x);
-			input.deltaY = prevDelta.y + (center.y - offset.y);
-		}
-		/**
-		* velocity is calculated every x ms
-		* @param {Object} session
-		* @param {Object} input
-		*/
-		function computeIntervalInputData(session, input) {
-			var last = session.lastInterval || input, deltaTime = input.timeStamp - last.timeStamp, velocity, velocityX, velocityY, direction;
-			if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined$1)) {
-				var deltaX = input.deltaX - last.deltaX;
-				var deltaY = input.deltaY - last.deltaY;
-				var v = getVelocity(deltaTime, deltaX, deltaY);
-				velocityX = v.x;
-				velocityY = v.y;
-				velocity = abs(v.x) > abs(v.y) ? v.x : v.y;
-				direction = getDirection(deltaX, deltaY);
-				session.lastInterval = input;
-			} else {
-				velocity = last.velocity;
-				velocityX = last.velocityX;
-				velocityY = last.velocityY;
-				direction = last.direction;
-			}
-			input.velocity = velocity;
-			input.velocityX = velocityX;
-			input.velocityY = velocityY;
-			input.direction = direction;
-		}
-		/**
-		* create a simple clone from the input used for storage of firstInput and firstMultiple
-		* @param {Object} input
-		* @returns {Object} clonedInputData
-		*/
-		function simpleCloneInputData(input) {
-			var pointers = [];
-			var i = 0;
-			while (i < input.pointers.length) {
-				pointers[i] = {
-					clientX: round(input.pointers[i].clientX),
-					clientY: round(input.pointers[i].clientY)
-				};
-				i++;
-			}
-			return {
-				timeStamp: now(),
-				pointers,
-				center: getCenter(pointers),
-				deltaX: input.deltaX,
-				deltaY: input.deltaY
-			};
-		}
-		/**
-		* get the center of all the pointers
-		* @param {Array} pointers
-		* @return {Object} center contains `x` and `y` properties
-		*/
-		function getCenter(pointers) {
-			var pointersLength = pointers.length;
-			if (pointersLength === 1) return {
-				x: round(pointers[0].clientX),
-				y: round(pointers[0].clientY)
-			};
-			var x = 0, y = 0, i = 0;
-			while (i < pointersLength) {
-				x += pointers[i].clientX;
-				y += pointers[i].clientY;
-				i++;
-			}
-			return {
-				x: round(x / pointersLength),
-				y: round(y / pointersLength)
-			};
-		}
-		/**
-		* calculate the velocity between two points. unit is in px per ms.
-		* @param {Number} deltaTime
-		* @param {Number} x
-		* @param {Number} y
-		* @return {Object} velocity `x` and `y`
-		*/
-		function getVelocity(deltaTime, x, y) {
-			return {
-				x: x / deltaTime || 0,
-				y: y / deltaTime || 0
-			};
-		}
-		/**
-		* get the direction between two points
-		* @param {Number} x
-		* @param {Number} y
-		* @return {Number} direction
-		*/
-		function getDirection(x, y) {
-			if (x === y) return DIRECTION_NONE;
-			if (abs(x) >= abs(y)) return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
-			return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
-		}
-		/**
-		* calculate the absolute distance between two points
-		* @param {Object} p1 {x, y}
-		* @param {Object} p2 {x, y}
-		* @param {Array} [props] containing x and y keys
-		* @return {Number} distance
-		*/
-		function getDistance(p1, p2, props) {
-			if (!props) props = PROPS_XY;
-			var x = p2[props[0]] - p1[props[0]], y = p2[props[1]] - p1[props[1]];
-			return Math.sqrt(x * x + y * y);
-		}
-		/**
-		* calculate the angle between two coordinates
-		* @param {Object} p1
-		* @param {Object} p2
-		* @param {Array} [props] containing x and y keys
-		* @return {Number} angle
-		*/
-		function getAngle(p1, p2, props) {
-			if (!props) props = PROPS_XY;
-			var x = p2[props[0]] - p1[props[0]], y = p2[props[1]] - p1[props[1]];
-			return Math.atan2(y, x) * 180 / Math.PI;
-		}
-		/**
-		* calculate the rotation degrees between two pointersets
-		* @param {Array} start array of pointers
-		* @param {Array} end array of pointers
-		* @return {Number} rotation
-		*/
-		function getRotation(start, end) {
-			return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
-		}
-		/**
-		* calculate the scale factor between two pointersets
-		* no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
-		* @param {Array} start array of pointers
-		* @param {Array} end array of pointers
-		* @return {Number} scale
-		*/
-		function getScale(start, end) {
-			return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
-		}
-		var MOUSE_INPUT_MAP = {
-			mousedown: INPUT_START,
-			mousemove: INPUT_MOVE,
-			mouseup: INPUT_END
-		};
-		var MOUSE_ELEMENT_EVENTS = "mousedown";
-		var MOUSE_WINDOW_EVENTS = "mousemove mouseup";
-		/**
-		* Mouse events input
-		* @constructor
-		* @extends Input
-		*/
-		function MouseInput() {
-			this.evEl = MOUSE_ELEMENT_EVENTS;
-			this.evWin = MOUSE_WINDOW_EVENTS;
-			this.pressed = false;
-			Input.apply(this, arguments);
-		}
-		inherit(MouseInput, Input, { handler: function MEhandler(ev) {
-			var eventType = MOUSE_INPUT_MAP[ev.type];
-			if (eventType & INPUT_START && ev.button === 0) this.pressed = true;
-			if (eventType & INPUT_MOVE && ev.which !== 1) eventType = INPUT_END;
-			if (!this.pressed) return;
-			if (eventType & INPUT_END) this.pressed = false;
-			this.callback(this.manager, eventType, {
-				pointers: [ev],
-				changedPointers: [ev],
-				pointerType: INPUT_TYPE_MOUSE,
-				srcEvent: ev
-			});
-		} });
-		var POINTER_INPUT_MAP = {
-			pointerdown: INPUT_START,
-			pointermove: INPUT_MOVE,
-			pointerup: INPUT_END,
-			pointercancel: INPUT_CANCEL,
-			pointerout: INPUT_CANCEL
-		};
-		var IE10_POINTER_TYPE_ENUM = {
-			2: INPUT_TYPE_TOUCH,
-			3: INPUT_TYPE_PEN,
-			4: INPUT_TYPE_MOUSE,
-			5: INPUT_TYPE_KINECT
-		};
-		var POINTER_ELEMENT_EVENTS = "pointerdown";
-		var POINTER_WINDOW_EVENTS = "pointermove pointerup pointercancel";
-		if (window$1.MSPointerEvent && !window$1.PointerEvent) {
-			POINTER_ELEMENT_EVENTS = "MSPointerDown";
-			POINTER_WINDOW_EVENTS = "MSPointerMove MSPointerUp MSPointerCancel";
-		}
-		/**
-		* Pointer events input
-		* @constructor
-		* @extends Input
-		*/
-		function PointerEventInput() {
-			this.evEl = POINTER_ELEMENT_EVENTS;
-			this.evWin = POINTER_WINDOW_EVENTS;
-			Input.apply(this, arguments);
-			this.store = this.manager.session.pointerEvents = [];
-		}
-		inherit(PointerEventInput, Input, { handler: function PEhandler(ev) {
-			var store = this.store;
-			var removePointer = false;
-			var eventTypeNormalized = ev.type.toLowerCase().replace("ms", "");
-			var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
-			var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
-			var isTouch = pointerType == INPUT_TYPE_TOUCH;
-			var storeIndex = inArray(store, ev.pointerId, "pointerId");
-			if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
-				if (storeIndex < 0) {
-					store.push(ev);
-					storeIndex = store.length - 1;
-				}
-			} else if (eventType & (INPUT_END | INPUT_CANCEL)) removePointer = true;
-			if (storeIndex < 0) return;
-			store[storeIndex] = ev;
-			this.callback(this.manager, eventType, {
-				pointers: store,
-				changedPointers: [ev],
-				pointerType,
-				srcEvent: ev
-			});
-			if (removePointer) store.splice(storeIndex, 1);
-		} });
-		var SINGLE_TOUCH_INPUT_MAP = {
-			touchstart: INPUT_START,
-			touchmove: INPUT_MOVE,
-			touchend: INPUT_END,
-			touchcancel: INPUT_CANCEL
-		};
-		var SINGLE_TOUCH_TARGET_EVENTS = "touchstart";
-		var SINGLE_TOUCH_WINDOW_EVENTS = "touchstart touchmove touchend touchcancel";
-		/**
-		* Touch events input
-		* @constructor
-		* @extends Input
-		*/
-		function SingleTouchInput() {
-			this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
-			this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
-			this.started = false;
-			Input.apply(this, arguments);
-		}
-		inherit(SingleTouchInput, Input, { handler: function TEhandler(ev) {
-			var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
-			if (type === INPUT_START) this.started = true;
-			if (!this.started) return;
-			var touches = normalizeSingleTouches.call(this, ev, type);
-			if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) this.started = false;
-			this.callback(this.manager, type, {
-				pointers: touches[0],
-				changedPointers: touches[1],
-				pointerType: INPUT_TYPE_TOUCH,
-				srcEvent: ev
-			});
-		} });
-		/**
-		* @this {TouchInput}
-		* @param {Object} ev
-		* @param {Number} type flag
-		* @returns {undefined|Array} [all, changed]
-		*/
-		function normalizeSingleTouches(ev, type) {
-			var all = toArray(ev.touches);
-			var changed = toArray(ev.changedTouches);
-			if (type & (INPUT_END | INPUT_CANCEL)) all = uniqueArray(all.concat(changed), "identifier", true);
-			return [all, changed];
-		}
-		var TOUCH_INPUT_MAP = {
-			touchstart: INPUT_START,
-			touchmove: INPUT_MOVE,
-			touchend: INPUT_END,
-			touchcancel: INPUT_CANCEL
-		};
-		var TOUCH_TARGET_EVENTS = "touchstart touchmove touchend touchcancel";
-		/**
-		* Multi-user touch events input
-		* @constructor
-		* @extends Input
-		*/
-		function TouchInput() {
-			this.evTarget = TOUCH_TARGET_EVENTS;
-			this.targetIds = {};
-			Input.apply(this, arguments);
-		}
-		inherit(TouchInput, Input, { handler: function MTEhandler(ev) {
-			var type = TOUCH_INPUT_MAP[ev.type];
-			var touches = getTouches.call(this, ev, type);
-			if (!touches) return;
-			this.callback(this.manager, type, {
-				pointers: touches[0],
-				changedPointers: touches[1],
-				pointerType: INPUT_TYPE_TOUCH,
-				srcEvent: ev
-			});
-		} });
-		/**
-		* @this {TouchInput}
-		* @param {Object} ev
-		* @param {Number} type flag
-		* @returns {undefined|Array} [all, changed]
-		*/
-		function getTouches(ev, type) {
-			var allTouches = toArray(ev.touches);
-			var targetIds = this.targetIds;
-			if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
-				targetIds[allTouches[0].identifier] = true;
-				return [allTouches, allTouches];
-			}
-			var i, targetTouches, changedTouches = toArray(ev.changedTouches), changedTargetTouches = [], target = this.target;
-			targetTouches = allTouches.filter(function(touch) {
-				return hasParent(touch.target, target);
-			});
-			if (type === INPUT_START) {
-				i = 0;
-				while (i < targetTouches.length) {
-					targetIds[targetTouches[i].identifier] = true;
-					i++;
-				}
-			}
-			i = 0;
-			while (i < changedTouches.length) {
-				if (targetIds[changedTouches[i].identifier]) changedTargetTouches.push(changedTouches[i]);
-				if (type & (INPUT_END | INPUT_CANCEL)) delete targetIds[changedTouches[i].identifier];
-				i++;
-			}
-			if (!changedTargetTouches.length) return;
-			return [uniqueArray(targetTouches.concat(changedTargetTouches), "identifier", true), changedTargetTouches];
-		}
-		/**
-		* Combined touch and mouse input
-		*
-		* Touch has a higher priority then mouse, and while touching no mouse events are allowed.
-		* This because touch devices also emit mouse events while doing a touch.
-		*
-		* @constructor
-		* @extends Input
-		*/
-		var DEDUP_TIMEOUT = 2500;
-		var DEDUP_DISTANCE = 25;
-		function TouchMouseInput() {
-			Input.apply(this, arguments);
-			var handler = bindFn(this.handler, this);
-			this.touch = new TouchInput(this.manager, handler);
-			this.mouse = new MouseInput(this.manager, handler);
-			this.primaryTouch = null;
-			this.lastTouches = [];
-		}
-		inherit(TouchMouseInput, Input, {
-			handler: function TMEhandler(manager, inputEvent, inputData) {
-				var isTouch = inputData.pointerType == INPUT_TYPE_TOUCH, isMouse = inputData.pointerType == INPUT_TYPE_MOUSE;
-				if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) return;
-				if (isTouch) recordTouches.call(this, inputEvent, inputData);
-				else if (isMouse && isSyntheticEvent.call(this, inputData)) return;
-				this.callback(manager, inputEvent, inputData);
-			},
-			destroy: function destroy() {
-				this.touch.destroy();
-				this.mouse.destroy();
-			}
-		});
-		function recordTouches(eventType, eventData) {
-			if (eventType & INPUT_START) {
-				this.primaryTouch = eventData.changedPointers[0].identifier;
-				setLastTouch.call(this, eventData);
-			} else if (eventType & (INPUT_END | INPUT_CANCEL)) setLastTouch.call(this, eventData);
-		}
-		function setLastTouch(eventData) {
-			var touch = eventData.changedPointers[0];
-			if (touch.identifier === this.primaryTouch) {
-				var lastTouch = {
-					x: touch.clientX,
-					y: touch.clientY
-				};
-				this.lastTouches.push(lastTouch);
-				var lts = this.lastTouches;
-				var removeLastTouch = function() {
-					var i = lts.indexOf(lastTouch);
-					if (i > -1) lts.splice(i, 1);
-				};
-				setTimeout(removeLastTouch, DEDUP_TIMEOUT);
-			}
-		}
-		function isSyntheticEvent(eventData) {
-			var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;
-			for (var i = 0; i < this.lastTouches.length; i++) {
-				var t = this.lastTouches[i];
-				var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);
-				if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) return true;
-			}
-			return false;
-		}
-		var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, "touchAction");
-		var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined$1;
-		var TOUCH_ACTION_COMPUTE = "compute";
-		var TOUCH_ACTION_AUTO = "auto";
-		var TOUCH_ACTION_MANIPULATION = "manipulation";
-		var TOUCH_ACTION_NONE = "none";
-		var TOUCH_ACTION_PAN_X = "pan-x";
-		var TOUCH_ACTION_PAN_Y = "pan-y";
-		var TOUCH_ACTION_MAP = getTouchActionProps();
-		/**
-		* Touch Action
-		* sets the touchAction property or uses the js alternative
-		* @param {Manager} manager
-		* @param {String} value
-		* @constructor
-		*/
-		function TouchAction(manager, value) {
-			this.manager = manager;
-			this.set(value);
-		}
-		TouchAction.prototype = {
-			set: function(value) {
-				if (value == TOUCH_ACTION_COMPUTE) value = this.compute();
-				if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
-				this.actions = value.toLowerCase().trim();
-			},
-			update: function() {
-				this.set(this.manager.options.touchAction);
-			},
-			compute: function() {
-				var actions = [];
-				each(this.manager.recognizers, function(recognizer) {
-					if (boolOrFn(recognizer.options.enable, [recognizer])) actions = actions.concat(recognizer.getTouchAction());
-				});
-				return cleanTouchActions(actions.join(" "));
-			},
-			preventDefaults: function(input) {
-				var srcEvent = input.srcEvent;
-				var direction = input.offsetDirection;
-				if (this.manager.session.prevented) {
-					srcEvent.preventDefault();
-					return;
-				}
-				var actions = this.actions;
-				var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
-				var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
-				var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
-				if (hasNone) {
-					var isTapPointer = input.pointers.length === 1;
-					var isTapMovement = input.distance < 2;
-					var isTapTouchTime = input.deltaTime < 250;
-					if (isTapPointer && isTapMovement && isTapTouchTime) return;
-				}
-				if (hasPanX && hasPanY) return;
-				if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) return this.preventSrc(srcEvent);
-			},
-			preventSrc: function(srcEvent) {
-				this.manager.session.prevented = true;
-				srcEvent.preventDefault();
-			}
-		};
-		/**
-		* when the touchActions are collected they are not a valid value, so we need to clean things up. *
-		* @param {String} actions
-		* @returns {*}
-		*/
-		function cleanTouchActions(actions) {
-			if (inStr(actions, TOUCH_ACTION_NONE)) return TOUCH_ACTION_NONE;
-			var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
-			var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
-			if (hasPanX && hasPanY) return TOUCH_ACTION_NONE;
-			if (hasPanX || hasPanY) return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
-			if (inStr(actions, TOUCH_ACTION_MANIPULATION)) return TOUCH_ACTION_MANIPULATION;
-			return TOUCH_ACTION_AUTO;
-		}
-		function getTouchActionProps() {
-			if (!NATIVE_TOUCH_ACTION) return false;
-			var touchMap = {};
-			var cssSupports = window$1.CSS && window$1.CSS.supports;
-			[
-				"auto",
-				"manipulation",
-				"pan-y",
-				"pan-x",
-				"pan-x pan-y",
-				"none"
-			].forEach(function(val) {
-				touchMap[val] = cssSupports ? window$1.CSS.supports("touch-action", val) : true;
-			});
-			return touchMap;
-		}
-		/**
-		* Recognizer flow explained; *
-		* All recognizers have the initial state of POSSIBLE when a input session starts.
-		* The definition of a input session is from the first input until the last input, with all it's movement in it. *
-		* Example session for mouse-input: mousedown -> mousemove -> mouseup
-		*
-		* On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
-		* which determines with state it should be.
-		*
-		* If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
-		* POSSIBLE to give it another change on the next cycle.
-		*
-		*               Possible
-		*                  |
-		*            +-----+---------------+
-		*            |                     |
-		*      +-----+-----+               |
-		*      |           |               |
-		*   Failed      Cancelled          |
-		*                          +-------+------+
-		*                          |              |
-		*                      Recognized       Began
-		*                                         |
-		*                                      Changed
-		*                                         |
-		*                                  Ended/Recognized
-		*/
-		var STATE_POSSIBLE = 1;
-		var STATE_BEGAN = 2;
-		var STATE_CHANGED = 4;
-		var STATE_ENDED = 8;
-		var STATE_RECOGNIZED = STATE_ENDED;
-		var STATE_CANCELLED = 16;
-		var STATE_FAILED = 32;
-		/**
-		* Recognizer
-		* Every recognizer needs to extend from this class.
-		* @constructor
-		* @param {Object} options
-		*/
-		function Recognizer(options) {
-			this.options = assign({}, this.defaults, options || {});
-			this.id = uniqueId();
-			this.manager = null;
-			this.options.enable = ifUndefined(this.options.enable, true);
-			this.state = STATE_POSSIBLE;
-			this.simultaneous = {};
-			this.requireFail = [];
-		}
-		Recognizer.prototype = {
-			defaults: {},
-			set: function(options) {
-				assign(this.options, options);
-				this.manager && this.manager.touchAction.update();
-				return this;
-			},
-			recognizeWith: function(otherRecognizer) {
-				if (invokeArrayArg(otherRecognizer, "recognizeWith", this)) return this;
-				var simultaneous = this.simultaneous;
-				otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-				if (!simultaneous[otherRecognizer.id]) {
-					simultaneous[otherRecognizer.id] = otherRecognizer;
-					otherRecognizer.recognizeWith(this);
-				}
-				return this;
-			},
-			dropRecognizeWith: function(otherRecognizer) {
-				if (invokeArrayArg(otherRecognizer, "dropRecognizeWith", this)) return this;
-				otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-				delete this.simultaneous[otherRecognizer.id];
-				return this;
-			},
-			requireFailure: function(otherRecognizer) {
-				if (invokeArrayArg(otherRecognizer, "requireFailure", this)) return this;
-				var requireFail = this.requireFail;
-				otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-				if (inArray(requireFail, otherRecognizer) === -1) {
-					requireFail.push(otherRecognizer);
-					otherRecognizer.requireFailure(this);
-				}
-				return this;
-			},
-			dropRequireFailure: function(otherRecognizer) {
-				if (invokeArrayArg(otherRecognizer, "dropRequireFailure", this)) return this;
-				otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-				var index = inArray(this.requireFail, otherRecognizer);
-				if (index > -1) this.requireFail.splice(index, 1);
-				return this;
-			},
-			hasRequireFailures: function() {
-				return this.requireFail.length > 0;
-			},
-			canRecognizeWith: function(otherRecognizer) {
-				return !!this.simultaneous[otherRecognizer.id];
-			},
-			emit: function(input) {
-				var self$1 = this;
-				var state = this.state;
-				function emit(event) {
-					self$1.manager.emit(event, input);
-				}
-				if (state < STATE_ENDED) emit(self$1.options.event + stateStr(state));
-				emit(self$1.options.event);
-				if (input.additionalEvent) emit(input.additionalEvent);
-				if (state >= STATE_ENDED) emit(self$1.options.event + stateStr(state));
-			},
-			tryEmit: function(input) {
-				if (this.canEmit()) return this.emit(input);
-				this.state = STATE_FAILED;
-			},
-			canEmit: function() {
-				var i = 0;
-				while (i < this.requireFail.length) {
-					if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) return false;
-					i++;
-				}
-				return true;
-			},
-			recognize: function(inputData) {
-				var inputDataClone = assign({}, inputData);
-				if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
-					this.reset();
-					this.state = STATE_FAILED;
-					return;
-				}
-				if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) this.state = STATE_POSSIBLE;
-				this.state = this.process(inputDataClone);
-				if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) this.tryEmit(inputDataClone);
-			},
-			process: function(inputData) {},
-			getTouchAction: function() {},
-			reset: function() {}
-		};
-		/**
-		* get a usable string, used as event postfix
-		* @param {Const} state
-		* @returns {String} state
-		*/
-		function stateStr(state) {
-			if (state & STATE_CANCELLED) return "cancel";
-			else if (state & STATE_ENDED) return "end";
-			else if (state & STATE_CHANGED) return "move";
-			else if (state & STATE_BEGAN) return "start";
-			return "";
-		}
-		/**
-		* direction cons to string
-		* @param {Const} direction
-		* @returns {String}
-		*/
-		function directionStr(direction) {
-			if (direction == DIRECTION_DOWN) return "down";
-			else if (direction == DIRECTION_UP) return "up";
-			else if (direction == DIRECTION_LEFT) return "left";
-			else if (direction == DIRECTION_RIGHT) return "right";
-			return "";
-		}
-		/**
-		* get a recognizer by name if it is bound to a manager
-		* @param {Recognizer|String} otherRecognizer
-		* @param {Recognizer} recognizer
-		* @returns {Recognizer}
-		*/
-		function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
-			var manager = recognizer.manager;
-			if (manager) return manager.get(otherRecognizer);
-			return otherRecognizer;
-		}
-		/**
-		* This recognizer is just used as a base for the simple attribute recognizers.
-		* @constructor
-		* @extends Recognizer
-		*/
-		function AttrRecognizer() {
-			Recognizer.apply(this, arguments);
-		}
-		inherit(AttrRecognizer, Recognizer, {
-			defaults: { pointers: 1 },
-			attrTest: function(input) {
-				var optionPointers = this.options.pointers;
-				return optionPointers === 0 || input.pointers.length === optionPointers;
-			},
-			process: function(input) {
-				var state = this.state;
-				var eventType = input.eventType;
-				var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
-				var isValid = this.attrTest(input);
-				if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) return state | STATE_CANCELLED;
-				else if (isRecognized || isValid) {
-					if (eventType & INPUT_END) return state | STATE_ENDED;
-					else if (!(state & STATE_BEGAN)) return STATE_BEGAN;
-					return state | STATE_CHANGED;
-				}
-				return STATE_FAILED;
-			}
-		});
-		/**
-		* Pan
-		* Recognized when the pointer is down and moved in the allowed direction.
-		* @constructor
-		* @extends AttrRecognizer
-		*/
-		function PanRecognizer() {
-			AttrRecognizer.apply(this, arguments);
-			this.pX = null;
-			this.pY = null;
-		}
-		inherit(PanRecognizer, AttrRecognizer, {
-			defaults: {
-				event: "pan",
-				threshold: 10,
-				pointers: 1,
-				direction: DIRECTION_ALL
-			},
-			getTouchAction: function() {
-				var direction = this.options.direction;
-				var actions = [];
-				if (direction & DIRECTION_HORIZONTAL) actions.push(TOUCH_ACTION_PAN_Y);
-				if (direction & DIRECTION_VERTICAL) actions.push(TOUCH_ACTION_PAN_X);
-				return actions;
-			},
-			directionTest: function(input) {
-				var options = this.options;
-				var hasMoved = true;
-				var distance = input.distance;
-				var direction = input.direction;
-				var x = input.deltaX;
-				var y = input.deltaY;
-				if (!(direction & options.direction)) if (options.direction & DIRECTION_HORIZONTAL) {
-					direction = x === 0 ? DIRECTION_NONE : x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
-					hasMoved = x != this.pX;
-					distance = Math.abs(input.deltaX);
-				} else {
-					direction = y === 0 ? DIRECTION_NONE : y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
-					hasMoved = y != this.pY;
-					distance = Math.abs(input.deltaY);
-				}
-				input.direction = direction;
-				return hasMoved && distance > options.threshold && direction & options.direction;
-			},
-			attrTest: function(input) {
-				return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));
-			},
-			emit: function(input) {
-				this.pX = input.deltaX;
-				this.pY = input.deltaY;
-				var direction = directionStr(input.direction);
-				if (direction) input.additionalEvent = this.options.event + direction;
-				this._super.emit.call(this, input);
-			}
-		});
-		/**
-		* Pinch
-		* Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
-		* @constructor
-		* @extends AttrRecognizer
-		*/
-		function PinchRecognizer() {
-			AttrRecognizer.apply(this, arguments);
-		}
-		inherit(PinchRecognizer, AttrRecognizer, {
-			defaults: {
-				event: "pinch",
-				threshold: 0,
-				pointers: 2
-			},
-			getTouchAction: function() {
-				return [TOUCH_ACTION_NONE];
-			},
-			attrTest: function(input) {
-				return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
-			},
-			emit: function(input) {
-				if (input.scale !== 1) {
-					var inOut = input.scale < 1 ? "in" : "out";
-					input.additionalEvent = this.options.event + inOut;
-				}
-				this._super.emit.call(this, input);
-			}
-		});
-		/**
-		* Press
-		* Recognized when the pointer is down for x ms without any movement.
-		* @constructor
-		* @extends Recognizer
-		*/
-		function PressRecognizer() {
-			Recognizer.apply(this, arguments);
-			this._timer = null;
-			this._input = null;
-		}
-		inherit(PressRecognizer, Recognizer, {
-			defaults: {
-				event: "press",
-				pointers: 1,
-				time: 251,
-				threshold: 9
-			},
-			getTouchAction: function() {
-				return [TOUCH_ACTION_AUTO];
-			},
-			process: function(input) {
-				var options = this.options;
-				var validPointers = input.pointers.length === options.pointers;
-				var validMovement = input.distance < options.threshold;
-				var validTime = input.deltaTime > options.time;
-				this._input = input;
-				if (!validMovement || !validPointers || input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime) this.reset();
-				else if (input.eventType & INPUT_START) {
-					this.reset();
-					this._timer = setTimeoutContext(function() {
-						this.state = STATE_RECOGNIZED;
-						this.tryEmit();
-					}, options.time, this);
-				} else if (input.eventType & INPUT_END) return STATE_RECOGNIZED;
-				return STATE_FAILED;
-			},
-			reset: function() {
-				clearTimeout(this._timer);
-			},
-			emit: function(input) {
-				if (this.state !== STATE_RECOGNIZED) return;
-				if (input && input.eventType & INPUT_END) this.manager.emit(this.options.event + "up", input);
-				else {
-					this._input.timeStamp = now();
-					this.manager.emit(this.options.event, this._input);
-				}
-			}
-		});
-		/**
-		* Rotate
-		* Recognized when two or more pointer are moving in a circular motion.
-		* @constructor
-		* @extends AttrRecognizer
-		*/
-		function RotateRecognizer() {
-			AttrRecognizer.apply(this, arguments);
-		}
-		inherit(RotateRecognizer, AttrRecognizer, {
-			defaults: {
-				event: "rotate",
-				threshold: 0,
-				pointers: 2
-			},
-			getTouchAction: function() {
-				return [TOUCH_ACTION_NONE];
-			},
-			attrTest: function(input) {
-				return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
-			}
-		});
-		/**
-		* Swipe
-		* Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
-		* @constructor
-		* @extends AttrRecognizer
-		*/
-		function SwipeRecognizer() {
-			AttrRecognizer.apply(this, arguments);
-		}
-		inherit(SwipeRecognizer, AttrRecognizer, {
-			defaults: {
-				event: "swipe",
-				threshold: 10,
-				velocity: .3,
-				direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
-				pointers: 1
-			},
-			getTouchAction: function() {
-				return PanRecognizer.prototype.getTouchAction.call(this);
-			},
-			attrTest: function(input) {
-				var direction = this.options.direction;
-				var velocity;
-				if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) velocity = input.overallVelocity;
-				else if (direction & DIRECTION_HORIZONTAL) velocity = input.overallVelocityX;
-				else if (direction & DIRECTION_VERTICAL) velocity = input.overallVelocityY;
-				return this._super.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers == this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
-			},
-			emit: function(input) {
-				var direction = directionStr(input.offsetDirection);
-				if (direction) this.manager.emit(this.options.event + direction, input);
-				this.manager.emit(this.options.event, input);
-			}
-		});
-		/**
-		* A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
-		* between the given interval and position. The delay option can be used to recognize multi-taps without firing
-		* a single tap.
-		*
-		* The eventData from the emitted event contains the property `tapCount`, which contains the amount of
-		* multi-taps being recognized.
-		* @constructor
-		* @extends Recognizer
-		*/
-		function TapRecognizer() {
-			Recognizer.apply(this, arguments);
-			this.pTime = false;
-			this.pCenter = false;
-			this._timer = null;
-			this._input = null;
-			this.count = 0;
-		}
-		inherit(TapRecognizer, Recognizer, {
-			defaults: {
-				event: "tap",
-				pointers: 1,
-				taps: 1,
-				interval: 300,
-				time: 250,
-				threshold: 9,
-				posThreshold: 10
-			},
-			getTouchAction: function() {
-				return [TOUCH_ACTION_MANIPULATION];
-			},
-			process: function(input) {
-				var options = this.options;
-				var validPointers = input.pointers.length === options.pointers;
-				var validMovement = input.distance < options.threshold;
-				var validTouchTime = input.deltaTime < options.time;
-				this.reset();
-				if (input.eventType & INPUT_START && this.count === 0) return this.failTimeout();
-				if (validMovement && validTouchTime && validPointers) {
-					if (input.eventType != INPUT_END) return this.failTimeout();
-					var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
-					var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
-					this.pTime = input.timeStamp;
-					this.pCenter = input.center;
-					if (!validMultiTap || !validInterval) this.count = 1;
-					else this.count += 1;
-					this._input = input;
-					var tapCount = this.count % options.taps;
-					if (tapCount === 0) if (!this.hasRequireFailures()) return STATE_RECOGNIZED;
-					else {
-						this._timer = setTimeoutContext(function() {
-							this.state = STATE_RECOGNIZED;
-							this.tryEmit();
-						}, options.interval, this);
-						return STATE_BEGAN;
-					}
-				}
-				return STATE_FAILED;
-			},
-			failTimeout: function() {
-				this._timer = setTimeoutContext(function() {
-					this.state = STATE_FAILED;
-				}, this.options.interval, this);
-				return STATE_FAILED;
-			},
-			reset: function() {
-				clearTimeout(this._timer);
-			},
-			emit: function() {
-				if (this.state == STATE_RECOGNIZED) {
-					this._input.tapCount = this.count;
-					this.manager.emit(this.options.event, this._input);
-				}
-			}
-		});
-		/**
-		* Simple way to create a manager with a default set of recognizers.
-		* @param {HTMLElement} element
-		* @param {Object} [options]
-		* @constructor
-		*/
-		function Hammer(element, options) {
-			options = options || {};
-			options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
-			return new Manager(element, options);
-		}
-		/**
-		* @const {string}
-		*/
-		Hammer.VERSION = "2.0.7";
-		/**
-		* default settings
-		* @namespace
-		*/
-		Hammer.defaults = {
-			domEvents: false,
-			touchAction: TOUCH_ACTION_COMPUTE,
-			enable: true,
-			inputTarget: null,
-			inputClass: null,
-			preset: [
-				[RotateRecognizer, { enable: false }],
-				[
-					PinchRecognizer,
-					{ enable: false },
-					["rotate"]
-				],
-				[SwipeRecognizer, { direction: DIRECTION_HORIZONTAL }],
-				[
-					PanRecognizer,
-					{ direction: DIRECTION_HORIZONTAL },
-					["swipe"]
-				],
-				[TapRecognizer],
-				[
-					TapRecognizer,
-					{
-						event: "doubletap",
-						taps: 2
-					},
-					["tap"]
-				],
-				[PressRecognizer]
-			],
-			cssProps: {
-				userSelect: "none",
-				touchSelect: "none",
-				touchCallout: "none",
-				contentZooming: "none",
-				userDrag: "none",
-				tapHighlightColor: "rgba(0,0,0,0)"
-			}
-		};
-		var STOP = 1;
-		var FORCED_STOP = 2;
-		/**
-		* Manager
-		* @param {HTMLElement} element
-		* @param {Object} [options]
-		* @constructor
-		*/
-		function Manager(element, options) {
-			this.options = assign({}, Hammer.defaults, options || {});
-			this.options.inputTarget = this.options.inputTarget || element;
-			this.handlers = {};
-			this.session = {};
-			this.recognizers = [];
-			this.oldCssProps = {};
-			this.element = element;
-			this.input = createInputInstance(this);
-			this.touchAction = new TouchAction(this, this.options.touchAction);
-			toggleCssProps(this, true);
-			each(this.options.recognizers, function(item) {
-				var recognizer = this.add(new item[0](item[1]));
-				item[2] && recognizer.recognizeWith(item[2]);
-				item[3] && recognizer.requireFailure(item[3]);
-			}, this);
-		}
-		Manager.prototype = {
-			set: function(options) {
-				assign(this.options, options);
-				if (options.touchAction) this.touchAction.update();
-				if (options.inputTarget) {
-					this.input.destroy();
-					this.input.target = options.inputTarget;
-					this.input.init();
-				}
-				return this;
-			},
-			stop: function(force) {
-				this.session.stopped = force ? FORCED_STOP : STOP;
-			},
-			recognize: function(inputData) {
-				var session = this.session;
-				if (session.stopped) return;
-				this.touchAction.preventDefaults(inputData);
-				var recognizer;
-				var recognizers = this.recognizers;
-				var curRecognizer = session.curRecognizer;
-				if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) curRecognizer = session.curRecognizer = null;
-				var i = 0;
-				while (i < recognizers.length) {
-					recognizer = recognizers[i];
-					if (session.stopped !== FORCED_STOP && (!curRecognizer || recognizer == curRecognizer || recognizer.canRecognizeWith(curRecognizer))) recognizer.recognize(inputData);
-					else recognizer.reset();
-					if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) curRecognizer = session.curRecognizer = recognizer;
-					i++;
-				}
-			},
-			get: function(recognizer) {
-				if (recognizer instanceof Recognizer) return recognizer;
-				var recognizers = this.recognizers;
-				for (var i = 0; i < recognizers.length; i++) if (recognizers[i].options.event == recognizer) return recognizers[i];
-				return null;
-			},
-			add: function(recognizer) {
-				if (invokeArrayArg(recognizer, "add", this)) return this;
-				var existing = this.get(recognizer.options.event);
-				if (existing) this.remove(existing);
-				this.recognizers.push(recognizer);
-				recognizer.manager = this;
-				this.touchAction.update();
-				return recognizer;
-			},
-			remove: function(recognizer) {
-				if (invokeArrayArg(recognizer, "remove", this)) return this;
-				recognizer = this.get(recognizer);
-				if (recognizer) {
-					var recognizers = this.recognizers;
-					var index = inArray(recognizers, recognizer);
-					if (index !== -1) {
-						recognizers.splice(index, 1);
-						this.touchAction.update();
-					}
-				}
-				return this;
-			},
-			on: function(events, handler) {
-				if (events === undefined$1) return;
-				if (handler === undefined$1) return;
-				var handlers = this.handlers;
-				each(splitStr(events), function(event) {
-					handlers[event] = handlers[event] || [];
-					handlers[event].push(handler);
-				});
-				return this;
-			},
-			off: function(events, handler) {
-				if (events === undefined$1) return;
-				var handlers = this.handlers;
-				each(splitStr(events), function(event) {
-					if (!handler) delete handlers[event];
-					else handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
-				});
-				return this;
-			},
-			emit: function(event, data) {
-				if (this.options.domEvents) triggerDomEvent(event, data);
-				var handlers = this.handlers[event] && this.handlers[event].slice();
-				if (!handlers || !handlers.length) return;
-				data.type = event;
-				data.preventDefault = function() {
-					data.srcEvent.preventDefault();
-				};
-				var i = 0;
-				while (i < handlers.length) {
-					handlers[i](data);
-					i++;
-				}
-			},
-			destroy: function() {
-				this.element && toggleCssProps(this, false);
-				this.handlers = {};
-				this.session = {};
-				this.input.destroy();
-				this.element = null;
-			}
-		};
-		/**
-		* add/remove the css properties as defined in manager.options.cssProps
-		* @param {Manager} manager
-		* @param {Boolean} add
-		*/
-		function toggleCssProps(manager, add) {
-			var element = manager.element;
-			if (!element.style) return;
-			var prop;
-			each(manager.options.cssProps, function(value, name) {
-				prop = prefixed(element.style, name);
-				if (add) {
-					manager.oldCssProps[prop] = element.style[prop];
-					element.style[prop] = value;
-				} else element.style[prop] = manager.oldCssProps[prop] || "";
-			});
-			if (!add) manager.oldCssProps = {};
-		}
-		/**
-		* trigger dom event
-		* @param {String} event
-		* @param {Object} data
-		*/
-		function triggerDomEvent(event, data) {
-			var gestureEvent = document$1.createEvent("Event");
-			gestureEvent.initEvent(event, true, true);
-			gestureEvent.gesture = data;
-			data.target.dispatchEvent(gestureEvent);
-		}
-		assign(Hammer, {
-			INPUT_START,
-			INPUT_MOVE,
-			INPUT_END,
-			INPUT_CANCEL,
-			STATE_POSSIBLE,
-			STATE_BEGAN,
-			STATE_CHANGED,
-			STATE_ENDED,
-			STATE_RECOGNIZED,
-			STATE_CANCELLED,
-			STATE_FAILED,
-			DIRECTION_NONE,
-			DIRECTION_LEFT,
-			DIRECTION_RIGHT,
-			DIRECTION_UP,
-			DIRECTION_DOWN,
-			DIRECTION_HORIZONTAL,
-			DIRECTION_VERTICAL,
-			DIRECTION_ALL,
-			Manager,
-			Input,
-			TouchAction,
-			TouchInput,
-			MouseInput,
-			PointerEventInput,
-			TouchMouseInput,
-			SingleTouchInput,
-			Recognizer,
-			AttrRecognizer,
-			Tap: TapRecognizer,
-			Pan: PanRecognizer,
-			Swipe: SwipeRecognizer,
-			Pinch: PinchRecognizer,
-			Rotate: RotateRecognizer,
-			Press: PressRecognizer,
-			on: addEventListeners,
-			off: removeEventListeners,
-			each,
-			merge,
-			extend,
-			assign,
-			inherit,
-			bindFn,
-			prefixed
-		});
-		var freeGlobal = typeof window$1 !== "undefined" ? window$1 : typeof self !== "undefined" ? self : {};
-		freeGlobal.Hammer = Hammer;
-		if (typeof define === "function" && define.amd) define(function() {
-			return Hammer;
-		});
-		else if (typeof module != "undefined" && module.exports) module.exports = Hammer;
-		else window$1[exportName] = Hammer;
-	})(window, document, "Hammer");
-} });
-var import_hammer = __toESM(require_hammer(), 1);
-
 //#endregion
 //#region src/plugins/stage-zoom/stage-zoom.ts
 var WeaveStageZoomPlugin = class extends WeavePlugin {
@@ -23697,19 +22027,12 @@ var WeaveStageZoomPlugin = class extends WeavePlugin {
 	isTrackpad = false;
 	zoomVelocity = 0;
 	zoomInertiaType = WEAVE_STAGE_ZOOM_TYPE.MOUSE_WHEEL;
-	initialScale = 0;
-	lastTime = 0;
-	center = {
-		x: 0,
-		y: 0
-	};
 	defaultStep = 3;
 	constructor(params) {
 		super();
 		const { config } = params ?? {};
 		this.config = (0, import_lodash.merge)(WEAVE_STAGE_ZOOM_DEFAULT_CONFIG, config);
 		if (!this.config.zoomSteps.includes(this.config.defaultZoom)) throw new Error(`Default zoom ${this.config.defaultZoom} is not in zoom steps`);
-		this.threshold = .2;
 		this.pinching = false;
 		this.isTrackpad = false;
 		this.isCtrlOrMetaPressed = false;
@@ -23950,6 +22273,15 @@ var WeaveStageZoomPlugin = class extends WeavePlugin {
 	disable() {
 		this.enabled = false;
 	}
+	getDistance(p1, p2) {
+		return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+	}
+	getCenter(p1, p2) {
+		return {
+			x: (p1.x + p2.x) / 2,
+			y: (p1.y + p2.y) / 2
+		};
+	}
 	initEvents() {
 		window.addEventListener("keydown", (e) => {
 			if (e.ctrlKey || e.metaKey) this.isCtrlOrMetaPressed = true;
@@ -23958,57 +22290,80 @@ var WeaveStageZoomPlugin = class extends WeavePlugin {
 			if (!(e.ctrlKey || e.metaKey)) this.isCtrlOrMetaPressed = false;
 		});
 		const stage = this.instance.getStage();
-		const stageContainer = this.instance.getStage().container();
-		const sc = new import_hammer.default.Manager(stageContainer);
-		sc.add(new import_hammer.default.Pinch({
-			threshold: this.threshold,
-			pointers: 2
-		}));
-		sc.on("pinchstart", (e) => {
-			if (this.getPanPlugin()?.isPanning()) {
-				this.pinching = false;
-				return;
-			}
-			this.getNodesSelectionPlugin()?.disable();
-			this.initialScale = this.instance.getStage().scaleX();
-			this.center = {
-				x: e.center.x,
-				y: e.center.y
-			};
-			this.lastTime = performance.now();
-		});
-		sc.on("pinchmove", (e) => {
-			if (this.getPanPlugin()?.isPanning()) {
-				this.pinching = false;
-				return;
+		let lastCenter = null;
+		let lastDist = 0;
+		stage.getContent().addEventListener("touchstart", (e) => {
+			e.preventDefault();
+			if (e.touches.length === 2) {
+				e.preventDefault();
+				e.stopPropagation();
+				this.pinching = true;
+				const touch1 = e.touches[0];
+				const touch2 = e.touches[1];
+				const p1 = {
+					x: touch1.clientX,
+					y: touch1.clientY
+				};
+				const p2 = {
+					x: touch2.clientX,
+					y: touch2.clientY
+				};
+				if (!lastCenter) {
+					lastCenter = this.getCenter(p1, p2);
+					return;
+				}
 			}
-			this.pinching = true;
-			const now = performance.now();
-			this.getContextMenuPlugin()?.cancelLongPressTimer();
-			const newScale = Math.max(this.config.zoomSteps[0], Math.min(this.config.zoomSteps[this.config.zoomSteps.length - 1], this.initialScale * e.scale));
-			this.setZoom(newScale, false, this.center);
-			const dt = now - this.lastTime;
-			this.zoomVelocity = (newScale - 1) / (dt * 16.6);
-			this.lastTime = now;
-		});
-		sc.on("pinchend", () => {
-			if (this.getPanPlugin()?.isPanning()) {
-				this.pinching = false;
-				this.zooming = false;
-				return;
+		}, { passive: false });
+		stage.getContent().addEventListener("touchmove", (e) => {
+			e.preventDefault();
+			if (e.touches.length === 2) {
+				e.preventDefault();
+				e.stopPropagation();
+				this.getContextMenuPlugin()?.cancelLongPressTimer();
+				const touch1 = e.touches[0];
+				const touch2 = e.touches[1];
+				const p1 = {
+					x: touch1.clientX,
+					y: touch1.clientY
+				};
+				const p2 = {
+					x: touch2.clientX,
+					y: touch2.clientY
+				};
+				if (!lastCenter) {
+					lastCenter = this.getCenter(p1, p2);
+					return;
+				}
+				const newCenter = this.getCenter(p1, p2);
+				const dist = this.getDistance(p1, p2);
+				if (!lastDist) lastDist = dist;
+				const pointTo = {
+					x: (newCenter.x - stage.x()) / stage.scaleX(),
+					y: (newCenter.y - stage.y()) / stage.scaleX()
+				};
+				const newScale = Math.max(this.config.zoomSteps[0], Math.min(this.config.zoomSteps[this.config.zoomSteps.length - 1], stage.scaleX() * (dist / lastDist)));
+				this.setZoom(newScale, false, newCenter);
+				const dx = newCenter.x - lastCenter.x;
+				const dy = newCenter.y - lastCenter.y;
+				const newPos = {
+					x: newCenter.x - pointTo.x * newScale + dx,
+					y: newCenter.y - pointTo.y * newScale + dy
+				};
+				stage.position(newPos);
+				lastDist = dist;
+				lastCenter = newCenter;
 			}
-			this.getNodesSelectionPlugin()?.enable();
+		}, { passive: false });
+		stage.getContent().addEventListener("touchend", () => {
 			this.pinching = false;
-			this.zooming = true;
-			this.zoomInertiaType = WEAVE_STAGE_ZOOM_TYPE.PINCH_ZOOM;
-			requestAnimationFrame(this.zoomTick.bind(this));
-		});
+			lastDist = 0;
+			lastCenter = null;
+		}, { passive: false });
 		const handleWheel = (e) => {
 			e.evt.preventDefault();
 			const stage$1 = this.instance.getStage();
 			const performZoom = this.isCtrlOrMetaPressed || !this.isCtrlOrMetaPressed && e.evt.ctrlKey && e.evt.deltaMode === 0;
 			if (!this.enabled || !stage$1.isFocused() || !performZoom) return;
-			this.getNodesSelectionPlugin()?.disable();
 			const delta = e.evt.deltaY > 0 ? 1 : -1;
 			this.zoomVelocity += delta;
 			this.isTrackpad = Math.abs(e.evt.deltaY) < 15 && e.evt.deltaMode === 0;
@@ -24035,13 +22390,12 @@ var WeaveStageZoomPlugin = class extends WeavePlugin {
 			this.zooming = false;
 			return;
 		}
-		let pointer = this.center;
+		let pointer = null;
 		if (this.zoomInertiaType === WEAVE_STAGE_ZOOM_TYPE.MOUSE_WHEEL) {
 			const stage = this.instance.getStage();
 			pointer = stage.getPointerPosition();
 		}
 		if (!pointer) return;
-		this.getNodesSelectionPlugin()?.enable();
 		this.setZoom(this.getInertiaScale(), false, pointer);
 		this.zoomVelocity *= this.config.zoomInertia.friction;
 		this.getStageGridPlugin()?.onRender();
@@ -24058,10 +22412,6 @@ var WeaveStageZoomPlugin = class extends WeavePlugin {
 		const selectionPlugin = this.instance.getPlugin("nodesSelection");
 		return selectionPlugin;
 	}
-	getPanPlugin() {
-		const panPlugin = this.instance.getPlugin("stagePanning");
-		return panPlugin;
-	}
 	getContextMenuPlugin() {
 		const contextMenuPlugin = this.instance.getPlugin("contextMenu");
 		return contextMenuPlugin;
@@ -26778,18 +25128,13 @@ const WEAVE_STAGE_PANNING_KEY = "stagePanning";
 //#endregion
 //#region src/plugins/stage-panning/stage-panning.ts
 var WeaveStagePanningPlugin = class extends WeavePlugin {
-	pinching = false;
 	panning = false;
 	getLayerName = void 0;
 	initLayer = void 0;
 	constructor() {
 		super();
 		this.pointers = new Map();
-		this.lastCenter = null;
-		this.pinching = false;
 		this.panning = false;
-		this.threshold = 5;
-		this.pointersDistanceDiffThreshold = 10;
 		this.enabled = true;
 		this.moveToolActive = false;
 		this.isMouseMiddleButtonPressed = false;
@@ -26833,20 +25178,14 @@ var WeaveStagePanningPlugin = class extends WeavePlugin {
 				this.disableMove();
 			}
 		});
-		let startPointersDistance = null;
-		let startCenter = null;
 		let lastPos = null;
 		let isDragging = false;
-		let velocity = {
-			x: 0,
-			y: 0
-		};
-		let lastTime = 0;
 		stage.on("pointerdown", (e) => {
 			this.pointers.set(e.evt.pointerId, {
 				x: e.evt.clientX,
 				y: e.evt.clientY
 			});
+			if (this.pointers.size > 1) return;
 			const activeAction = this.instance.getActiveAction();
 			let enableMove = false;
 			if (e && (e.evt.pointerType !== "mouse" || e.evt.pointerType === "mouse" && e.evt.buttons === 1) && activeAction === "moveTool") {
@@ -26857,142 +25196,40 @@ var WeaveStagePanningPlugin = class extends WeavePlugin {
 				this.isMouseMiddleButtonPressed = true;
 				enableMove = true;
 			}
-			if (e.evt.pointerType !== "mouse" && this.pointers.size === 2 && !this.pinching && !this.panning) {
-				const center = this.getTouchCenter();
-				const [p1, p2] = Array.from(this.pointers.values());
-				const pointersDistance = this.getDistance(p1, p2);
-				if (!startCenter) {
-					startPointersDistance = pointersDistance;
-					startCenter = center;
-					this.lastCenter = center;
-					this.pinching = false;
-					this.panning = false;
-					velocity = {
-						x: 0,
-						y: 0
-					};
-				}
-				isDragging = true;
-				lastPos = stage.getPointerPosition();
-				lastTime = performance.now();
-				this.enableMove();
-				return;
-			}
 			if (enableMove) {
 				isDragging = true;
 				lastPos = stage.getPointerPosition();
-				lastTime = performance.now();
-				velocity = {
-					x: 0,
-					y: 0
-				};
 				this.enableMove();
 			}
 		});
 		stage.on("pointercancel", (e) => {
 			this.pointers.delete(e.evt.pointerId);
 			lastPos = null;
-			this.lastCenter = null;
 		});
 		const handleMouseMove = (e) => {
 			this.pointers.set(e.evt.pointerId, {
 				x: e.evt.clientX,
 				y: e.evt.clientY
 			});
+			if (this.pointers.size > 1) return;
 			if (!isDragging) return;
-			const center = this.getTouchCenter();
-			if (e.evt.pointerType !== "mouse" && this.pointers.size !== 2) {
-				startCenter = null;
-				startPointersDistance = null;
-				this.pinching = false;
-				this.panning = false;
-			}
-			if (e.evt.pointerType !== "mouse" && this.pointers.size === 2) {
-				this.getContextMenuPlugin()?.cancelLongPressTimer();
-				const [p1, p2] = Array.from(this.pointers.values());
-				const pointersDistance = this.getDistance(p1, p2);
-				if (!startCenter) {
-					startPointersDistance = pointersDistance;
-					startCenter = center;
-					this.lastCenter = center;
-					this.pinching = false;
-					this.panning = false;
-				}
-				if (center && startCenter && startPointersDistance && this.lastCenter) {
-					const now$1 = performance.now();
-					const dt$1 = now$1 - lastTime;
-					const dx = center.x - startCenter.x;
-					const dy = center.y - startCenter.y;
-					const distanceCenters = Math.hypot(dx, dy);
-					const distanceChange = Math.abs(pointersDistance - startPointersDistance);
-					if (!this.pinching && distanceCenters > this.threshold && distanceChange <= this.pointersDistanceDiffThreshold) this.panning = true;
-					if (!this.panning && distanceCenters <= this.threshold && distanceChange > this.pointersDistanceDiffThreshold) this.pinching = true;
-					if (this.panning) {
-						this.getNodesSelectionPlugin()?.disable();
-						const dx$1 = center.x - this.lastCenter.x;
-						const dy$1 = center.y - this.lastCenter.y;
-						velocity = {
-							x: dx$1 / dt$1,
-							y: dy$1 / dt$1
-						};
-						stage.x(stage.x() + dx$1);
-						stage.y(stage.y() + dy$1);
-						this.instance.emitEvent("onStageMove");
-					}
-					this.lastCenter = center;
-					lastTime = now$1;
-					return;
-				}
-			}
-			this.lastCenter = center;
 			if (!this.enabled || !(this.isSpaceKeyPressed || this.isMouseMiddleButtonPressed || this.moveToolActive)) return;
 			this.getContextMenuPlugin()?.cancelLongPressTimer();
-			this.getNodesSelectionPlugin()?.disable();
 			const pos = stage.getPointerPosition();
-			const now = performance.now();
-			const dt = now - lastTime;
 			if (pos && lastPos) {
 				const dx = pos.x - lastPos.x;
 				const dy = pos.y - lastPos.y;
-				velocity = {
-					x: dx / dt,
-					y: dy / dt
-				};
 				stage.x(stage.x() + dx);
 				stage.y(stage.y() + dy);
 			}
 			lastPos = pos;
-			lastTime = now;
 			this.instance.emitEvent("onStageMove");
 		};
 		stage.on("pointermove", handleMouseMove);
-		const decay = .95;
-		const animateInertia = () => {
-			velocity.x *= decay;
-			velocity.y *= decay;
-			if (Math.abs(velocity.x) < .01 && Math.abs(velocity.y) < .01) return;
-			stage.x(stage.x() + velocity.x);
-			stage.y(stage.y() + velocity.y);
-			this.instance.emitEvent("onStageMove");
-			requestAnimationFrame(animateInertia);
-		};
 		stage.on("pointerup", (e) => {
 			this.pointers.delete(e.evt.pointerId);
-			if (e.evt.pointerType !== "mouse" && this.pointers.size < 2) {
-				this.getNodesSelectionPlugin()?.enable();
-				isDragging = false;
-				startCenter = null;
-				startPointersDistance = null;
-				this.lastCenter = null;
-				this.pinching = false;
-				this.panning = false;
-				requestAnimationFrame(animateInertia);
-				return;
-			}
 			isDragging = false;
-			this.pinching = false;
 			this.panning = false;
-			requestAnimationFrame(animateInertia);
 		});
 		const handleWheel = (e) => {
 			e.evt.preventDefault();