aura-glass 2.0.39 → 2.1.0

package/dist/esm/animations/physics/galileoPhysicsSystem.js

@@ -0,0 +1,407 @@
+import { useRef, useEffect } from 'react';
+
+class GalileoPhysicsSystem {
+  constructor(config = {}) {
+    this.animationFrame = null;
+    this.lastTime = 0;
+    this.paused = false;
+    this.animate = () => {
+      const currentTime = performance.now();
+      const deltaTime = Math.min((currentTime - this.lastTime) / 1000, 1 / 30); // Cap at 30 FPS minimum
+      if (!this.paused) {
+        for (let i = 0; i < this.world.substeps; i++) {
+          this.step(deltaTime / this.world.substeps);
+        }
+      }
+      this.lastTime = currentTime;
+      this.animationFrame = requestAnimationFrame(this.animate);
+    };
+    this.world = {
+      bodies: new Map(),
+      gravity: {
+        x: 0,
+        y: 0
+      },
+      bounds: {
+        left: -Infinity,
+        right: Infinity,
+        top: -Infinity,
+        bottom: Infinity
+      },
+      timeStep: 1 / 60,
+      // 60 FPS
+      substeps: 1,
+      ...config
+    };
+  }
+  // Body management
+  addBody(body) {
+    this.world.bodies.set(body.id, body);
+  }
+  removeBody(id) {
+    this.world.bodies.delete(id);
+  }
+  getBody(id) {
+    return this.world.bodies.get(id);
+  }
+  updateBody(id, updates) {
+    const body = this.world.bodies.get(id);
+    if (body) {
+      Object.assign(body, updates);
+    }
+  }
+  // Force management
+  applyForce(id, force, duration) {
+    const body = this.world.bodies.get(id);
+    if (body) {
+      body.forces.push({
+        ...force,
+        duration
+      });
+    }
+  }
+  applyImpulse(id, impulse) {
+    const body = this.world.bodies.get(id);
+    if (body && !body.fixed) {
+      body.velocity.x += impulse.x / body.mass;
+      body.velocity.y += impulse.y / body.mass;
+    }
+  }
+  // Physics simulation
+  start() {
+    if (this.animationFrame) return;
+    this.lastTime = performance.now();
+    if (this.animate) this.animate();
+  }
+  stop() {
+    if (this.animationFrame) {
+      cancelAnimationFrame(this.animationFrame);
+      this.animationFrame = null;
+    }
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+    this.lastTime = performance.now();
+  }
+  step(deltaTime) {
+    // Update forces
+    this.updateForces(deltaTime);
+    // Integrate motion
+    this.integrateMotion(deltaTime);
+    // Handle collisions
+    this.handleCollisions();
+    // Apply constraints
+    this.applyConstraints();
+  }
+  updateForces(deltaTime) {
+    this.world.bodies.forEach(body => {
+      if (body.fixed) return;
+      // Reset acceleration
+      body.acceleration.x = 0;
+      body.acceleration.y = 0;
+      // Apply gravity
+      body.acceleration.x += this.world.gravity.x;
+      body.acceleration.y += this.world.gravity.y;
+      // Apply custom forces
+      body.forces = body.forces.filter(force => {
+        body.acceleration.x += force.x / body.mass;
+        body.acceleration.y += force.y / body.mass;
+        if (force.duration !== undefined) {
+          force.duration -= deltaTime;
+          return force.duration > 0;
+        }
+        return true; // Permanent forces
+      });
+      // Apply friction
+      const speed = Math.sqrt(body.velocity.x ** 2 + body.velocity.y ** 2);
+      if (speed > 0.001) {
+        const frictionForce = body.friction * body.mass * Math.abs(this.world.gravity.y || 1);
+        const frictionX = -body.velocity.x / speed * frictionForce / body.mass;
+        const frictionY = -body.velocity.y / speed * frictionForce / body.mass;
+        body.acceleration.x += frictionX;
+        body.acceleration.y += frictionY;
+      }
+    });
+  }
+  integrateMotion(deltaTime) {
+    this.world.bodies.forEach(body => {
+      if (body.fixed) return;
+      // Verlet integration for better stability
+      const newVelocityX = body.velocity.x + body.acceleration.x * deltaTime;
+      const newVelocityY = body.velocity.y + body.acceleration.y * deltaTime;
+      body.position.x += (body.velocity.x + newVelocityX) * 0.5 * deltaTime;
+      body.position.y += (body.velocity.y + newVelocityY) * 0.5 * deltaTime;
+      body.velocity.x = newVelocityX;
+      body.velocity.y = newVelocityY;
+    });
+  }
+  handleCollisions() {
+    const bodies = Array.from(this.world.bodies.values());
+    const collisions = [];
+    // Check all pairs for collisions
+    for (let i = 0; i < bodies.length; i++) {
+      for (let j = i + 1; j < bodies.length; j++) {
+        const collision = this.checkCollision(bodies[i], bodies[j]);
+        if (collision) {
+          collisions.push(collision);
+        }
+      }
+    }
+    // Resolve collisions
+    collisions.forEach(collision => {
+      this.resolveCollision(collision);
+    });
+  }
+  checkCollision(bodyA, bodyB) {
+    const dx = bodyB.position.x - bodyA.position.x;
+    const dy = bodyB.position.y - bodyA.position.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const minDistance = bodyA.radius + bodyB.radius;
+    if (distance < minDistance) {
+      const penetration = minDistance - distance;
+      const normal = {
+        x: dx / distance,
+        y: dy / distance
+      };
+      return {
+        bodyA,
+        bodyB,
+        normal,
+        penetration,
+        contactPoint: {
+          x: bodyA.position.x + normal.x * bodyA.radius,
+          y: bodyA.position.y + normal.y * bodyA.radius
+        }
+      };
+    }
+    return null;
+  }
+  resolveCollision(collision) {
+    const {
+      bodyA,
+      bodyB,
+      normal,
+      penetration
+    } = collision;
+    // Separate bodies
+    const separationX = normal.x * penetration * 0.5;
+    const separationY = normal.y * penetration * 0.5;
+    if (!bodyA.fixed) {
+      bodyA.position.x -= separationX;
+      bodyA.position.y -= separationY;
+    }
+    if (!bodyB.fixed) {
+      bodyB.position.x += separationX;
+      bodyB.position.y += separationY;
+    }
+    // Calculate relative velocity
+    const relativeVelocityX = bodyB.velocity.x - bodyA.velocity.x;
+    const relativeVelocityY = bodyB.velocity.y - bodyA.velocity.y;
+    const velocityAlongNormal = relativeVelocityX * normal.x + relativeVelocityY * normal.y;
+    // Don't resolve if velocities are separating
+    if (velocityAlongNormal > 0) return;
+    // Calculate restitution
+    const restitution = Math.min(bodyA.restitution, bodyB.restitution);
+    // Calculate impulse scalar
+    const impulseScalar = -(1 + restitution) * velocityAlongNormal;
+    const totalMass = bodyA.mass + bodyB.mass;
+    let impulseX = impulseScalar * normal.x;
+    let impulseY = impulseScalar * normal.y;
+    // Apply mass weighting
+    if (!bodyA.fixed && !bodyB.fixed) {
+      impulseX /= totalMass / bodyA.mass;
+      impulseY /= totalMass / bodyA.mass;
+    }
+    // Apply impulses
+    if (!bodyA.fixed) {
+      bodyA.velocity.x -= impulseX / bodyA.mass;
+      bodyA.velocity.y -= impulseY / bodyA.mass;
+    }
+    if (!bodyB.fixed) {
+      bodyB.velocity.x += impulseX / bodyB.mass;
+      bodyB.velocity.y += impulseY / bodyB.mass;
+    }
+  }
+  applyConstraints() {
+    this.world.bodies.forEach(body => {
+      if (body.fixed) return;
+      // Boundary constraints
+      const {
+        bounds
+      } = this.world;
+      if (body.position.x - body.radius < bounds.left) {
+        body.position.x = bounds.left + body.radius;
+        body.velocity.x *= -body.restitution;
+      }
+      if (body.position.x + body.radius > bounds.right) {
+        body.position.x = bounds.right - body.radius;
+        body.velocity.x *= -body.restitution;
+      }
+      if (body.position.y - body.radius < bounds.top) {
+        body.position.y = bounds.top + body.radius;
+        body.velocity.y *= -body.restitution;
+      }
+      if (body.position.y + body.radius > bounds.bottom) {
+        body.position.y = bounds.bottom - body.radius;
+        body.velocity.y *= -body.restitution;
+      }
+    });
+  }
+  // Utility methods
+  setGravity(gravity) {
+    this.world.gravity = gravity;
+  }
+  setBounds(bounds) {
+    this.world.bounds = {
+      ...this.world.bounds,
+      ...bounds
+    };
+  }
+  getAllBodies() {
+    return Array.from(this.world.bodies.values());
+  }
+  clear() {
+    this.world.bodies.clear();
+  }
+  // Factory methods for common body types
+  static createCircleBody(id, x, y, radius, mass = 1, options = {}) {
+    return {
+      id,
+      position: {
+        x,
+        y
+      },
+      velocity: {
+        x: 0,
+        y: 0
+      },
+      acceleration: {
+        x: 0,
+        y: 0
+      },
+      mass,
+      radius,
+      friction: 0.1,
+      restitution: 0.8,
+      fixed: false,
+      forces: [],
+      ...options
+    };
+  }
+  static createFixedBody(id, x, y, radius) {
+    return {
+      id,
+      position: {
+        x,
+        y
+      },
+      velocity: {
+        x: 0,
+        y: 0
+      },
+      acceleration: {
+        x: 0,
+        y: 0
+      },
+      mass: Infinity,
+      radius,
+      friction: 0,
+      restitution: 1,
+      fixed: true,
+      forces: []
+    };
+  }
+}
+// Hook for using physics system
+function usePhysicsSystem(config) {
+  const systemRef = useRef();
+  useEffect(() => {
+    systemRef.current = new GalileoPhysicsSystem(config);
+    return () => {
+      systemRef.current?.stop();
+    };
+  }, []);
+  return systemRef.current;
+}
+// Spring physics utilities
+class SpringPhysics {
+  static calculateSpringForce(current, target, velocity, config) {
+    const displacement = target - current;
+    const springForce = displacement * (config.stiffness ?? 100);
+    const dampingForce = -velocity * (config.damping ?? 10);
+    const totalForce = springForce + dampingForce;
+    const acceleration = totalForce / (config.mass ?? 1);
+    const newVelocity = velocity + acceleration * 0.016; // Assuming 60fps
+    return {
+      force: totalForce,
+      newVelocity
+    };
+  }
+  static interpolateSpring(from, to, progress, config) {
+    // Simplified spring interpolation
+    const t = progress;
+    const stiffness = config.stiffness || 100;
+    const damping = config.damping || 10;
+    // Critically damped spring
+    const omega = Math.sqrt(stiffness);
+    const zeta = damping / (2 * Math.sqrt(stiffness));
+    if (zeta >= 1) {
+      // Over-damped
+      const r1 = -omega * (zeta - Math.sqrt(zeta * zeta - 1));
+      const r2 = -omega * (zeta + Math.sqrt(zeta * zeta - 1));
+      return to + (from - to) * (r1 * Math.exp(r1 * t) - r2 * Math.exp(r2 * t)) / (r1 - r2);
+    } else {
+      // Under-damped
+      const alpha = omega * Math.sqrt(1 - zeta * zeta);
+      const beta = omega * zeta;
+      return to + (from - to) * Math.exp(-beta * t) * Math.cos(alpha * t);
+    }
+  }
+}
+// Advanced physics utilities
+const physicsUtils = {
+  // Calculate trajectory
+  calculateTrajectory: (initialPosition, initialVelocity, gravity, time) => {
+    return {
+      x: initialPosition.x + initialVelocity.x * time + 0.5 * gravity.x * time * time,
+      y: initialPosition.y + initialVelocity.y * time + 0.5 * gravity.y * time * time
+    };
+  },
+  // Calculate collision point
+  calculateCollisionPoint: (bodyA, bodyB) => {
+    const dx = bodyB.position.x - bodyA.position.x;
+    const dy = bodyB.position.y - bodyA.position.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance < bodyA.radius + bodyB.radius) {
+      const overlap = bodyA.radius + bodyB.radius - distance;
+      return {
+        x: bodyA.position.x + dx / distance * (bodyA.radius - overlap / 2),
+        y: bodyA.position.y + dy / distance * (bodyA.radius - overlap / 2)
+      };
+    }
+    return null;
+  },
+  // Apply explosion force
+  applyExplosion: (bodies, center, force, radius) => {
+    bodies.forEach(body => {
+      const dx = body.position.x - center.x;
+      const dy = body.position.y - center.y;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      if (distance < radius && distance > 0) {
+        const strength = (1 - distance / radius) * force;
+        const impulse = {
+          x: dx / distance * strength / body.mass,
+          y: dy / distance * strength / body.mass
+        };
+        body.velocity.x += impulse.x;
+        body.velocity.y += impulse.y;
+      }
+    });
+  }
+};
+
+export { GalileoPhysicsSystem, SpringPhysics, physicsUtils, usePhysicsSystem };
+//# sourceMappingURL=galileoPhysicsSystem.js.map

