mtrl-addons 0.5.6 → 0.7.0

package/dist/components/vlist/types.d.ts

@@ -429,6 +429,13 @@ export interface ListAPI<T extends ListItem = ListItem> {
      * @returns Set of pending removal IDs
      */
     getPendingRemovals(): Set<string | number>;
+    /**
+     * Mark an item as pending removal without removing it
+     * Use this to prevent race conditions when the removal will happen later
+     * @param id - The item ID to mark as pending removal
+     * @param timeout - Optional timeout in ms to auto-clear (default: 10000)
+     */
+    markPendingRemoval(id: string | number, timeout?: number): void;
     /**
      * Clear a specific pending removal
      * @param id - The item ID to clear from pending removals

package/dist/core/gestures/index.js

@@ -0,0 +1,508 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/gestures/index.ts
+var exports_gestures = {};
+__export(exports_gestures, {
+  detectTap: () => detectTap,
+  detectSwipe: () => detectSwipe,
+  detectRotate: () => detectRotate,
+  detectPinch: () => detectPinch,
+  detectPan: () => detectPan,
+  detectLongPress: () => detectLongPress,
+  createGestureManager: () => createGestureManager,
+  SWIPE_DIRECTIONS: () => SWIPE_DIRECTIONS,
+  GESTURE_TYPES: () => GESTURE_TYPES
+});
+module.exports = __toCommonJS(exports_gestures);
+
+// src/core/gestures/types.ts
+var GESTURE_TYPES;
+((GESTURE_TYPES2) => {
+  GESTURE_TYPES2["TAP"] = "tap";
+  GESTURE_TYPES2["SWIPE"] = "swipe";
+  GESTURE_TYPES2["SWIPE_LEFT"] = "swipeleft";
+  GESTURE_TYPES2["SWIPE_RIGHT"] = "swiperight";
+  GESTURE_TYPES2["SWIPE_UP"] = "swipeup";
+  GESTURE_TYPES2["SWIPE_DOWN"] = "swipedown";
+  GESTURE_TYPES2["PINCH"] = "pinch";
+  GESTURE_TYPES2["ROTATE"] = "rotate";
+  GESTURE_TYPES2["LONG_PRESS"] = "longpress";
+  GESTURE_TYPES2["PAN"] = "pan";
+})(GESTURE_TYPES ||= {});
+var SWIPE_DIRECTIONS;
+((SWIPE_DIRECTIONS2) => {
+  SWIPE_DIRECTIONS2["UP"] = "up";
+  SWIPE_DIRECTIONS2["DOWN"] = "down";
+  SWIPE_DIRECTIONS2["LEFT"] = "left";
+  SWIPE_DIRECTIONS2["RIGHT"] = "right";
+})(SWIPE_DIRECTIONS ||= {});
+
+// src/core/gestures/utils.ts
+function getDistance(x1, y1, x2, y2) {
+  return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+}
+function getAngle(x1, y1, x2, y2) {
+  const angle = Math.atan2(y2 - y1, x2 - x1) * 180 / Math.PI;
+  return angle < 0 ? angle + 360 : angle;
+}
+function createGestureEvent(type, originalEvent, state) {
+  const endTime = Date.now();
+  let defaultPrevented = false;
+  const event = {
+    type,
+    originalEvent,
+    target: state.target || originalEvent.target,
+    startTime: state.startTime,
+    endTime,
+    duration: endTime - state.startTime,
+    defaultPrevented,
+    preventDefault: () => {
+      defaultPrevented = true;
+      event.defaultPrevented = true;
+      if (originalEvent.cancelable) {
+        originalEvent.preventDefault();
+      }
+    },
+    stopPropagation: () => {
+      originalEvent.stopPropagation();
+    }
+  };
+  return event;
+}
+function hasTouchSupport() {
+  const maxPoints = navigator.maxTouchPoints;
+  return "ontouchstart" in window || typeof maxPoints === "number" && maxPoints > 0;
+}
+function hasPointerSupport() {
+  return !!window.PointerEvent;
+}
+function getTouchCoordinates(e) {
+  if ("touches" in e && Array.isArray(e.touches) && e.touches.length > 0) {
+    return {
+      clientX: e.touches[0].clientX,
+      clientY: e.touches[0].clientY
+    };
+  }
+  return {
+    clientX: e.clientX,
+    clientY: e.clientY
+  };
+}
+
+// src/core/gestures/tap.ts
+function detectTap(context) {
+  const { state, options, originalEvent } = context;
+  const deltaX = state.currentX - state.startX;
+  const deltaY = state.currentY - state.startY;
+  const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+  if (distance < options.tapDistanceThreshold) {
+    const now = Date.now();
+    const isDoubleTap = now - state.lastTapTime < 300;
+    const tapCount = isDoubleTap ? state.tapCount + 1 : 1;
+    const tapEvent = {
+      ...createGestureEvent("tap", originalEvent, state),
+      type: "tap",
+      count: tapCount,
+      x: state.currentX,
+      y: state.currentY
+    };
+    return tapEvent;
+  }
+  return null;
+}
+
+// src/core/gestures/swipe.ts
+function getSwipeDirection(deltaX, deltaY) {
+  if (Math.abs(deltaX) > Math.abs(deltaY)) {
+    return deltaX > 0 ? "right" /* RIGHT */ : "left" /* LEFT */;
+  }
+  return deltaY > 0 ? "down" /* DOWN */ : "up" /* UP */;
+}
+function detectSwipe(context) {
+  const { state, options, originalEvent } = context;
+  const deltaX = state.currentX - state.startX;
+  const deltaY = state.currentY - state.startY;
+  const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+  const endTime = Date.now();
+  const deltaTime = endTime - state.startTime;
+  const velocity = distance / deltaTime;
+  if (distance >= options.swipeThreshold && deltaTime <= options.swipeTimeThreshold) {
+    const direction = getSwipeDirection(deltaX, deltaY);
+    const swipeEvent = {
+      ...createGestureEvent("swipe", originalEvent, state),
+      type: "swipe",
+      direction,
+      deltaX,
+      deltaY,
+      distance,
+      velocity,
+      startX: state.startX,
+      startY: state.startY,
+      endX: state.currentX,
+      endY: state.currentY
+    };
+    return swipeEvent;
+  }
+  return null;
+}
+
+// src/core/gestures/longpress.ts
+function detectLongPress(context, callback) {
+  const { state, options, originalEvent } = context;
+  const timer = window.setTimeout(() => {
+    if (state.active) {
+      const diffX = Math.abs(state.currentX - state.startX);
+      const diffY = Math.abs(state.currentY - state.startY);
+      if (diffX < options.tapDistanceThreshold && diffY < options.tapDistanceThreshold) {
+        const longPressEvent = {
+          ...createGestureEvent("longpress", originalEvent, state),
+          type: "longpress",
+          x: state.currentX,
+          y: state.currentY
+        };
+        callback(longPressEvent);
+      }
+    }
+  }, options.longPressTime);
+  return () => {
+    clearTimeout(timer);
+  };
+}
+function shouldCancelLongPress(context) {
+  const { state, options } = context;
+  const diffX = Math.abs(state.currentX - state.startX);
+  const diffY = Math.abs(state.currentY - state.startY);
+  return diffX > options.tapDistanceThreshold || diffY > options.tapDistanceThreshold;
+}
+
+// src/core/gestures/pan.ts
+function detectPan(context) {
+  const { state, originalEvent } = context;
+  const deltaX = state.currentX - state.startX;
+  const deltaY = state.currentY - state.startY;
+  const moveDeltaX = state.currentX - state.lastX;
+  const moveDeltaY = state.currentY - state.lastY;
+  const moveDelta = Math.sqrt(moveDeltaX * moveDeltaX + moveDeltaY * moveDeltaY);
+  if (moveDelta > 0) {
+    const panEvent = {
+      ...createGestureEvent("pan", originalEvent, state),
+      type: "pan",
+      deltaX,
+      deltaY,
+      startX: state.startX,
+      startY: state.startY,
+      currentX: state.currentX,
+      currentY: state.currentY
+    };
+    return panEvent;
+  }
+  return null;
+}
+
+// src/core/gestures/pinch.ts
+function detectPinch(context, touch1, touch2) {
+  const { state, originalEvent } = context;
+  const currentDistance = getDistance(touch1.clientX, touch1.clientY, touch2.clientX, touch2.clientY);
+  const PINCH_THRESHOLD = 10;
+  if (Math.abs(currentDistance - state.startDistance) > PINCH_THRESHOLD) {
+    const scale = currentDistance / state.startDistance;
+    const centerX = (touch1.clientX + touch2.clientX) / 2;
+    const centerY = (touch1.clientY + touch2.clientY) / 2;
+    const pinchEvent = {
+      ...createGestureEvent("pinch", originalEvent, state),
+      type: "pinch",
+      scale,
+      centerX,
+      centerY
+    };
+    return pinchEvent;
+  }
+  return null;
+}
+
+// src/core/gestures/rotate.ts
+function detectRotate(context, touch1, touch2) {
+  const { state, originalEvent } = context;
+  const currentAngle = getAngle(touch1.clientX, touch1.clientY, touch2.clientX, touch2.clientY);
+  const ROTATION_THRESHOLD = 10;
+  const rotationDiff = currentAngle - state.startAngle;
+  if (Math.abs(rotationDiff) > ROTATION_THRESHOLD) {
+    const centerX = (touch1.clientX + touch2.clientX) / 2;
+    const centerY = (touch1.clientY + touch2.clientY) / 2;
+    const rotateEvent = {
+      ...createGestureEvent("rotate", originalEvent, state),
+      type: "rotate",
+      rotation: rotationDiff,
+      centerX,
+      centerY
+    };
+    return rotateEvent;
+  }
+  return null;
+}
+
+// src/core/gestures/manager.ts
+var createGestureManager = (element, config = {}) => {
+  const options = {
+    swipeThreshold: 30,
+    swipeTimeThreshold: 300,
+    longPressTime: 500,
+    tapDistanceThreshold: 10,
+    preventDefault: true,
+    stopPropagation: false,
+    ...config
+  };
+  const handlers = new Map;
+  const state = {
+    active: false,
+    startTime: 0,
+    startX: 0,
+    startY: 0,
+    lastX: 0,
+    lastY: 0,
+    currentX: 0,
+    currentY: 0,
+    touchCount: 0,
+    longPressTimer: null,
+    startDistance: 0,
+    startAngle: 0,
+    lastTapTime: 0,
+    tapCount: 0,
+    target: null
+  };
+  const supportTouch = hasTouchSupport();
+  const supportPointer = hasPointerSupport();
+  const gestureSupport = {
+    tap: true,
+    swipe: true,
+    swipeleft: true,
+    swiperight: true,
+    swipeup: true,
+    swipedown: true,
+    longpress: true,
+    pan: true,
+    pinch: supportTouch || supportPointer,
+    rotate: supportTouch || supportPointer
+  };
+  const dispatchGesture = (event) => {
+    const eventHandlers = handlers.get(event.type);
+    if (!eventHandlers)
+      return;
+    eventHandlers.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error(`Error in gesture handler for ${event.type}:`, error);
+      }
+    });
+    if (event.type === "swipe" && "direction" in event) {
+      const directionEvent = { ...event, type: `swipe${event.direction}` };
+      dispatchGesture(directionEvent);
+    }
+    if (options.preventDefault && !event.defaultPrevented) {
+      event.preventDefault();
+    }
+    if (options.stopPropagation) {
+      event.stopPropagation();
+    }
+  };
+  let longPressCleanup = null;
+  const handleStart = (e) => {
+    const touch = getTouchCoordinates(e);
+    const touchCount = "touches" in e ? e.touches.length : 1;
+    state.active = true;
+    state.startTime = Date.now();
+    state.startX = state.lastX = state.currentX = touch.clientX;
+    state.startY = state.lastY = state.currentY = touch.clientY;
+    state.touchCount = touchCount;
+    state.target = e.target;
+    if (touchCount === 2 && "touches" in e) {
+      const touch1 = e.touches[0];
+      const touch2 = e.touches[1];
+      state.startDistance = Math.sqrt(Math.pow(touch2.clientX - touch1.clientX, 2) + Math.pow(touch2.clientY - touch1.clientY, 2));
+      state.startAngle = Math.atan2(touch2.clientY - touch1.clientY, touch2.clientX - touch1.clientX) * 180 / Math.PI;
+      if (state.startAngle < 0)
+        state.startAngle += 360;
+    }
+    const context = {
+      state,
+      options,
+      originalEvent: e
+    };
+    if (longPressCleanup) {
+      longPressCleanup();
+    }
+    longPressCleanup = detectLongPress(context, (longPressEvent) => {
+      dispatchGesture(longPressEvent);
+    });
+  };
+  const handleMove = (e) => {
+    if (!state.active)
+      return;
+    const touch = getTouchCoordinates(e);
+    const touchCount = "touches" in e ? e.touches.length : 1;
+    state.lastX = state.currentX;
+    state.lastY = state.currentY;
+    state.currentX = touch.clientX;
+    state.currentY = touch.clientY;
+    const context = {
+      state,
+      options,
+      originalEvent: e
+    };
+    if (shouldCancelLongPress(context) && longPressCleanup) {
+      longPressCleanup();
+      longPressCleanup = null;
+    }
+    const panEvent = detectPan(context);
+    if (panEvent) {
+      dispatchGesture(panEvent);
+    }
+    if (touchCount === 2 && "touches" in e) {
+      const touch1 = e.touches[0];
+      const touch2 = e.touches[1];
+      const pinchEvent = detectPinch(context, touch1, touch2);
+      if (pinchEvent) {
+        dispatchGesture(pinchEvent);
+      }
+      const rotateEvent = detectRotate(context, touch1, touch2);
+      if (rotateEvent) {
+        dispatchGesture(rotateEvent);
+      }
+    }
+  };
+  const handleEnd = (e) => {
+    if (!state.active)
+      return;
+    if (longPressCleanup) {
+      longPressCleanup();
+      longPressCleanup = null;
+    }
+    const context = {
+      state,
+      options,
+      originalEvent: e
+    };
+    const tapEvent = detectTap(context);
+    if (tapEvent) {
+      state.lastTapTime = Date.now();
+      state.tapCount = tapEvent.count;
+      dispatchGesture(tapEvent);
+    } else {
+      const swipeEvent = detectSwipe(context);
+      if (swipeEvent) {
+        dispatchGesture(swipeEvent);
+      }
+    }
+    state.active = false;
+  };
+  const handleCancel = () => {
+    if (longPressCleanup) {
+      longPressCleanup();
+      longPressCleanup = null;
+    }
+    state.active = false;
+  };
+  let eventListeners = {};
+  const setupEventListeners = () => {
+    if (supportPointer) {
+      eventListeners = {
+        pointerdown: handleStart,
+        pointermove: handleMove,
+        pointerup: handleEnd,
+        pointercancel: handleCancel
+      };
+    } else if (supportTouch) {
+      eventListeners = {
+        touchstart: handleStart,
+        touchmove: handleMove,
+        touchend: handleEnd,
+        touchcancel: handleCancel
+      };
+    } else {
+      eventListeners = {
+        mousedown: handleStart,
+        mousemove: handleMove,
+        mouseup: handleEnd,
+        mouseleave: handleCancel
+      };
+    }
+    Object.entries(eventListeners).forEach(([event, listener]) => {
+      element.addEventListener(event, listener, { passive: !options.preventDefault });
+    });
+  };
+  const removeEventListeners = () => {
+    Object.entries(eventListeners).forEach(([event, listener]) => {
+      element.removeEventListener(event, listener);
+    });
+    eventListeners = {};
+  };
+  setupEventListeners();
+  return {
+    on(eventType, handler) {
+      if (!handlers.has(eventType)) {
+        handlers.set(eventType, new Set);
+      }
+      handlers.get(eventType).add(handler);
+      return this;
+    },
+    off(eventType, handler) {
+      const eventHandlers = handlers.get(eventType);
+      if (eventHandlers) {
+        eventHandlers.delete(handler);
+        if (eventHandlers.size === 0) {
+          handlers.delete(eventType);
+        }
+      }
+      return this;
+    },
+    isSupported(gestureType) {
+      return gestureType in gestureSupport && gestureSupport[gestureType];
+    },
+    enable() {
+      setupEventListeners();
+      return this;
+    },
+    disable() {
+      removeEventListeners();
+      return this;
+    },
+    destroy() {
+      removeEventListeners();
+      if (longPressCleanup) {
+        longPressCleanup();
+        longPressCleanup = null;
+      }
+      handlers.clear();
+    }
+  };
+};
+
+//# debugId=34D8A19FC9E7DD6764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/core/gestures/types.ts", "../../../src/core/gestures/utils.ts", "../../../src/core/gestures/tap.ts", "../../../src/core/gestures/swipe.ts", "../../../src/core/gestures/longpress.ts", "../../../src/core/gestures/pan.ts", "../../../src/core/gestures/pinch.ts", "../../../src/core/gestures/rotate.ts", "../../../src/core/gestures/manager.ts"],
  "sourcesContent": [
    "// src/core/gestures/types.ts\n/**\n * @module core/gestures\n * @description Type definitions for the gesture system\n */\n\n/**\n * Types of gestures supported by the system\n */\nexport enum GESTURE_TYPES {\n  TAP = 'tap',\n  SWIPE = 'swipe',\n  SWIPE_LEFT = 'swipeleft',\n  SWIPE_RIGHT = 'swiperight',\n  SWIPE_UP = 'swipeup',\n  SWIPE_DOWN = 'swipedown',\n  PINCH = 'pinch',\n  ROTATE = 'rotate',\n  LONG_PRESS = 'longpress',\n  PAN = 'pan'\n}\n\n/**\n * Direction of swipe gestures\n */\nexport enum SWIPE_DIRECTIONS {\n  UP = 'up',\n  DOWN = 'down',\n  LEFT = 'left',\n  RIGHT = 'right'\n}\n\n/**\n * Configuration options for gesture recognition\n */\nexport interface GestureConfig {\n  /**\n   * Minimum distance (in pixels) to recognize a swipe\n   * @default 30\n   */\n  swipeThreshold?: number;\n  \n  /**\n   * Maximum time (in ms) in which a swipe must be completed\n   * @default 300\n   */\n  swipeTimeThreshold?: number;\n  \n  /**\n   * Time (in ms) to recognize a long press\n   * @default 500\n   */\n  longPressTime?: number;\n  \n  /**\n   * Distance threshold (in pixels) for tap recognition\n   * @default 10\n   */\n  tapDistanceThreshold?: number;\n  \n  /**\n   * Whether to prevent default behaviors on touch events\n   * @default true\n   */\n  preventDefault?: boolean;\n  \n  /**\n   * Whether to stop event propagation\n   * @default false\n   */\n  stopPropagation?: boolean;\n  \n  [key: string]: any;\n}\n\n/**\n * Base gesture event data\n */\nexport interface GestureEvent {\n  /**\n   * Type of the gesture\n   */\n  type: string;\n  \n  /**\n   * Original DOM event\n   */\n  originalEvent: Event;\n  \n  /**\n   * Element the gesture was triggered on\n   */\n  target: EventTarget;\n  \n  /**\n   * Timestamp when the gesture started\n   */\n  startTime: number;\n  \n  /**\n   * Timestamp when the gesture ended\n   */\n  endTime: number;\n  \n  /**\n   * Gesture duration in milliseconds\n   */\n  duration: number;\n  \n  /**\n   * Whether default behavior was prevented\n   */\n  defaultPrevented: boolean;\n  \n  /**\n   * Prevent default behavior\n   */\n  preventDefault: () => void;\n  \n  /**\n   * Stop event propagation\n   */\n  stopPropagation: () => void;\n}\n\n/**\n * Tap gesture event data\n */\nexport interface TapEvent extends GestureEvent {\n  type: 'tap';\n  \n  /**\n   * Number of taps (for double tap detection)\n   */\n  count: number;\n  \n  /**\n   * X position of the tap\n   */\n  x: number;\n  \n  /**\n   * Y position of the tap\n   */\n  y: number;\n}\n\n/**\n * Swipe gesture event data\n */\nexport interface SwipeEvent extends GestureEvent {\n  type: 'swipe' | 'swipeleft' | 'swiperight' | 'swipeup' | 'swipedown';\n  \n  /**\n   * Direction of the swipe\n   */\n  direction: 'up' | 'down' | 'left' | 'right';\n  \n  /**\n   * Distance swiped in the X direction\n   */\n  deltaX: number;\n  \n  /**\n   * Distance swiped in the Y direction\n   */\n  deltaY: number;\n  \n  /**\n   * Total distance swiped\n   */\n  distance: number;\n  \n  /**\n   * Velocity of the swipe in pixels per millisecond\n   */\n  velocity: number;\n  \n  /**\n   * Start X position\n   */\n  startX: number;\n  \n  /**\n   * Start Y position\n   */\n  startY: number;\n  \n  /**\n   * End X position\n   */\n  endX: number;\n  \n  /**\n   * End Y position\n   */\n  endY: number;\n}\n\n/**\n * Long press gesture event data\n */\nexport interface LongPressEvent extends GestureEvent {\n  type: 'longpress';\n  \n  /**\n   * X position of the long press\n   */\n  x: number;\n  \n  /**\n   * Y position of the long press\n   */\n  y: number;\n}\n\n/**\n * Pinch gesture event data\n */\nexport interface PinchEvent extends GestureEvent {\n  type: 'pinch';\n  \n  /**\n   * Scale factor of the pinch (>1 for zoom in, <1 for zoom out)\n   */\n  scale: number;\n  \n  /**\n   * Center X position of the pinch\n   */\n  centerX: number;\n  \n  /**\n   * Center Y position of the pinch\n   */\n  centerY: number;\n}\n\n/**\n * Rotate gesture event data\n */\nexport interface RotateEvent extends GestureEvent {\n  type: 'rotate';\n  \n  /**\n   * Rotation angle in degrees\n   */\n  rotation: number;\n  \n  /**\n   * Center X position of the rotation\n   */\n  centerX: number;\n  \n  /**\n   * Center Y position of the rotation\n   */\n  centerY: number;\n}\n\n/**\n * Pan gesture event data\n */\nexport interface PanEvent extends GestureEvent {\n  type: 'pan';\n  \n  /**\n   * Distance panned in the X direction\n   */\n  deltaX: number;\n  \n  /**\n   * Distance panned in the Y direction\n   */\n  deltaY: number;\n  \n  /**\n   * Start X position\n   */\n  startX: number;\n  \n  /**\n   * Start Y position\n   */\n  startY: number;\n  \n  /**\n   * Current X position\n   */\n  currentX: number;\n  \n  /**\n   * Current Y position\n   */\n  currentY: number;\n}\n\n/**\n * Union type of all gesture events\n */\nexport type AnyGestureEvent = \n  | TapEvent\n  | SwipeEvent \n  | LongPressEvent \n  | PinchEvent \n  | RotateEvent \n  | PanEvent;\n\n/**\n * Handler for gesture events\n */\nexport type GestureHandler = (event: AnyGestureEvent) => void;\n\n/**\n * Gesture state for tracking touch interactions\n */\nexport interface GestureState {\n  active: boolean;\n  startTime: number;\n  startX: number;\n  startY: number;\n  lastX: number;\n  lastY: number;\n  currentX: number;\n  currentY: number;\n  touchCount: number;\n  longPressTimer: number | null;\n  startDistance: number;\n  startAngle: number;\n  lastTapTime: number;\n  tapCount: number;\n  target: EventTarget | null;\n}\n\n/**\n * Context for gesture detection\n */\nexport interface GestureDetectionContext {\n  state: GestureState;\n  options: Required<GestureConfig>;\n  originalEvent: Event;\n}\n\n/**\n * Gesture manager interface\n */\nexport interface GestureManager {\n  /**\n   * Add an event listener for a gesture\n   * @param eventType - Gesture type\n   * @param handler - Event handler\n   * @returns Gesture manager for chaining\n   */\n  on: (eventType: string, handler: GestureHandler) => GestureManager;\n  \n  /**\n   * Remove an event listener for a gesture\n   * @param eventType - Gesture type\n   * @param handler - Event handler\n   * @returns Gesture manager for chaining\n   */\n  off: (eventType: string, handler: GestureHandler) => GestureManager;\n  \n  /**\n   * Check if a gesture is supported on the current device\n   * @param gestureType - Type of gesture to check\n   * @returns Whether the gesture is supported\n   */\n  isSupported: (gestureType: string) => boolean;\n  \n  /**\n   * Enable gesture recognition\n   * @returns Gesture manager for chaining\n   */\n  enable: () => GestureManager;\n  \n  /**\n   * Disable gesture recognition\n   * @returns Gesture manager for chaining\n   */\n  disable: () => GestureManager;\n  \n  /**\n   * Clean up event listeners\n   */\n  destroy: () => void;\n}",
    "// src/core/gestures/utils.ts\n/**\n * @module core/gestures\n * @description Utility functions for gesture detection\n */\n\nimport { GestureEvent, GestureState } from \"./types\";\n\n/**\n * Calculate distance between two points\n *\n * @param x1 - X coordinate of first point\n * @param y1 - Y coordinate of first point\n * @param x2 - X coordinate of second point\n * @param y2 - Y coordinate of second point\n * @returns Distance between the points\n */\nexport function getDistance(\n  x1: number,\n  y1: number,\n  x2: number,\n  y2: number\n): number {\n  return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));\n}\n\n/**\n * Calculate angle between two points in degrees (0-360)\n *\n * @param x1 - X coordinate of first point\n * @param y1 - Y coordinate of first point\n * @param x2 - X coordinate of second point\n * @param y2 - Y coordinate of second point\n * @returns Angle in degrees\n */\nexport function getAngle(\n  x1: number,\n  y1: number,\n  x2: number,\n  y2: number\n): number {\n  const angle = (Math.atan2(y2 - y1, x2 - x1) * 180) / Math.PI;\n  return angle < 0 ? angle + 360 : angle;\n}\n\n/**\n * Create a base gesture event\n *\n * @param type - Type of gesture\n * @param originalEvent - Original DOM event\n * @param state - Current gesture state\n * @returns Base gesture event object\n */\nexport function createGestureEvent(\n  type: string,\n  originalEvent: Event,\n  state: GestureState\n): GestureEvent {\n  const endTime = Date.now();\n  let defaultPrevented = false;\n\n  const event: GestureEvent = {\n    type,\n    originalEvent,\n    target:\n      (state.target as EventTarget) || (originalEvent.target as EventTarget),\n    startTime: state.startTime,\n    endTime,\n    duration: endTime - state.startTime,\n    defaultPrevented,\n    preventDefault: () => {\n      defaultPrevented = true;\n      event.defaultPrevented = true;\n      if (originalEvent.cancelable) {\n        originalEvent.preventDefault();\n      }\n    },\n    stopPropagation: () => {\n      originalEvent.stopPropagation();\n    },\n  };\n\n  return event;\n}\n\n/**\n * Detect if the device supports touch events\n *\n * @returns Whether touch is supported\n */\nexport function hasTouchSupport(): boolean {\n  const maxPoints = (navigator as any).maxTouchPoints;\n  return (\n    \"ontouchstart\" in window || (typeof maxPoints === \"number\" && maxPoints > 0)\n  );\n}\n\n/**\n * Detect if the device supports pointer events\n *\n * @returns Whether pointer events are supported\n */\nexport function hasPointerSupport(): boolean {\n  return !!window.PointerEvent;\n}\n\n/**\n * Extract normalized touch coordinates from an event\n * Works with mouse events, touch events and pointer events\n *\n * @param e - DOM event\n * @returns Object with clientX and clientY coordinates\n */\nexport function getTouchCoordinates(\n  e: MouseEvent | TouchEvent | PointerEvent\n): { clientX: number; clientY: number } {\n  if (\"touches\" in e && Array.isArray(e.touches) && e.touches.length > 0) {\n    return {\n      clientX: e.touches[0].clientX,\n      clientY: e.touches[0].clientY,\n    };\n  }\n\n  return {\n    clientX: (e as MouseEvent | PointerEvent).clientX,\n    clientY: (e as MouseEvent | PointerEvent).clientY,\n  };\n}\n",
    "// src/core/gestures/tap.ts\n/**\n * @module core/gestures\n * @description Tap gesture detection\n */\n\nimport { TapEvent, GestureDetectionContext } from './types';\nimport { createGestureEvent } from './utils';\n\n/**\n * Detect tap gesture\n * \n * @param context - Gesture detection context\n * @returns Tap event or null if no tap detected\n */\nexport function detectTap(context: GestureDetectionContext): TapEvent | null {\n  const { state, options, originalEvent } = context;\n  \n  // Calculate distance between start and current position\n  const deltaX = state.currentX - state.startX;\n  const deltaY = state.currentY - state.startY;\n  const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n  \n  // Check if movement is within threshold\n  if (distance < options.tapDistanceThreshold) {\n    // Check for double tap\n    const now = Date.now();\n    const isDoubleTap = now - state.lastTapTime < 300;\n    \n    const tapCount = isDoubleTap ? state.tapCount + 1 : 1;\n    \n    // Create tap event\n    const tapEvent: TapEvent = {\n      ...createGestureEvent('tap', originalEvent, state),\n      type: 'tap',\n      count: tapCount,\n      x: state.currentX,\n      y: state.currentY\n    };\n    \n    return tapEvent;\n  }\n  \n  return null;\n}",
    "// src/core/gestures/swipe.ts\n/**\n * @module core/gestures\n * @description Swipe gesture detection\n */\n\nimport { SwipeEvent, GestureDetectionContext, SWIPE_DIRECTIONS } from './types';\nimport { createGestureEvent } from './utils';\n\n/**\n * Determine swipe direction based on delta X and Y\n * \n * @param deltaX - Distance moved in X direction\n * @param deltaY - Distance moved in Y direction\n * @returns Direction of the swipe\n */\nexport function getSwipeDirection(deltaX: number, deltaY: number): SWIPE_DIRECTIONS {\n  if (Math.abs(deltaX) > Math.abs(deltaY)) {\n    return deltaX > 0 ? SWIPE_DIRECTIONS.RIGHT : SWIPE_DIRECTIONS.LEFT;\n  }\n  return deltaY > 0 ? SWIPE_DIRECTIONS.DOWN : SWIPE_DIRECTIONS.UP;\n}\n\n/**\n * Detect swipe gesture\n * \n * @param context - Gesture detection context\n * @returns Swipe event or null if no swipe detected\n */\nexport function detectSwipe(context: GestureDetectionContext): SwipeEvent | null {\n  const { state, options, originalEvent } = context;\n  \n  // Calculate deltas and distance\n  const deltaX = state.currentX - state.startX;\n  const deltaY = state.currentY - state.startY;\n  const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n  \n  // Calculate time and velocity\n  const endTime = Date.now();\n  const deltaTime = endTime - state.startTime;\n  const velocity = distance / deltaTime;\n  \n  // Check if it's a swipe\n  if (distance >= options.swipeThreshold && deltaTime <= options.swipeTimeThreshold) {\n    const direction = getSwipeDirection(deltaX, deltaY);\n    \n    // Create swipe event\n    const swipeEvent: SwipeEvent = {\n      ...createGestureEvent('swipe', originalEvent, state),\n      type: 'swipe',\n      direction,\n      deltaX,\n      deltaY,\n      distance,\n      velocity,\n      startX: state.startX,\n      startY: state.startY,\n      endX: state.currentX,\n      endY: state.currentY\n    };\n    \n    return swipeEvent;\n  }\n  \n  return null;\n}",
    "// src/core/gestures/longpress.ts\n/**\n * @module core/gestures\n * @description Long press gesture detection\n */\n\nimport { LongPressEvent, GestureDetectionContext } from './types';\nimport { createGestureEvent } from './utils';\n\n/**\n * Detect long press gesture\n * \n * This is slightly different from other gesture detectors as it sets up a timer\n * and returns a callback function that will be triggered when the timer completes.\n * \n * @param context - Gesture detection context\n * @param callback - Function to call when long press is detected\n * @returns Cleanup function to cancel the long press detection\n */\nexport function detectLongPress(\n  context: GestureDetectionContext,\n  callback: (event: LongPressEvent) => void\n): () => void {\n  const { state, options, originalEvent } = context;\n  \n  // Set a timer for long press detection\n  const timer = window.setTimeout(() => {\n    // Only trigger if gesture is still active\n    if (state.active) {\n      // Check if movement is within threshold\n      const diffX = Math.abs(state.currentX - state.startX);\n      const diffY = Math.abs(state.currentY - state.startY);\n      \n      if (diffX < options.tapDistanceThreshold && diffY < options.tapDistanceThreshold) {\n        // Create long press event\n        const longPressEvent: LongPressEvent = {\n          ...createGestureEvent('longpress', originalEvent, state),\n          type: 'longpress',\n          x: state.currentX,\n          y: state.currentY\n        };\n        \n        // Trigger callback\n        callback(longPressEvent);\n      }\n    }\n  }, options.longPressTime);\n  \n  // Return cleanup function\n  return () => {\n    clearTimeout(timer);\n  };\n}\n\n/**\n * Check if movement would cancel a long press\n * \n * @param context - Gesture detection context\n * @returns Whether the long press should be canceled\n */\nexport function shouldCancelLongPress(context: GestureDetectionContext): boolean {\n  const { state, options } = context;\n  \n  const diffX = Math.abs(state.currentX - state.startX);\n  const diffY = Math.abs(state.currentY - state.startY);\n  \n  return diffX > options.tapDistanceThreshold || diffY > options.tapDistanceThreshold;\n}",
    "// src/core/gestures/pan.ts\n/**\n * @module core/gestures\n * @description Pan gesture detection\n */\n\nimport { PanEvent, GestureDetectionContext } from \"./types\";\nimport { createGestureEvent } from \"./utils\";\n\n/**\n * Detect pan gesture\n *\n * @param context - Gesture detection context\n * @returns Pan event or null if no significant movement\n */\nexport function detectPan(context: GestureDetectionContext): PanEvent | null {\n  const { state, originalEvent } = context;\n\n  // Calculate delta from start position\n  const deltaX = state.currentX - state.startX;\n  const deltaY = state.currentY - state.startY;\n\n  // Calculate delta from last position to determine if there's significant movement\n  const moveDeltaX = state.currentX - state.lastX;\n  const moveDeltaY = state.currentY - state.lastY;\n  const moveDelta = Math.sqrt(\n    moveDeltaX * moveDeltaX + moveDeltaY * moveDeltaY\n  );\n\n  // Check if movement is significant\n  if (moveDelta > 0) {\n    // Create pan event\n    const panEvent: PanEvent = {\n      ...createGestureEvent(\"pan\", originalEvent, state),\n      type: \"pan\",\n      deltaX,\n      deltaY,\n      startX: state.startX,\n      startY: state.startY,\n      currentX: state.currentX,\n      currentY: state.currentY,\n    };\n\n    return panEvent;\n  }\n\n  return null;\n}\n",
    "// src/core/gestures/pinch.ts\n/**\n * @module core/gestures\n * @description Pinch gesture detection\n */\n\nimport { PinchEvent, GestureDetectionContext } from \"./types\";\nimport { createGestureEvent, getDistance } from \"./utils\";\n\n/**\n * Detect pinch gesture\n *\n * @param context - Gesture detection context\n * @param touch1 - First touch point\n * @param touch2 - Second touch point\n * @returns Pinch event or null if no pinch detected\n */\nexport function detectPinch(\n  context: GestureDetectionContext,\n  touch1: Touch,\n  touch2: Touch\n): PinchEvent | null {\n  const { state, originalEvent } = context;\n\n  // Calculate current distance between touch points\n  const currentDistance = getDistance(\n    touch1.clientX,\n    touch1.clientY,\n    touch2.clientX,\n    touch2.clientY\n  );\n\n  // Minimum movement threshold for pinch detection\n  const PINCH_THRESHOLD = 10;\n\n  // Check if the distance change is significant\n  if (Math.abs(currentDistance - state.startDistance) > PINCH_THRESHOLD) {\n    // Calculate scale factor\n    const scale = currentDistance / state.startDistance;\n\n    // Calculate center point\n    const centerX = (touch1.clientX + touch2.clientX) / 2;\n    const centerY = (touch1.clientY + touch2.clientY) / 2;\n\n    // Create pinch event\n    const pinchEvent: PinchEvent = {\n      ...createGestureEvent(\"pinch\", originalEvent, state),\n      type: \"pinch\",\n      scale,\n      centerX,\n      centerY,\n    };\n\n    return pinchEvent;\n  }\n\n  return null;\n}\n",
    "// src/core/gestures/rotate.ts\n/**\n * @module core/gestures\n * @description Rotate gesture detection\n */\n\nimport { RotateEvent, GestureDetectionContext } from \"./types\";\nimport { createGestureEvent, getAngle } from \"./utils\";\n\n/**\n * Detect rotate gesture\n *\n * @param context - Gesture detection context\n * @param touch1 - First touch point\n * @param touch2 - Second touch point\n * @returns Rotate event or null if no rotation detected\n */\nexport function detectRotate(\n  context: GestureDetectionContext,\n  touch1: Touch,\n  touch2: Touch\n): RotateEvent | null {\n  const { state, originalEvent } = context;\n\n  // Calculate current angle between touch points\n  const currentAngle = getAngle(\n    touch1.clientX,\n    touch1.clientY,\n    touch2.clientX,\n    touch2.clientY\n  );\n\n  // Minimum rotation threshold for detection\n  const ROTATION_THRESHOLD = 10;\n\n  // Calculate rotation difference\n  const rotationDiff = currentAngle - state.startAngle;\n\n  // Check if rotation is significant\n  if (Math.abs(rotationDiff) > ROTATION_THRESHOLD) {\n    // Calculate center point\n    const centerX = (touch1.clientX + touch2.clientX) / 2;\n    const centerY = (touch1.clientY + touch2.clientY) / 2;\n\n    // Create rotate event\n    const rotateEvent: RotateEvent = {\n      ...createGestureEvent(\"rotate\", originalEvent, state),\n      type: \"rotate\",\n      rotation: rotationDiff,\n      centerX,\n      centerY,\n    };\n\n    return rotateEvent;\n  }\n\n  return null;\n}\n",
    "// src/core/gestures/manager.ts\n/**\n * @module core/gestures\n * @description Gesture management system for handling touch and mouse interactions\n */\n\nimport { \n  GestureConfig,\n  GestureManager,\n  GestureState,\n  GestureHandler,\n  GestureDetectionContext,\n  AnyGestureEvent,\n  GESTURE_TYPES,\n  SWIPE_DIRECTIONS\n} from './types';\n\nimport { detectTap } from './tap';\nimport { detectSwipe } from './swipe';\nimport { detectLongPress, shouldCancelLongPress } from './longpress';\nimport { detectPan } from './pan';\nimport { detectPinch } from './pinch';\nimport { detectRotate } from './rotate';\nimport { hasTouchSupport, hasPointerSupport, getTouchCoordinates } from './utils';\n\n// Re-export types and constants\nexport { GESTURE_TYPES, SWIPE_DIRECTIONS };\n\n/**\n * Creates a gesture manager for handling touch and mouse interactions\n * \n * @param element - DOM element to attach gesture recognition to\n * @param config - Configuration options\n * @returns Gesture manager instance\n */\nexport const createGestureManager = (\n  element: HTMLElement,\n  config: GestureConfig = {}\n): GestureManager => {\n  // Default configuration\n  const options: Required<GestureConfig> = {\n    swipeThreshold: 30,\n    swipeTimeThreshold: 300,\n    longPressTime: 500,\n    tapDistanceThreshold: 10,\n    preventDefault: true,\n    stopPropagation: false,\n    ...config\n  };\n  \n  // Event handlers storage\n  const handlers: Map<string, Set<GestureHandler>> = new Map();\n  \n  // Gesture state\n  const state: GestureState = {\n    active: false,\n    startTime: 0,\n    startX: 0,\n    startY: 0,\n    lastX: 0,\n    lastY: 0,\n    currentX: 0,\n    currentY: 0,\n    touchCount: 0,\n    longPressTimer: null,\n    startDistance: 0,\n    startAngle: 0,\n    lastTapTime: 0,\n    tapCount: 0,\n    target: null\n  };\n  \n  // Detect feature support\n  const supportTouch = hasTouchSupport();\n  const supportPointer = hasPointerSupport();\n    \n  const gestureSupport = {\n    tap: true,\n    swipe: true,\n    swipeleft: true,\n    swiperight: true,\n    swipeup: true,\n    swipedown: true,\n    longpress: true,\n    pan: true,\n    pinch: supportTouch || supportPointer,\n    rotate: supportTouch || supportPointer\n  };\n  \n  /**\n   * Dispatch a gesture event\n   */\n  const dispatchGesture = (event: AnyGestureEvent): void => {\n    // Get handlers for this event type\n    const eventHandlers = handlers.get(event.type);\n    if (!eventHandlers) return;\n    \n    // Call each handler\n    eventHandlers.forEach(handler => {\n      try {\n        handler(event);\n      } catch (error) {\n        console.error(`Error in gesture handler for ${event.type}:`, error);\n      }\n    });\n    \n    // For swipe, also dispatch direction-specific events\n    if (event.type === 'swipe' && 'direction' in event) {\n      const directionEvent = { ...event, type: `swipe${event.direction}` as any };\n      dispatchGesture(directionEvent as any);\n    }\n    \n    // Apply default configuration for preventDefault and stopPropagation\n    if (options.preventDefault && !event.defaultPrevented) {\n      event.preventDefault();\n    }\n    \n    if (options.stopPropagation) {\n      event.stopPropagation();\n    }\n  };\n  \n  // Reference to the longpress cleanup function\n  let longPressCleanup: (() => void) | null = null;\n  \n  /**\n   * Handle touch/mouse start\n   */\n  const handleStart = (e: TouchEvent | MouseEvent | PointerEvent): void => {\n    const touch = getTouchCoordinates(e);\n    const touchCount = 'touches' in e ? e.touches.length : 1;\n    \n    // Store gesture state\n    state.active = true;\n    state.startTime = Date.now();\n    state.startX = state.lastX = state.currentX = touch.clientX;\n    state.startY = state.lastY = state.currentY = touch.clientY;\n    state.touchCount = touchCount;\n    state.target = e.target;\n    \n    // Handle multi-touch gestures\n    if (touchCount === 2 && 'touches' in e) {\n      const touch1 = e.touches[0];\n      const touch2 = e.touches[1];\n      \n      // Set initial values for pinch and rotate\n      state.startDistance = Math.sqrt(\n        Math.pow(touch2.clientX - touch1.clientX, 2) + \n        Math.pow(touch2.clientY - touch1.clientY, 2)\n      );\n      \n      state.startAngle = Math.atan2(\n        touch2.clientY - touch1.clientY,\n        touch2.clientX - touch1.clientX\n      ) * 180 / Math.PI;\n      \n      if (state.startAngle < 0) state.startAngle += 360;\n    }\n    \n    // Setup context for gesture detection\n    const context: GestureDetectionContext = {\n      state,\n      options,\n      originalEvent: e\n    };\n    \n    // Start long press detection\n    if (longPressCleanup) {\n      longPressCleanup();\n    }\n    \n    longPressCleanup = detectLongPress(context, (longPressEvent) => {\n      dispatchGesture(longPressEvent);\n    });\n  };\n  \n  /**\n   * Handle touch/mouse move\n   */\n  const handleMove = (e: TouchEvent | MouseEvent | PointerEvent): void => {\n    if (!state.active) return;\n    \n    const touch = getTouchCoordinates(e);\n    const touchCount = 'touches' in e ? e.touches.length : 1;\n    \n    // Update positions\n    state.lastX = state.currentX;\n    state.lastY = state.currentY;\n    state.currentX = touch.clientX;\n    state.currentY = touch.clientY;\n    \n    // Setup context for gesture detection\n    const context: GestureDetectionContext = {\n      state,\n      options,\n      originalEvent: e\n    };\n    \n    // Check if we should cancel longpress\n    if (shouldCancelLongPress(context) && longPressCleanup) {\n      longPressCleanup();\n      longPressCleanup = null;\n    }\n    \n    // Detect pan gesture\n    const panEvent = detectPan(context);\n    if (panEvent) {\n      dispatchGesture(panEvent);\n    }\n    \n    // Multi-touch gestures\n    if (touchCount === 2 && 'touches' in e) {\n      const touch1 = e.touches[0];\n      const touch2 = e.touches[1];\n      \n      // Detect pinch\n      const pinchEvent = detectPinch(context, touch1, touch2);\n      if (pinchEvent) {\n        dispatchGesture(pinchEvent);\n      }\n      \n      // Detect rotate\n      const rotateEvent = detectRotate(context, touch1, touch2);\n      if (rotateEvent) {\n        dispatchGesture(rotateEvent);\n      }\n    }\n  };\n  \n  /**\n   * Handle touch/mouse end\n   */\n  const handleEnd = (e: TouchEvent | MouseEvent | PointerEvent): void => {\n    if (!state.active) return;\n    \n    // Cancel any ongoing long press detection\n    if (longPressCleanup) {\n      longPressCleanup();\n      longPressCleanup = null;\n    }\n    \n    // Setup context for gesture detection\n    const context: GestureDetectionContext = {\n      state,\n      options,\n      originalEvent: e\n    };\n    \n    // Detect tap\n    const tapEvent = detectTap(context);\n    if (tapEvent) {\n      // Update tap count for next tap\n      state.lastTapTime = Date.now();\n      state.tapCount = tapEvent.count;\n      \n      dispatchGesture(tapEvent);\n    } else {\n      // Detect swipe\n      const swipeEvent = detectSwipe(context);\n      if (swipeEvent) {\n        dispatchGesture(swipeEvent);\n      }\n    }\n    \n    // Reset state\n    state.active = false;\n  };\n  \n  /**\n   * Handle touch/mouse cancel\n   */\n  const handleCancel = (): void => {\n    // Cancel long press detection\n    if (longPressCleanup) {\n      longPressCleanup();\n      longPressCleanup = null;\n    }\n    \n    // Reset state\n    state.active = false;\n  };\n  \n  // Event listener references\n  let eventListeners: { \n    [event: string]: EventListener \n  } = {};\n  \n  /**\n   * Set up event listeners based on available APIs\n   */\n  const setupEventListeners = (): void => {\n    if (supportPointer) {\n      // Use Pointer Events API\n      eventListeners = {\n        pointerdown: handleStart as EventListener,\n        pointermove: handleMove as EventListener,\n        pointerup: handleEnd as EventListener,\n        pointercancel: handleCancel as EventListener\n      };\n    } else if (supportTouch) {\n      // Use Touch Events API\n      eventListeners = {\n        touchstart: handleStart as EventListener,\n        touchmove: handleMove as EventListener,\n        touchend: handleEnd as EventListener,\n        touchcancel: handleCancel as EventListener\n      };\n    } else {\n      // Fall back to Mouse Events API\n      eventListeners = {\n        mousedown: handleStart as EventListener,\n        mousemove: handleMove as EventListener,\n        mouseup: handleEnd as EventListener,\n        mouseleave: handleCancel as EventListener\n      };\n    }\n    \n    // Add listeners to element\n    Object.entries(eventListeners).forEach(([event, listener]) => {\n      element.addEventListener(event, listener, { passive: !options.preventDefault });\n    });\n  };\n  \n  /**\n   * Remove all event listeners\n   */\n  const removeEventListeners = (): void => {\n    // Remove all listeners from element\n    Object.entries(eventListeners).forEach(([event, listener]) => {\n      element.removeEventListener(event, listener);\n    });\n    \n    // Clear eventListeners object\n    eventListeners = {};\n  };\n  \n  // Initialize event listeners\n  setupEventListeners();\n  \n  return {\n    /**\n     * Add a gesture event listener\n     * @param eventType - Type of gesture to listen for\n     * @param handler - Event handler function\n     * @returns Gesture manager for chaining\n     */\n    on(eventType: string, handler: GestureHandler): GestureManager {\n      if (!handlers.has(eventType)) {\n        handlers.set(eventType, new Set());\n      }\n      \n      handlers.get(eventType)!.add(handler);\n      return this;\n    },\n    \n    /**\n     * Remove a gesture event listener\n     * @param eventType - Type of gesture\n     * @param handler - Event handler to remove\n     * @returns Gesture manager for chaining\n     */\n    off(eventType: string, handler: GestureHandler): GestureManager {\n      const eventHandlers = handlers.get(eventType);\n      if (eventHandlers) {\n        eventHandlers.delete(handler);\n        \n        if (eventHandlers.size === 0) {\n          handlers.delete(eventType);\n        }\n      }\n      return this;\n    },\n    \n    /**\n     * Check if a gesture is supported on the current device\n     * @param gestureType - Type of gesture to check\n     * @returns Whether the gesture is supported\n     */\n    isSupported(gestureType: string): boolean {\n      return gestureType in gestureSupport && gestureSupport[gestureType as keyof typeof gestureSupport];\n    },\n    \n    /**\n     * Enable gesture recognition by adding event listeners\n     * @returns Gesture manager for chaining\n     */\n    enable(): GestureManager {\n      setupEventListeners();\n      return this;\n    },\n    \n    /**\n     * Disable gesture recognition by removing event listeners\n     * @returns Gesture manager for chaining\n     */\n    disable(): GestureManager {\n      removeEventListeners();\n      return this;\n    },\n    \n    /**\n     * Clean up event listeners and timers\n     */\n    destroy(): void {\n      // Clean up listeners\n      removeEventListeners();\n      \n      // Clear long press timer\n      if (longPressCleanup) {\n        longPressCleanup();\n        longPressCleanup = null;\n      }\n      \n      // Clear handler references\n      handlers.clear();\n    }\n  };\n};"
  ],
  "mappings": "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",
  "debugId": "34D8A19FC9E7DD6764756E2164756E21",
  "names": []
}