@beautifi/plugin 0.1.0

package/dist/beautifi.esm.js

@@ -0,0 +1,1619 @@
+class LivePhotoError extends Error {
+  constructor(message, code, originalError) {
+    super(message);
+    this.code = code;
+    this.originalError = originalError;
+    this.name = "LivePhotoError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, LivePhotoError);
+    }
+  }
+}
+const DEFAULT_OPTIONS = {
+  endpoint: "https://us-central1-magic-mirror-427812.cloudfunctions.net/beautifi-animate/animate",
+  selector: "img",
+  intensity: "subtle",
+  type: "auto",
+  loop: true,
+  respectReducedMotion: true,
+  debug: false,
+  threshold: 0.1,
+  rootMargin: "50px",
+  timeout: 1e4,
+  maxRetries: 3,
+  mode: "auto",
+  videoEndpoint: "https://us-central1-magic-mirror-427812.cloudfunctions.net/beautifi-animate"
+};
+const DEFAULT_ANIMATION_CONFIG = {
+  enabled: true,
+  intensity: "subtle",
+  type: "auto",
+  loop: true,
+  delay: 0
+};
+function generateId() {
+  return `lmp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function parseDataAttributes(element) {
+  const enabled = element.dataset.live !== "false";
+  const intensityAttr = element.dataset.liveIntensity;
+  const intensity = intensityAttr === "subtle" || intensityAttr === "medium" || intensityAttr === "strong" ? intensityAttr : DEFAULT_ANIMATION_CONFIG.intensity;
+  const typeAttr = element.dataset.liveType;
+  const type = typeAttr === "breathing" || typeAttr === "parallax" || typeAttr === "sway" || typeAttr === "auto" ? typeAttr : DEFAULT_ANIMATION_CONFIG.type;
+  const loop = element.dataset.liveLoop !== "false";
+  const delay = parseInt(element.dataset.liveDelay || "0", 10) || 0;
+  return {
+    enabled,
+    intensity,
+    type,
+    loop,
+    delay
+  };
+}
+class ImageDetector {
+  constructor(selector = "img", debug = false) {
+    this.trackedImages = /* @__PURE__ */ new Map();
+    this.processedElements = /* @__PURE__ */ new WeakSet();
+    this.mutationObserver = null;
+    this.onImageDetected = null;
+    this.selector = selector;
+    this.debug = debug;
+  }
+  /**
+   * Set callback for when new images are detected
+   */
+  setOnImageDetected(callback) {
+    this.onImageDetected = callback;
+  }
+  /**
+   * Scan the DOM for images matching the selector
+   */
+  scan() {
+    const elements = document.querySelectorAll(this.selector);
+    const newImages = [];
+    elements.forEach((element) => {
+      if (this.processedElements.has(element)) {
+        return;
+      }
+      const config = parseDataAttributes(element);
+      if (!config.enabled) {
+        this.processedElements.add(element);
+        return;
+      }
+      const trackedImage = {
+        element,
+        id: generateId(),
+        state: "idle",
+        config
+      };
+      this.trackedImages.set(trackedImage.id, trackedImage);
+      this.processedElements.add(element);
+      newImages.push(trackedImage);
+      if (this.debug) {
+        console.log("[LiveMyPhotos] Detected image:", element.src, config);
+      }
+    });
+    return newImages;
+  }
+  /**
+   * Start observing the DOM for dynamically added images
+   */
+  observe() {
+    if (this.mutationObserver) {
+      return;
+    }
+    this.mutationObserver = new MutationObserver((mutations) => {
+      let shouldScan = false;
+      for (const mutation of mutations) {
+        if (mutation.type === "childList") {
+          for (const node of mutation.addedNodes) {
+            if (node instanceof HTMLImageElement || node instanceof Element && node.querySelector(this.selector)) {
+              shouldScan = true;
+              break;
+            }
+          }
+        }
+        if (shouldScan) break;
+      }
+      if (shouldScan) {
+        const newImages = this.scan();
+        newImages.forEach((image) => {
+          if (this.onImageDetected) {
+            this.onImageDetected(image);
+          }
+        });
+      }
+    });
+    this.mutationObserver.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+  }
+  /**
+   * Get all tracked images
+   */
+  getTrackedImages() {
+    return Array.from(this.trackedImages.values());
+  }
+  /**
+   * Get a tracked image by ID
+   */
+  getTrackedImage(id) {
+    return this.trackedImages.get(id);
+  }
+  /**
+   * Update a tracked image's state
+   */
+  updateImageState(id, updates) {
+    const image = this.trackedImages.get(id);
+    if (image) {
+      Object.assign(image, updates);
+    }
+  }
+  /**
+   * Clean up and stop observing
+   */
+  destroy() {
+    if (this.mutationObserver) {
+      this.mutationObserver.disconnect();
+      this.mutationObserver = null;
+    }
+    this.trackedImages.clear();
+    this.onImageDetected = null;
+  }
+}
+class ViewportObserver {
+  constructor(callback, options = {}) {
+    this.observer = null;
+    this.visibilityHandler = null;
+    this.observedElements = /* @__PURE__ */ new Map();
+    this.isDocumentVisible = true;
+    this.callback = callback;
+    this.threshold = options.threshold ?? 0.1;
+    this.rootMargin = options.rootMargin ?? "50px";
+    this.debug = options.debug ?? false;
+    this.isDocumentVisible = typeof document !== "undefined" ? !document.hidden : true;
+  }
+  /**
+   * Initialize the observer
+   */
+  init() {
+    if (this.observer) {
+      return;
+    }
+    this.observer = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          const image = this.observedElements.get(entry.target);
+          if (image && this.isDocumentVisible) {
+            if (this.debug) {
+              console.log(
+                "[LiveMyPhotos] Viewport:",
+                entry.isIntersecting ? "enter" : "leave",
+                image.element.src
+              );
+            }
+            this.callback(image, entry.isIntersecting);
+          }
+        });
+      },
+      {
+        threshold: this.threshold,
+        rootMargin: this.rootMargin
+      }
+    );
+    this.visibilityHandler = () => {
+      const wasVisible = this.isDocumentVisible;
+      this.isDocumentVisible = !document.hidden;
+      if (wasVisible !== this.isDocumentVisible) {
+        if (this.debug) {
+          console.log("[LiveMyPhotos] Document visibility:", this.isDocumentVisible);
+        }
+        this.observedElements.forEach((image) => {
+          this.callback(image, this.isDocumentVisible);
+        });
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  /**
+   * Start observing an image
+   */
+  observe(image) {
+    if (!this.observer) {
+      this.init();
+    }
+    if (!this.observedElements.has(image.element)) {
+      this.observedElements.set(image.element, image);
+      this.observer.observe(image.element);
+    }
+  }
+  /**
+   * Stop observing an image
+   */
+  unobserve(image) {
+    if (this.observer && this.observedElements.has(image.element)) {
+      this.observer.unobserve(image.element);
+      this.observedElements.delete(image.element);
+    }
+  }
+  /**
+   * Check if document is currently visible
+   */
+  isVisible() {
+    return this.isDocumentVisible;
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+    if (this.visibilityHandler) {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+    this.observedElements.clear();
+  }
+}
+const DEFAULT_CONFIG$2 = {
+  timeout: 1e4,
+  maxRetries: 3,
+  enableCache: true,
+  debug: false
+};
+const CACHE_KEY_PREFIX = "lmp_cache_";
+const CACHE_TTL = 30 * 24 * 60 * 60 * 1e3;
+class GeminiApiClient {
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_CONFIG$2,
+      ...config
+    };
+  }
+  /**
+   * Fetch animation data for an image
+   *
+   * @param imageUrl - URL of the image to animate
+   * @param options - Animation options
+   * @returns Promise resolving to animation response
+   */
+  async fetch(imageUrl, options = {}) {
+    const imageHash = await this.computeHash(imageUrl);
+    if (this.config.enableCache) {
+      const cached = this.getFromCache(imageHash);
+      if (cached) {
+        if (this.config.debug) {
+          console.log("[GeminiApiClient] Cache hit for:", imageUrl);
+        }
+        return { ...cached, cacheStatus: "hit" };
+      }
+    }
+    const request = {
+      imageUrl,
+      imageHash,
+      type: options.type ?? "auto",
+      intensity: options.intensity ?? "subtle",
+      loop: options.loop ?? true
+    };
+    const response = await this.fetchWithRetry(request);
+    if (response.success && this.config.enableCache) {
+      this.saveToCache(imageHash, response);
+    }
+    return { ...response, cacheStatus: "miss" };
+  }
+  /**
+   * Fetch with retry logic and exponential backoff
+   */
+  async fetchWithRetry(request, attempt = 0) {
+    try {
+      return await this.fetchWithTimeout(request);
+    } catch (error) {
+      const isRetryable = error instanceof LivePhotoError && (error.code === "NETWORK_ERROR" || error.code === "TIMEOUT_ERROR");
+      if (isRetryable && attempt < this.config.maxRetries) {
+        const delay = Math.pow(2, attempt) * 1e3;
+        if (this.config.debug) {
+          console.log(
+            `[GeminiApiClient] Retry ${attempt + 1}/${this.config.maxRetries} after ${delay}ms`
+          );
+        }
+        await this.sleep(delay);
+        return this.fetchWithRetry(request, attempt + 1);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Fetch with timeout handling
+   */
+  async fetchWithTimeout(request) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        if (response.status === 429) {
+          throw new LivePhotoError(
+            "Rate limit exceeded",
+            "RATE_LIMIT_ERROR"
+          );
+        }
+        throw new LivePhotoError(
+          `API error: ${response.status} ${response.statusText}`,
+          "API_ERROR"
+        );
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof LivePhotoError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new LivePhotoError(
+            `Request timed out after ${this.config.timeout}ms`,
+            "TIMEOUT_ERROR",
+            error
+          );
+        }
+        throw new LivePhotoError(
+          `Network error: ${error.message}`,
+          "NETWORK_ERROR",
+          error
+        );
+      }
+      throw new LivePhotoError("Unknown error occurred", "UNKNOWN_ERROR");
+    }
+  }
+  /**
+   * Compute SHA-256 hash of a string (for cache keys)
+   */
+  async computeHash(input) {
+    if (typeof crypto !== "undefined" && crypto.subtle) {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(input);
+      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+      const char = input.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+  /**
+   * Get cached response if valid
+   */
+  getFromCache(imageHash) {
+    if (typeof localStorage === "undefined") {
+      return null;
+    }
+    try {
+      const cacheKey = CACHE_KEY_PREFIX + imageHash;
+      const cached = localStorage.getItem(cacheKey);
+      if (!cached) {
+        return null;
+      }
+      const parsed = JSON.parse(cached);
+      if (Date.now() - parsed.timestamp > CACHE_TTL) {
+        localStorage.removeItem(cacheKey);
+        return null;
+      }
+      return parsed.data;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save response to cache
+   */
+  saveToCache(imageHash, response) {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    try {
+      const cacheKey = CACHE_KEY_PREFIX + imageHash;
+      const cached = {
+        data: response,
+        timestamp: Date.now()
+      };
+      localStorage.setItem(cacheKey, JSON.stringify(cached));
+    } catch {
+      if (this.config.debug) {
+        console.warn("[GeminiApiClient] Failed to cache response");
+      }
+    }
+  }
+  /**
+   * Clear all cached responses
+   */
+  clearCache() {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key && key.startsWith(CACHE_KEY_PREFIX)) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((key) => localStorage.removeItem(key));
+  }
+  /**
+   * Sleep utility for retry delays
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+const INTENSITY_MULTIPLIERS = {
+  subtle: 0.3,
+  medium: 0.6,
+  strong: 1
+};
+const ANIMATION_PRESETS = {
+  breathing: {
+    translateX: 0,
+    translateY: 0,
+    scale: 0.02,
+    rotate: 0,
+    duration: 3e3
+  },
+  parallax: {
+    translateX: 5,
+    translateY: 3,
+    scale: 0.01,
+    rotate: 0,
+    duration: 4e3
+  },
+  sway: {
+    translateX: 3,
+    translateY: 0,
+    scale: 0,
+    rotate: 2,
+    duration: 2500
+  }
+};
+class AnimationRenderer {
+  constructor(config = {}) {
+    this.animations = /* @__PURE__ */ new Map();
+    this.config = {
+      frameRate: config.frameRate ?? 60,
+      debug: config.debug ?? false
+    };
+  }
+  /**
+   * Start animation playback for an image
+   *
+   * @param trackedImage - The tracked image to animate
+   * @param animationData - Animation data from Gemini API
+   * @param options - Animation options
+   */
+  play(trackedImage, animationData, options = {}) {
+    const { id, element } = trackedImage;
+    this.stop(id);
+    element.style.willChange = "transform";
+    element.style.transformOrigin = "center center";
+    const state = {
+      trackedImage,
+      animationData,
+      currentFrame: 0,
+      animationFrameId: null,
+      startTime: performance.now(),
+      isPaused: false,
+      intensity: options.intensity ?? trackedImage.config.intensity,
+      loop: options.loop ?? trackedImage.config.loop,
+      onComplete: options.onComplete
+    };
+    this.animations.set(id, state);
+    if (this.config.debug) {
+      console.log("[AnimationRenderer] Starting animation for:", id);
+    }
+    this.renderLoop(id);
+  }
+  /**
+   * Pause animation for an image
+   */
+  pause(imageId) {
+    const state = this.animations.get(imageId);
+    if (state && !state.isPaused) {
+      state.isPaused = true;
+      if (state.animationFrameId !== null) {
+        cancelAnimationFrame(state.animationFrameId);
+        state.animationFrameId = null;
+      }
+      if (this.config.debug) {
+        console.log("[AnimationRenderer] Paused animation for:", imageId);
+      }
+    }
+  }
+  /**
+   * Resume animation for an image
+   */
+  resume(imageId) {
+    const state = this.animations.get(imageId);
+    if (state && state.isPaused) {
+      state.isPaused = false;
+      state.startTime = performance.now() - this.getElapsedTime(state);
+      this.renderLoop(imageId);
+      if (this.config.debug) {
+        console.log("[AnimationRenderer] Resumed animation for:", imageId);
+      }
+    }
+  }
+  /**
+   * Stop animation for an image and reset transforms
+   */
+  stop(imageId) {
+    const state = this.animations.get(imageId);
+    if (state) {
+      if (state.animationFrameId !== null) {
+        cancelAnimationFrame(state.animationFrameId);
+      }
+      state.trackedImage.element.style.transform = "";
+      state.trackedImage.element.style.willChange = "";
+      this.animations.delete(imageId);
+      if (this.config.debug) {
+        console.log("[AnimationRenderer] Stopped animation for:", imageId);
+      }
+    }
+  }
+  /**
+   * Check if an image is currently animating
+   */
+  isPlaying(imageId) {
+    const state = this.animations.get(imageId);
+    return state !== void 0 && !state.isPaused;
+  }
+  /**
+   * Get all currently animating image IDs
+   */
+  getActiveAnimations() {
+    return Array.from(this.animations.keys());
+  }
+  /**
+   * Stop all animations and clean up
+   */
+  destroy() {
+    for (const imageId of this.animations.keys()) {
+      this.stop(imageId);
+    }
+    this.animations.clear();
+  }
+  /**
+   * Main render loop using requestAnimationFrame
+   */
+  renderLoop(imageId) {
+    const state = this.animations.get(imageId);
+    if (!state || state.isPaused) {
+      return;
+    }
+    const elapsed = performance.now() - state.startTime;
+    const duration = state.animationData.duration || 3e3;
+    const progress = elapsed % duration / duration;
+    if (!state.loop && elapsed >= duration) {
+      this.stop(imageId);
+      if (state.onComplete) {
+        state.onComplete();
+      }
+      return;
+    }
+    this.renderFrame(state, progress);
+    state.animationFrameId = requestAnimationFrame(() => {
+      this.renderLoop(imageId);
+    });
+  }
+  /**
+   * Render a single animation frame
+   */
+  renderFrame(state, progress) {
+    const { trackedImage, animationData, intensity } = state;
+    const multiplier = INTENSITY_MULTIPLIERS[intensity];
+    let transform;
+    if (animationData.frames && animationData.frames.length > 0) {
+      const frameIndex = Math.floor(progress * animationData.frames.length);
+      const frame = animationData.frames[Math.min(frameIndex, animationData.frames.length - 1)];
+      transform = frame.transform;
+    } else {
+      const animType = animationData.detectedType || "breathing";
+      if (animType !== "auto") {
+        transform = this.generateTransformFromType(animType, progress);
+      } else {
+        transform = this.generateTransformFromType("breathing", progress);
+      }
+    }
+    const translateX = transform.translateX * multiplier;
+    const translateY = transform.translateY * multiplier;
+    const scale = 1 + transform.scale * multiplier;
+    const rotate = transform.rotate * multiplier;
+    trackedImage.element.style.transform = `translate(${translateX}px, ${translateY}px) scale(${scale}) rotate(${rotate}deg)`;
+  }
+  /**
+   * Generate transform values for a given animation type
+   */
+  generateTransformFromType(type, progress) {
+    const preset = ANIMATION_PRESETS[type] || ANIMATION_PRESETS.breathing;
+    const oscillation = Math.sin(progress * Math.PI * 2);
+    return {
+      translateX: preset.translateX * oscillation,
+      translateY: preset.translateY * oscillation,
+      scale: preset.scale * oscillation,
+      rotate: preset.rotate * oscillation
+    };
+  }
+  /**
+   * Calculate elapsed time for a paused animation
+   */
+  getElapsedTime(state) {
+    const duration = state.animationData.duration || 3e3;
+    return state.currentFrame / state.animationData.frameRate * 1e3 % duration;
+  }
+}
+const DEFAULT_CONFIG$1 = {
+  apiKey: "",
+  debug: false,
+  pollInterval: 3e3,
+  maxPollAttempts: 60,
+  cacheTTL: 30 * 24 * 60 * 60 * 1e3
+  // 30 days
+};
+const VIDEO_CACHE_PREFIX = "beautifi_video_";
+class VeoClient {
+  constructor(config) {
+    this.pendingOperations = /* @__PURE__ */ new Map();
+    this.config = {
+      ...DEFAULT_CONFIG$1,
+      ...config
+    };
+  }
+  /**
+   * Start video generation for an image
+   *
+   * @param request - Video generation request
+   * @returns Promise resolving to operation ID
+   */
+  async startGeneration(request) {
+    var _a;
+    const cacheKey = this.computeCacheKey(request.imageUrl);
+    const cached = this.getFromCache(cacheKey);
+    if (cached) {
+      this.log(`📦 Video cached: ${cacheKey.slice(0, 8)}...`);
+      return {
+        success: true,
+        status: "completed",
+        videoUrl: cached
+      };
+    }
+    try {
+      const endpoint = this.config.endpoint.replace("/animate", "/animate-auto");
+      this.log(`🎬 Starting video generation for: ${request.imageUrl.slice(0, 50)}...`);
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.config.apiKey) {
+        headers["X-API-Key"] = this.config.apiKey;
+      }
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          imageUrl: request.imageUrl,
+          animationPrompt: request.animationPrompt,
+          aspectRatio: request.aspectRatio,
+          durationSeconds: request.durationSeconds
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (!data.success) {
+        throw new Error(((_a = data.error) == null ? void 0 : _a.message) || "Video generation failed");
+      }
+      this.log(`🚀 Generation started: ${data.operationId}`);
+      return data;
+    } catch (error) {
+      this.log(`❌ Start generation error: ${error}`);
+      return {
+        success: false,
+        error: {
+          code: "GENERATION_ERROR",
+          message: error instanceof Error ? error.message : "Failed to start generation"
+        }
+      };
+    }
+  }
+  /**
+   * Poll for video generation status until complete
+   *
+   * @param operationId - Operation ID to poll
+   * @param imageUrl - Original image URL (for caching)
+   * @param onProgress - Callback for progress updates
+   * @returns Promise resolving to video URL or null on failure
+   */
+  async pollUntilComplete(operationId, imageUrl, onProgress) {
+    var _a;
+    const controller = new AbortController();
+    this.pendingOperations.set(operationId, controller);
+    try {
+      let attempt = 0;
+      while (attempt < this.config.maxPollAttempts) {
+        if (controller.signal.aborted) {
+          this.log(`🛑 Polling aborted: ${operationId}`);
+          return null;
+        }
+        const result = await this.checkStatus(operationId);
+        if (onProgress) {
+          onProgress(result.status || "unknown", attempt);
+        }
+        if (result.status === "completed" && result.videoUrl) {
+          this.log(`✅ Video ready: ${result.videoUrl.slice(0, 50)}...`);
+          const cacheKey = this.computeCacheKey(imageUrl);
+          this.saveToCache(cacheKey, result.videoUrl);
+          return result.videoUrl;
+        }
+        if (result.status === "error" || !result.success) {
+          this.log(`❌ Generation failed: ${(_a = result.error) == null ? void 0 : _a.message}`);
+          return null;
+        }
+        const backoffMs = Math.min(
+          this.config.pollInterval * Math.pow(1.5, Math.min(attempt, 5)),
+          15e3
+        );
+        this.log(`⏳ Polling (${attempt + 1}/${this.config.maxPollAttempts}): ${result.status}`);
+        await this.sleep(backoffMs);
+        attempt++;
+      }
+      this.log(`⏰ Polling timeout: ${operationId}`);
+      return null;
+    } finally {
+      this.pendingOperations.delete(operationId);
+    }
+  }
+  /**
+   * Check the status of a video generation operation
+   */
+  async checkStatus(operationId) {
+    try {
+      const endpoint = this.config.endpoint.replace("/animate", "/generate-video/status").replace(/\/$/, "");
+      const headers = {};
+      if (this.config.apiKey) {
+        headers["X-API-Key"] = this.config.apiKey;
+      }
+      const response = await fetch(`${endpoint}/${operationId}`, { headers });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        status: "error",
+        error: {
+          code: "POLL_ERROR",
+          message: error instanceof Error ? error.message : "Status check failed"
+        }
+      };
+    }
+  }
+  /**
+   * Cancel a pending video generation operation
+   */
+  cancelOperation(operationId) {
+    const controller = this.pendingOperations.get(operationId);
+    if (controller) {
+      controller.abort();
+      this.pendingOperations.delete(operationId);
+      this.log(`🛑 Cancelled: ${operationId}`);
+    }
+  }
+  /**
+   * Cancel all pending operations
+   */
+  cancelAllOperations() {
+    for (const [id, controller] of this.pendingOperations) {
+      controller.abort();
+      this.log(`🛑 Cancelled: ${id}`);
+    }
+    this.pendingOperations.clear();
+  }
+  /**
+   * Get cached video URL for an image
+   */
+  getCachedVideo(imageUrl) {
+    const cacheKey = this.computeCacheKey(imageUrl);
+    return this.getFromCache(cacheKey);
+  }
+  /**
+   * Compute cache key from image URL
+   */
+  computeCacheKey(imageUrl) {
+    let hash = 0;
+    for (let i = 0; i < imageUrl.length; i++) {
+      const char = imageUrl.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+  /**
+   * Get video URL from localStorage cache
+   */
+  getFromCache(cacheKey) {
+    if (typeof localStorage === "undefined") return null;
+    try {
+      const raw = localStorage.getItem(VIDEO_CACHE_PREFIX + cacheKey);
+      if (!raw) return null;
+      const cached = JSON.parse(raw);
+      if (Date.now() - cached.timestamp > this.config.cacheTTL) {
+        localStorage.removeItem(VIDEO_CACHE_PREFIX + cacheKey);
+        return null;
+      }
+      return cached.videoUrl;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save video URL to localStorage cache
+   */
+  saveToCache(cacheKey, videoUrl) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const cached = {
+        videoUrl,
+        timestamp: Date.now()
+      };
+      localStorage.setItem(VIDEO_CACHE_PREFIX + cacheKey, JSON.stringify(cached));
+      this.log(`💾 Cached: ${cacheKey}`);
+    } catch {
+    }
+  }
+  /**
+   * Clear all cached videos
+   */
+  clearCache() {
+    if (typeof localStorage === "undefined") return;
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key == null ? void 0 : key.startsWith(VIDEO_CACHE_PREFIX)) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((key) => localStorage.removeItem(key));
+    this.log(`🧹 Cleared ${keysToRemove.length} cached videos`);
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.config.debug) {
+      console.log(`[VeoClient] ${message}`);
+    }
+  }
+}
+const DEFAULT_CONFIG = {
+  transitionDuration: 500,
+  debug: false,
+  autoPlay: true,
+  loop: true,
+  muted: true
+};
+class VideoRenderer {
+  constructor(config = {}) {
+    this.activeVideos = /* @__PURE__ */ new Map();
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+  }
+  /**
+   * Prepare a video overlay for an image
+   *
+   * @param imageId - Unique ID for tracking
+   * @param imageElement - The image element to overlay
+   * @param videoUrl - URL of the video to play
+   * @param onFallback - Callback if video fails to load
+   * @returns Promise that resolves when video is ready to play
+   */
+  async prepareVideo(imageId, imageElement, videoUrl, onFallback) {
+    if (this.activeVideos.has(imageId)) {
+      this.log(`⚠️ Video already prepared: ${imageId}`);
+      return true;
+    }
+    try {
+      const wrapper = this.createWrapper(imageElement);
+      const video = this.createVideoElement(videoUrl);
+      wrapper.insertBefore(video, imageElement);
+      const entry = {
+        imageElement,
+        videoElement: video,
+        wrapperElement: wrapper,
+        state: "loading",
+        onFallback
+      };
+      this.activeVideos.set(imageId, entry);
+      await this.waitForVideoReady(video, entry);
+      this.log(`✅ Video prepared: ${imageId}`);
+      return true;
+    } catch (error) {
+      this.log(`❌ Prepare failed: ${imageId} - ${error}`);
+      this.cleanup(imageId);
+      onFallback == null ? void 0 : onFallback();
+      return false;
+    }
+  }
+  /**
+   * Play video and transition from CSS animation
+   */
+  play(imageId) {
+    var _a;
+    const entry = this.activeVideos.get(imageId);
+    if (!entry) {
+      this.log(`⚠️ No video found: ${imageId}`);
+      return false;
+    }
+    if (entry.state === "error") {
+      this.log(`⚠️ Video in error state: ${imageId}`);
+      return false;
+    }
+    try {
+      this.transitionToVideo(entry);
+      entry.videoElement.play().catch((err) => {
+        var _a2;
+        this.log(`❌ Play failed: ${err}`);
+        entry.state = "error";
+        (_a2 = entry.onFallback) == null ? void 0 : _a2.call(entry);
+      });
+      entry.state = "playing";
+      this.log(`▶️ Playing: ${imageId}`);
+      return true;
+    } catch (error) {
+      this.log(`❌ Play error: ${error}`);
+      entry.state = "error";
+      (_a = entry.onFallback) == null ? void 0 : _a.call(entry);
+      return false;
+    }
+  }
+  /**
+   * Pause video playback
+   */
+  pause(imageId) {
+    const entry = this.activeVideos.get(imageId);
+    if (!entry || entry.state !== "playing") {
+      return false;
+    }
+    entry.videoElement.pause();
+    entry.state = "paused";
+    this.log(`⏸️ Paused: ${imageId}`);
+    return true;
+  }
+  /**
+   * Resume video playback
+   */
+  resume(imageId) {
+    const entry = this.activeVideos.get(imageId);
+    if (!entry || entry.state !== "paused") {
+      return false;
+    }
+    entry.videoElement.play().catch(() => {
+      entry.state = "error";
+    });
+    entry.state = "playing";
+    this.log(`▶️ Resumed: ${imageId}`);
+    return true;
+  }
+  /**
+   * Stop video and remove overlay
+   */
+  stop(imageId) {
+    const entry = this.activeVideos.get(imageId);
+    if (!entry) return;
+    this.transitionToImage(entry);
+    setTimeout(() => {
+      this.cleanup(imageId);
+    }, this.config.transitionDuration);
+  }
+  /**
+   * Check if video is playing for an image
+   */
+  isPlaying(imageId) {
+    const entry = this.activeVideos.get(imageId);
+    return (entry == null ? void 0 : entry.state) === "playing";
+  }
+  /**
+   * Check if video is prepared for an image
+   */
+  isPrepared(imageId) {
+    return this.activeVideos.has(imageId);
+  }
+  /**
+   * Get current playback state
+   */
+  getState(imageId) {
+    var _a;
+    return ((_a = this.activeVideos.get(imageId)) == null ? void 0 : _a.state) || null;
+  }
+  /**
+   * Destroy all videos and cleanup
+   */
+  destroy() {
+    for (const imageId of this.activeVideos.keys()) {
+      this.cleanup(imageId);
+    }
+    this.log(`🧹 Destroyed all videos`);
+  }
+  /**
+   * Create wrapper element around image
+   */
+  createWrapper(imageElement) {
+    var _a;
+    const existingWrapper = imageElement.parentElement;
+    if (existingWrapper == null ? void 0 : existingWrapper.classList.contains("beautifi-video-wrapper")) {
+      return existingWrapper;
+    }
+    const wrapper = document.createElement("div");
+    wrapper.className = "beautifi-video-wrapper";
+    wrapper.style.cssText = `
+            position: relative;
+            display: inline-block;
+            width: ${imageElement.offsetWidth}px;
+            height: ${imageElement.offsetHeight}px;
+            overflow: hidden;
+        `;
+    (_a = imageElement.parentNode) == null ? void 0 : _a.insertBefore(wrapper, imageElement);
+    wrapper.appendChild(imageElement);
+    imageElement.style.cssText += `
+            position: relative;
+            z-index: 2;
+            transition: opacity ${this.config.transitionDuration}ms ease-in-out;
+        `;
+    return wrapper;
+  }
+  /**
+   * Create video element with proper attributes
+   */
+  createVideoElement(videoUrl) {
+    const video = document.createElement("video");
+    video.src = videoUrl;
+    video.muted = this.config.muted;
+    video.loop = this.config.loop;
+    video.playsInline = true;
+    video.preload = "auto";
+    video.crossOrigin = "anonymous";
+    video.style.cssText = `
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+            z-index: 1;
+            opacity: 0;
+            transition: opacity ${this.config.transitionDuration}ms ease-in-out;
+        `;
+    return video;
+  }
+  /**
+   * Wait for video to be ready to play
+   */
+  waitForVideoReady(video, entry) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Video load timeout"));
+      }, 3e4);
+      video.addEventListener("canplaythrough", () => {
+        clearTimeout(timeout);
+        entry.state = "buffering";
+        resolve();
+      }, { once: true });
+      video.addEventListener("error", () => {
+        clearTimeout(timeout);
+        entry.state = "error";
+        reject(new Error("Video load error"));
+      }, { once: true });
+      video.load();
+    });
+  }
+  /**
+   * Transition from image to video
+   */
+  transitionToVideo(entry) {
+    entry.videoElement.style.opacity = "1";
+    entry.imageElement.style.opacity = "0";
+    entry.imageElement.style.animation = "none";
+  }
+  /**
+   * Transition from video back to image
+   */
+  transitionToImage(entry) {
+    entry.imageElement.style.opacity = "1";
+    entry.videoElement.style.opacity = "0";
+    entry.videoElement.pause();
+  }
+  /**
+   * Cleanup video element and restore image
+   */
+  cleanup(imageId) {
+    const entry = this.activeVideos.get(imageId);
+    if (!entry) return;
+    entry.imageElement.style.opacity = "1";
+    entry.imageElement.style.animation = "";
+    entry.imageElement.style.position = "";
+    entry.imageElement.style.zIndex = "";
+    entry.imageElement.style.transition = "";
+    entry.videoElement.remove();
+    if (entry.wrapperElement.classList.contains("beautifi-video-wrapper")) {
+      const parent = entry.wrapperElement.parentNode;
+      if (parent) {
+        parent.insertBefore(entry.imageElement, entry.wrapperElement);
+        entry.wrapperElement.remove();
+      }
+    }
+    this.activeVideos.delete(imageId);
+    this.log(`🧹 Cleaned up: ${imageId}`);
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.config.debug) {
+      console.log(`[VideoRenderer] ${message}`);
+    }
+  }
+}
+class beautifiPlugin {
+  constructor() {
+    this.initialized = false;
+    this.options = null;
+    this.detector = null;
+    this.viewportObserver = null;
+    this.apiClient = null;
+    this.renderer = null;
+    this.veoClient = null;
+    this.videoRenderer = null;
+    this.reducedMotion = false;
+    this.pendingVideoGenerations = /* @__PURE__ */ new Map();
+  }
+  // imageId -> operationId
+  /**
+   * Initialize the plugin with configuration options
+   *
+   * @param options - Plugin configuration
+   * @throws Error if apiKey is not provided
+   */
+  init(options) {
+    if (!options.apiKey) {
+      throw new Error("beautifi: apiKey is required");
+    }
+    if (typeof window !== "undefined" && window.matchMedia) {
+      this.reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    }
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...options
+    };
+    if (this.reducedMotion && this.options.respectReducedMotion) {
+      if (this.options.debug) {
+        console.log("[beautifi] Reduced motion preference detected, animations disabled");
+      }
+      this.initialized = true;
+      return;
+    }
+    this.detector = new ImageDetector(this.options.selector, this.options.debug);
+    this.apiClient = new GeminiApiClient({
+      endpoint: this.options.endpoint || "https://us-central1-seedgpt-planter.cloudfunctions.net/beautifi-animate/animate",
+      timeout: this.options.timeout,
+      maxRetries: this.options.maxRetries,
+      enableCache: true,
+      debug: this.options.debug
+    });
+    this.renderer = new AnimationRenderer({
+      debug: this.options.debug
+    });
+    if (this.options.mode !== "css") {
+      this.veoClient = new VeoClient({
+        endpoint: this.options.videoEndpoint || this.options.endpoint,
+        debug: this.options.debug
+      });
+      this.videoRenderer = new VideoRenderer({
+        debug: this.options.debug,
+        transitionDuration: 500
+      });
+      if (this.options.debug) {
+        console.log("[beautifi] Video mode enabled:", this.options.mode);
+      }
+    }
+    this.viewportObserver = new ViewportObserver(
+      (image, isIntersecting) => {
+        this.handleVisibilityChange(image, isIntersecting);
+      },
+      {
+        threshold: this.options.threshold,
+        rootMargin: this.options.rootMargin,
+        debug: this.options.debug
+      }
+    );
+    this.detector.setOnImageDetected((image) => {
+      this.viewportObserver.observe(image);
+    });
+    this.viewportObserver.init();
+    const images = this.detector.scan();
+    images.forEach((image) => {
+      this.viewportObserver.observe(image);
+    });
+    this.detector.observe();
+    this.initialized = true;
+    if (this.options.debug) {
+      console.log("[beautifi] Initialized with options:", this.options);
+      console.log("[beautifi] Detected", images.length, "images");
+    }
+  }
+  /**
+   * Handle image entering/leaving viewport
+   */
+  handleVisibilityChange(image, isIntersecting) {
+    if (!this.options) return;
+    if (isIntersecting) {
+      if (image.state === "idle") {
+        this.queueAnimation(image);
+      } else if (image.state === "paused") {
+        this.resumeAnimation(image);
+      }
+    } else {
+      if (image.state === "playing") {
+        this.pauseAnimation(image);
+      }
+    }
+  }
+  /**
+   * Queue an image for animation
+   */
+  async queueAnimation(image) {
+    var _a, _b, _c;
+    if (this.detector) {
+      this.detector.updateImageState(image.id, { state: "loading" });
+    }
+    if ((_a = this.options) == null ? void 0 : _a.debug) {
+      console.log("[beautifi] Queuing animation for:", image.element.src);
+    }
+    if (image.config.delay && image.config.delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, image.config.delay));
+    }
+    const imageMode = image.element.dataset.beautifiMode || ((_b = this.options) == null ? void 0 : _b.mode) || "auto";
+    try {
+      const animationData = await this.apiClient.fetch(image.element.src, {
+        type: image.config.type,
+        intensity: image.config.intensity,
+        loop: image.config.loop
+      });
+      if (!animationData.success) {
+        throw new LivePhotoError(
+          animationData.error || "Animation generation failed",
+          "API_ERROR"
+        );
+      }
+      if (this.detector) {
+        this.detector.updateImageState(image.id, {
+          state: "playing",
+          animationData
+        });
+      }
+      if (imageMode !== "video") {
+        this.renderer.play(image, animationData, {
+          intensity: image.config.intensity,
+          loop: image.config.loop,
+          onComplete: () => {
+            if (this.detector) {
+              this.detector.updateImageState(image.id, { state: "idle" });
+            }
+            this.emitEvent("animationComplete", image);
+          }
+        });
+        this.emitEvent("animationStart", image);
+      }
+      if (imageMode !== "css" && this.veoClient && this.videoRenderer) {
+        this.startVideoGeneration(image);
+      }
+    } catch (error) {
+      const livePhotoError = error instanceof LivePhotoError ? error : new LivePhotoError(
+        error instanceof Error ? error.message : "Unknown error",
+        "UNKNOWN_ERROR",
+        error instanceof Error ? error : void 0
+      );
+      if (this.detector) {
+        this.detector.updateImageState(image.id, {
+          state: "error",
+          error: livePhotoError
+        });
+      }
+      if ((_c = this.options) == null ? void 0 : _c.debug) {
+        console.error("[beautifi] Animation error:", livePhotoError);
+      }
+      this.emitEvent("animationError", image, livePhotoError);
+    }
+  }
+  /**
+   * Start video generation in background
+   */
+  async startVideoGeneration(image) {
+    var _a, _b, _c, _d, _e;
+    if (!this.veoClient || !this.videoRenderer) return;
+    const cachedVideo = this.veoClient.getCachedVideo(image.element.src);
+    if (cachedVideo) {
+      if ((_a = this.options) == null ? void 0 : _a.debug) {
+        console.log("[beautifi] Using cached video for:", image.id);
+      }
+      this.transitionToVideo(image, cachedVideo);
+      return;
+    }
+    this.emitVideoEvent("videoStart", image);
+    if ((_b = this.options) == null ? void 0 : _b.debug) {
+      console.log("[beautifi] Starting video generation for:", image.id);
+    }
+    try {
+      const result = await this.veoClient.startGeneration({
+        imageUrl: image.element.src
+      });
+      if (!result.success || !result.operationId) {
+        throw new Error(((_c = result.error) == null ? void 0 : _c.message) || "Failed to start video generation");
+      }
+      if (result.status === "completed" && result.videoUrl) {
+        this.transitionToVideo(image, result.videoUrl);
+        return;
+      }
+      this.pendingVideoGenerations.set(image.id, result.operationId);
+      const videoUrl = await this.veoClient.pollUntilComplete(
+        result.operationId,
+        image.element.src,
+        (status, attempt) => {
+          var _a2;
+          if ((_a2 = this.options) == null ? void 0 : _a2.debug) {
+            console.log(`[beautifi] Video poll ${image.id}: ${status} (attempt ${attempt})`);
+          }
+        }
+      );
+      this.pendingVideoGenerations.delete(image.id);
+      if (videoUrl) {
+        this.transitionToVideo(image, videoUrl);
+      } else {
+        if ((_d = this.options) == null ? void 0 : _d.debug) {
+          console.log("[beautifi] Video generation failed, keeping CSS animation:", image.id);
+        }
+        this.emitVideoEvent("videoError", image);
+      }
+    } catch (error) {
+      this.pendingVideoGenerations.delete(image.id);
+      if ((_e = this.options) == null ? void 0 : _e.debug) {
+        console.error("[beautifi] Video generation error:", error);
+      }
+      this.emitVideoEvent("videoError", image);
+    }
+  }
+  /**
+   * Transition from CSS animation to video
+   */
+  async transitionToVideo(image, videoUrl) {
+    var _a, _b;
+    if (!this.videoRenderer) return;
+    if ((_a = this.options) == null ? void 0 : _a.debug) {
+      console.log("[beautifi] Transitioning to video:", image.id);
+    }
+    const prepared = await this.videoRenderer.prepareVideo(
+      image.id,
+      image.element,
+      videoUrl,
+      () => {
+        var _a2;
+        if ((_a2 = this.options) == null ? void 0 : _a2.debug) {
+          console.log("[beautifi] Video fallback to CSS:", image.id);
+        }
+      }
+    );
+    if (prepared) {
+      (_b = this.renderer) == null ? void 0 : _b.stop(image.id);
+      this.videoRenderer.play(image.id);
+      this.emitVideoEvent("videoReady", image, videoUrl);
+    }
+  }
+  /**
+   * Pause animation for an image
+   */
+  pauseAnimation(image) {
+    var _a;
+    if (this.renderer) {
+      this.renderer.pause(image.id);
+    }
+    if (this.detector) {
+      this.detector.updateImageState(image.id, { state: "paused" });
+    }
+    if ((_a = this.options) == null ? void 0 : _a.debug) {
+      console.log("[beautifi] Pausing animation for:", image.element.src);
+    }
+    this.emitEvent("animationPause", image);
+  }
+  /**
+   * Resume animation for an image
+   */
+  resumeAnimation(image) {
+    var _a;
+    if (this.renderer) {
+      this.renderer.resume(image.id);
+    }
+    if (this.detector) {
+      this.detector.updateImageState(image.id, { state: "playing" });
+    }
+    if ((_a = this.options) == null ? void 0 : _a.debug) {
+      console.log("[beautifi] Resuming animation for:", image.element.src);
+    }
+    this.emitEvent("animationResume", image);
+  }
+  /**
+   * Emit lifecycle events
+   */
+  emitEvent(type, image, error) {
+    if (typeof CustomEvent !== "undefined") {
+      const detail = {
+        type,
+        timestamp: Date.now(),
+        element: image.element,
+        imageId: image.id,
+        ...error && { error }
+      };
+      const event = new CustomEvent(`beautifi:${type}`, { detail });
+      document.dispatchEvent(event);
+    }
+  }
+  /**
+   * Emit video-related events
+   */
+  emitVideoEvent(type, image, videoUrl) {
+    if (typeof CustomEvent !== "undefined") {
+      const detail = {
+        type,
+        timestamp: Date.now(),
+        element: image.element,
+        imageId: image.id,
+        ...videoUrl && { videoUrl }
+      };
+      const event = new CustomEvent(`beautifi:${type}`, { detail });
+      document.dispatchEvent(event);
+    }
+  }
+  /**
+   * Check if the plugin has been initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get current options (for debugging)
+   */
+  getOptions() {
+    return this.options;
+  }
+  /**
+   * Get all tracked images
+   */
+  getTrackedImages() {
+    var _a;
+    return ((_a = this.detector) == null ? void 0 : _a.getTrackedImages()) ?? [];
+  }
+  /**
+   * Destroy the plugin and clean up resources
+   */
+  destroy() {
+    if (this.veoClient) {
+      this.veoClient.cancelAllOperations();
+      this.veoClient = null;
+    }
+    if (this.videoRenderer) {
+      this.videoRenderer.destroy();
+      this.videoRenderer = null;
+    }
+    if (this.renderer) {
+      this.renderer.destroy();
+      this.renderer = null;
+    }
+    if (this.detector) {
+      this.detector.destroy();
+      this.detector = null;
+    }
+    if (this.viewportObserver) {
+      this.viewportObserver.destroy();
+      this.viewportObserver = null;
+    }
+    this.apiClient = null;
+    this.pendingVideoGenerations.clear();
+    this.initialized = false;
+    this.options = null;
+  }
+}
+const plugin = new beautifiPlugin();
+const beautifi = {
+  /**
+   * Initialize the plugin
+   */
+  init: (options) => plugin.init(options),
+  /**
+   * Check if initialized
+   */
+  isInitialized: () => plugin.isInitialized(),
+  /**
+   * Get current options
+   */
+  getOptions: () => plugin.getOptions(),
+  /**
+   * Get tracked images
+   */
+  getTrackedImages: () => plugin.getTrackedImages(),
+  /**
+   * Destroy and clean up
+   */
+  destroy: () => plugin.destroy()
+};
+const LiveMyPhotos = beautifi;
+if (typeof document !== "undefined") {
+  document.addEventListener("DOMContentLoaded", () => {
+    const scriptTag = document.querySelector(
+      'script[data-api-key][src*="beautifi"], script[data-api-key][src*="live-my-photos"]'
+    );
+    if (scriptTag) {
+      const apiKey = scriptTag.dataset.apiKey;
+      const autoInit = scriptTag.dataset.autoInit !== "false";
+      if (apiKey && autoInit) {
+        beautifi.init({
+          apiKey,
+          selector: scriptTag.dataset.selector,
+          intensity: scriptTag.dataset.intensity,
+          type: scriptTag.dataset.type,
+          loop: scriptTag.dataset.loop !== "false",
+          debug: scriptTag.dataset.debug === "true",
+          mode: scriptTag.dataset.mode || "auto"
+        });
+      }
+    }
+  });
+}
+if (typeof window !== "undefined") {
+  window.beautifi = beautifi;
+  window.LiveMyPhotos = beautifi;
+}
+export {
+  AnimationRenderer,
+  DEFAULT_ANIMATION_CONFIG,
+  DEFAULT_OPTIONS,
+  GeminiApiClient,
+  ImageDetector,
+  LiveMyPhotos,
+  LivePhotoError,
+  VeoClient,
+  VideoRenderer,
+  ViewportObserver,
+  beautifi,
+  beautifi as default
+};
+//# sourceMappingURL=beautifi.esm.js.map