package/dist/esm/animations/physics/galileoPhysicsSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"galileoPhysicsSystem.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/animations/physics/gesturePhysics.js

@@ -0,0 +1,285 @@
+import { useRef, useState, useCallback, useEffect } from 'react';
+import { createVector2D } from '../../types/common.js';
+
+/**
+ * Gesture Physics System
+ * Provides physics-based gesture interactions with preset configurations
+ */
+/**
+ * Gesture types supported by the physics system
+ */
+var GestureType;
+(function (GestureType) {
+  GestureType["TAP"] = "tap";
+  GestureType["DOUBLE_TAP"] = "double_tap";
+  GestureType["LONG_PRESS"] = "long_press";
+  GestureType["PAN"] = "pan";
+  GestureType["SWIPE"] = "swipe";
+  GestureType["PINCH"] = "pinch";
+  GestureType["ROTATE"] = "rotate";
+  GestureType["HOVER"] = "hover";
+})(GestureType || (GestureType = {}));
+/**
+ * Predefined gesture physics presets
+ */
+const GESTURE_PRESETS = {
+  smooth: {
+    name: 'smooth',
+    damping: 26,
+    stiffness: 170,
+    mass: 1,
+    velocity: 0,
+    restDelta: 0.01,
+    restSpeed: 0.01,
+    gestures: [GestureType.PAN, GestureType.HOVER]
+  },
+  snappy: {
+    name: 'snappy',
+    damping: 20,
+    stiffness: 300,
+    mass: 0.5,
+    velocity: 0,
+    restDelta: 0.001,
+    restSpeed: 0.001,
+    gestures: [GestureType.TAP, GestureType.DOUBLE_TAP]
+  },
+  bouncy: {
+    name: 'bouncy',
+    damping: 15,
+    stiffness: 400,
+    mass: 1.5,
+    velocity: 0,
+    restDelta: 0.05,
+    restSpeed: 0.05,
+    gestures: [GestureType.SWIPE, GestureType.PAN]
+  },
+  gentle: {
+    name: 'gentle',
+    damping: 30,
+    stiffness: 120,
+    mass: 1.2,
+    velocity: 0,
+    restDelta: 0.01,
+    restSpeed: 0.01,
+    gestures: [GestureType.HOVER, GestureType.LONG_PRESS]
+  },
+  precise: {
+    name: 'precise',
+    damping: 40,
+    stiffness: 500,
+    mass: 0.8,
+    velocity: 0,
+    restDelta: 0.0001,
+    restSpeed: 0.0001,
+    gestures: [GestureType.PINCH, GestureType.ROTATE]
+  }
+};
+/**
+ * Hook for gesture-based physics interactions
+ */
+const useGesturePhysics = (options = {}) => {
+  const {
+    preset = 'smooth',
+    enabledGestures = Object.values(GestureType),
+    onGesture,
+    onGestureStart,
+    onGestureEnd,
+    threshold = 10,
+    velocityThreshold = 100,
+    longPressDelay = 500
+  } = options;
+  const gestureState = useRef({
+    active: false,
+    gestureType: null,
+    startPosition: createVector2D(0, 0),
+    currentPosition: createVector2D(0, 0),
+    velocity: createVector2D(0, 0),
+    startTime: 0,
+    lastTime: 0
+  });
+  const longPressTimer = useRef(null);
+  const tapTimer = useRef(null);
+  const lastTapTime = useRef(0);
+  const [position, setPosition] = useState(createVector2D(0, 0));
+  const [isGestureActive, setIsGestureActive] = useState(false);
+  // Get preset configuration
+  const presetConfig = typeof preset === 'string' ? GESTURE_PRESETS[preset] : preset;
+  /**
+   * Create gesture event
+   */
+  const createGestureEvent = type => {
+    const state = gestureState.current;
+    const delta = {
+      x: state.currentPosition.x - state.startPosition.x,
+      y: state.currentPosition.y - state.startPosition.y
+    };
+    const distance = Math.sqrt(delta.x * delta.x + delta.y * delta.y);
+    const angle = Math.atan2(delta.y, delta.x);
+    return {
+      type,
+      position: state.currentPosition,
+      delta,
+      velocity: state.velocity,
+      distance,
+      angle,
+      scale: 1,
+      timestamp: Date.now()
+    };
+  };
+  /**
+   * Handle gesture start
+   */
+  const handleGestureStart = useCallback((clientX, clientY) => {
+    const state = gestureState.current;
+    const currentTime = Date.now();
+    state.active = true;
+    state.startPosition = createVector2D(clientX, clientY);
+    state.currentPosition = createVector2D(clientX, clientY);
+    state.velocity = createVector2D(0, 0);
+    state.startTime = currentTime;
+    state.lastTime = currentTime;
+    setIsGestureActive(true);
+    // Check for double tap
+    if (enabledGestures.includes(GestureType.DOUBLE_TAP)) {
+      if (currentTime - lastTapTime.current < 300) {
+        state.gestureType = GestureType.DOUBLE_TAP;
+        const event = createGestureEvent(GestureType.DOUBLE_TAP);
+        onGestureStart?.(event);
+        onGesture?.(event);
+        lastTapTime.current = 0;
+        return;
+      }
+      lastTapTime.current = currentTime;
+    }
+    // Start long press timer
+    if (enabledGestures.includes(GestureType.LONG_PRESS)) {
+      longPressTimer.current = setTimeout(() => {
+        if (state.active) {
+          state.gestureType = GestureType.LONG_PRESS;
+          const event = createGestureEvent(GestureType.LONG_PRESS);
+          onGestureStart?.(event);
+          onGesture?.(event);
+        }
+      }, longPressDelay);
+    }
+    state.gestureType = GestureType.TAP;
+    onGestureStart?.(createGestureEvent(GestureType.TAP));
+  }, [enabledGestures, onGestureStart, onGesture, longPressDelay]);
+  /**
+   * Handle gesture move
+   */
+  const handleGestureMove = useCallback((clientX, clientY) => {
+    const state = gestureState.current;
+    if (!state.active) return;
+    const currentTime = Date.now();
+    const dt = (currentTime - state.lastTime) / 1000;
+    const newPosition = createVector2D(clientX, clientY);
+    const delta = {
+      x: newPosition.x - state.currentPosition.x,
+      y: newPosition.y - state.currentPosition.y
+    };
+    // Calculate velocity
+    state.velocity = {
+      x: dt > 0 ? delta.x / dt : 0,
+      y: dt > 0 ? delta.y / dt : 0
+    };
+    state.currentPosition = newPosition;
+    state.lastTime = currentTime;
+    // Determine gesture type
+    const totalDistance = Math.sqrt(Math.pow(newPosition.x - state.startPosition.x, 2) + Math.pow(newPosition.y - state.startPosition.y, 2));
+    if (totalDistance > threshold) {
+      // Clear long press timer
+      if (longPressTimer.current) {
+        clearTimeout(longPressTimer.current);
+        longPressTimer.current = null;
+      }
+      const velocityMagnitude = Math.sqrt(state.velocity.x * state.velocity.x + state.velocity.y * state.velocity.y);
+      if (velocityMagnitude > velocityThreshold && enabledGestures.includes(GestureType.SWIPE)) {
+        state.gestureType = GestureType.SWIPE;
+      } else if (enabledGestures.includes(GestureType.PAN)) {
+        state.gestureType = GestureType.PAN;
+      }
+    }
+    setPosition(newPosition);
+    if (state.gestureType) {
+      onGesture?.(createGestureEvent(state.gestureType));
+    }
+  }, [enabledGestures, onGesture, threshold, velocityThreshold]);
+  /**
+   * Handle gesture end
+   */
+  const handleGestureEnd = useCallback(() => {
+    const state = gestureState.current;
+    if (!state.active) return;
+    // Clear timers
+    if (longPressTimer.current) {
+      clearTimeout(longPressTimer.current);
+      longPressTimer.current = null;
+    }
+    if (state.gestureType) {
+      onGestureEnd?.(createGestureEvent(state.gestureType));
+    }
+    state.active = false;
+    state.gestureType = null;
+    setIsGestureActive(false);
+  }, [onGestureEnd]);
+  /**
+   * Handlers for different input methods
+   */
+  const handlers = {
+    // Mouse events
+    onMouseDown: e => {
+      handleGestureStart(e.clientX, e.clientY);
+    },
+    onMouseMove: e => {
+      handleGestureMove(e.clientX, e.clientY);
+    },
+    onMouseUp: () => {
+      handleGestureEnd();
+    },
+    onMouseLeave: () => {
+      handleGestureEnd();
+    },
+    // Touch events
+    onTouchStart: e => {
+      const touch = e.touches[0];
+      if (touch) {
+        handleGestureStart(touch.clientX, touch.clientY);
+      }
+    },
+    onTouchMove: e => {
+      const touch = e.touches[0];
+      if (touch) {
+        handleGestureMove(touch.clientX, touch.clientY);
+      }
+    },
+    onTouchEnd: () => {
+      handleGestureEnd();
+    },
+    onTouchCancel: () => {
+      handleGestureEnd();
+    }
+  };
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (longPressTimer.current) {
+        clearTimeout(longPressTimer.current);
+      }
+      if (tapTimer.current) {
+        clearTimeout(tapTimer.current);
+      }
+    };
+  }, []);
+  return {
+    handlers,
+    position,
+    isActive: isGestureActive,
+    gestureType: gestureState.current.gestureType,
+    velocity: gestureState.current.velocity,
+    preset: presetConfig
+  };
+};
+
+export { GESTURE_PRESETS, GestureType, useGesturePhysics };
+//# sourceMappingURL=gesturePhysics.js.map

package/dist/esm/animations/physics/gesturePhysics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gesturePhysics.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}