@frybynite/image-cloud 0.1.0

package/dist/image-cloud.js

@@ -0,0 +1,3078 @@
+const St = Object.freeze({
+  none: "none",
+  sm: "0 2px 4px rgba(0,0,0,0.1)",
+  md: "0 4px 16px rgba(0,0,0,0.4)",
+  lg: "0 8px 32px rgba(0,0,0,0.5)",
+  glow: "0 0 30px rgba(255,255,255,0.6)"
+}), zt = Object.freeze({
+  energetic: Object.freeze({ overshoot: 0.25, bounces: 2, decayRatio: 0.5 }),
+  playful: Object.freeze({ overshoot: 0.15, bounces: 1, decayRatio: 0.5 }),
+  subtle: Object.freeze({ overshoot: 0.08, bounces: 1, decayRatio: 0.5 })
+}), Tt = Object.freeze({
+  gentle: Object.freeze({ stiffness: 150, damping: 30, mass: 1, oscillations: 2 }),
+  bouncy: Object.freeze({ stiffness: 300, damping: 15, mass: 1, oscillations: 4 }),
+  wobbly: Object.freeze({ stiffness: 180, damping: 12, mass: 1.5, oscillations: 5 }),
+  snappy: Object.freeze({ stiffness: 400, damping: 25, mass: 0.8, oscillations: 2 })
+}), Mt = Object.freeze({
+  gentle: Object.freeze({ amplitude: 30, frequency: 1.5, decay: !0, decayRate: 0.9, phase: 0 }),
+  playful: Object.freeze({ amplitude: 50, frequency: 2.5, decay: !0, decayRate: 0.7, phase: 0 }),
+  serpentine: Object.freeze({ amplitude: 60, frequency: 3, decay: !1, decayRate: 1, phase: 0 }),
+  flutter: Object.freeze({ amplitude: 20, frequency: 4, decay: !0, decayRate: 0.5, phase: 0 })
+}), It = Object.freeze({
+  type: "linear"
+}), Rt = Object.freeze({
+  mode: "none"
+}), Et = Object.freeze({
+  mode: "none"
+}), Lt = Object.freeze({
+  default: Object.freeze({
+    border: Object.freeze({
+      width: 0,
+      color: "#000000",
+      radius: 0,
+      style: "solid"
+    }),
+    shadow: "none",
+    filter: Object.freeze({}),
+    opacity: 1,
+    cursor: "pointer",
+    outline: Object.freeze({
+      width: 0,
+      color: "#000000",
+      style: "solid",
+      offset: 0
+    })
+  }),
+  hover: Object.freeze({
+    shadow: "none"
+  }),
+  focused: Object.freeze({
+    shadow: "none"
+  })
+}), Ht = Object.freeze({
+  rows: 1,
+  amplitude: 100,
+  frequency: 2,
+  phaseShift: 0,
+  synchronization: "offset"
+  // Note: Image rotation along wave is now controlled via image.rotation.mode = 'tangent'
+}), _t = Object.freeze({
+  // baseHeight not set - layouts will auto-calculate based on targetCoverage
+  variance: Object.freeze({
+    min: 1,
+    // No variance by default
+    max: 1
+  }),
+  scaleDecay: 0
+  // No decay by default
+}), jt = Object.freeze({
+  mode: "none",
+  range: Object.freeze({
+    min: -15,
+    max: 15
+  })
+}), $t = Object.freeze({
+  sizing: _t,
+  rotation: jt
+}), b = Object.freeze({
+  // Unified loader configuration
+  loader: Object.freeze({
+    type: "googleDrive",
+    googleDrive: Object.freeze({
+      apiKey: "",
+      // Must be provided by user
+      sources: [],
+      // Must be provided by user
+      apiEndpoint: "https://www.googleapis.com/drive/v3/files",
+      allowedExtensions: ["jpg", "jpeg", "png", "gif", "webp", "bmp"],
+      debugLogging: !1
+    }),
+    static: Object.freeze({
+      sources: [],
+      // Must be provided by user
+      validateUrls: !0,
+      validationTimeout: 5e3,
+      validationMethod: "head",
+      failOnAllMissing: !0,
+      allowedExtensions: ["jpg", "jpeg", "png", "gif", "webp", "bmp"],
+      debugLogging: !1
+    })
+  }),
+  // Image sizing and rotation configuration
+  image: $t,
+  // Pattern-based layout configuration
+  layout: Object.freeze({
+    algorithm: "radial",
+    sizing: Object.freeze({
+      base: 200,
+      // pixels - fallback when image.sizing.baseHeight not set
+      responsive: [
+        { minWidth: 1200, height: 225 },
+        // Large screens
+        { minWidth: 768, height: 180 },
+        // Tablet / Small desktop
+        { minWidth: 0, height: 100 }
+        // Mobile / Default
+      ],
+      adaptive: Object.freeze({
+        enabled: !0,
+        // Enable adaptive sizing by default
+        minSize: 50,
+        // Minimum 50px image height
+        maxSize: 400
+        // Maximum 400px image height
+      })
+    }),
+    targetCoverage: 0.6,
+    // Target 60% of container area
+    densityFactor: 1,
+    // Default density
+    spacing: Object.freeze({
+      padding: 50,
+      // padding from viewport edges
+      minGap: 20
+      // minimum spacing between images
+    }),
+    debugRadials: !1,
+    debugCenters: !1
+  }),
+  // Pattern-based animation configuration
+  animation: Object.freeze({
+    duration: 600,
+    // milliseconds
+    easing: Object.freeze({
+      default: "cubic-bezier(0.4, 0.0, 0.2, 1)",
+      // smooth easing
+      bounce: "cubic-bezier(0.68, -0.55, 0.265, 1.55)",
+      // bounce effect
+      focus: "cubic-bezier(0.4, 0.0, 0.2, 1)"
+      // focus/zoom easing
+    }),
+    queue: Object.freeze({
+      enabled: !0,
+      // When false, all images display simultaneously
+      interval: 150,
+      // ms between processing queue items (when enabled)
+      maxConcurrent: void 0
+      // STUB: Not implemented yet
+    }),
+    performance: Object.freeze({
+      useGPU: void 0,
+      // STUB: Not implemented yet
+      reduceMotion: void 0
+      // STUB: Not implemented yet
+    }),
+    entry: Object.freeze({
+      start: Object.freeze({
+        position: "nearest-edge",
+        // Default to nearest edge (current behavior)
+        offset: 100,
+        // pixels beyond edge
+        circular: Object.freeze({
+          radius: "120%",
+          // 120% of container diagonal
+          distribution: "even"
+        })
+      }),
+      timing: Object.freeze({
+        duration: 600,
+        // ms
+        stagger: 150
+        // ms between images
+      }),
+      easing: "cubic-bezier(0.25, 1, 0.5, 1)",
+      // smooth deceleration
+      path: It,
+      rotation: Rt,
+      scale: Et
+    })
+  }),
+  // Pattern-based interaction configuration
+  interaction: Object.freeze({
+    focus: Object.freeze({
+      scalePercent: 0.8,
+      // 80% of container height
+      zIndex: 1e3,
+      animationDuration: void 0
+      // Use default animation duration
+    }),
+    navigation: Object.freeze({
+      keyboard: void 0,
+      // STUB: Not implemented yet
+      swipe: void 0,
+      // STUB: Not implemented yet
+      mouseWheel: void 0
+      // STUB: Not implemented yet
+    }),
+    gestures: Object.freeze({
+      pinchToZoom: void 0,
+      // STUB: Not implemented yet
+      doubleTapToFocus: void 0
+      // STUB: Not implemented yet
+    })
+  }),
+  // Pattern-based rendering configuration
+  rendering: Object.freeze({
+    responsive: Object.freeze({
+      breakpoints: Object.freeze({
+        mobile: 768,
+        tablet: void 0,
+        // STUB: Not implemented yet
+        desktop: void 0
+        // STUB: Not implemented yet
+      }),
+      mobileDetection: () => typeof window > "u" ? !1 : window.innerWidth <= 768
+    }),
+    ui: Object.freeze({
+      showLoadingSpinner: !1,
+      showImageCounter: void 0,
+      // STUB: Not implemented yet
+      showThumbnails: void 0,
+      // STUB: Not implemented yet
+      theme: void 0
+      // STUB: Not implemented yet
+    }),
+    performance: Object.freeze({
+      lazyLoad: void 0,
+      // STUB: Not implemented yet
+      preloadCount: void 0,
+      // STUB: Not implemented yet
+      imageQuality: void 0
+      // STUB: Not implemented yet
+    })
+  }),
+  // Image styling
+  styling: Lt,
+  // Debug mode
+  debug: !1
+});
+function rt(n, t) {
+  if (!n) return t || {};
+  if (!t) return { ...n };
+  const e = { ...n };
+  return t.border !== void 0 && (e.border = { ...n.border, ...t.border }), t.borderTop !== void 0 && (e.borderTop = { ...n.borderTop, ...t.borderTop }), t.borderRight !== void 0 && (e.borderRight = { ...n.borderRight, ...t.borderRight }), t.borderBottom !== void 0 && (e.borderBottom = { ...n.borderBottom, ...t.borderBottom }), t.borderLeft !== void 0 && (e.borderLeft = { ...n.borderLeft, ...t.borderLeft }), t.filter !== void 0 && (e.filter = { ...n.filter, ...t.filter }), t.outline !== void 0 && (e.outline = { ...n.outline, ...t.outline }), t.shadow !== void 0 && (e.shadow = t.shadow), t.opacity !== void 0 && (e.opacity = t.opacity), t.cursor !== void 0 && (e.cursor = t.cursor), t.className !== void 0 && (e.className = t.className), t.objectFit !== void 0 && (e.objectFit = t.objectFit), t.aspectRatio !== void 0 && (e.aspectRatio = t.aspectRatio), t.borderRadiusTopLeft !== void 0 && (e.borderRadiusTopLeft = t.borderRadiusTopLeft), t.borderRadiusTopRight !== void 0 && (e.borderRadiusTopRight = t.borderRadiusTopRight), t.borderRadiusBottomRight !== void 0 && (e.borderRadiusBottomRight = t.borderRadiusBottomRight), t.borderRadiusBottomLeft !== void 0 && (e.borderRadiusBottomLeft = t.borderRadiusBottomLeft), e;
+}
+function Gt(n, t) {
+  if (!t) return { ...n };
+  const e = rt(n.default, t.default), i = rt(
+    rt(e, n.hover),
+    t.hover
+  ), o = rt(
+    rt(e, n.focused),
+    t.focused
+  );
+  return {
+    default: e,
+    hover: i,
+    focused: o
+  };
+}
+function kt(n, t) {
+  var i, o, s, c, a, h, l, g;
+  if (!t) return { ...n };
+  const e = { ...n };
+  if (t.sizing !== void 0 && (e.sizing = {
+    ...n.sizing,
+    ...t.sizing
+  }, t.sizing.variance)) {
+    const r = t.sizing.variance, d = r.min !== void 0 && r.min > 0.1 && r.min < 1 ? r.min : ((o = (i = n.sizing) == null ? void 0 : i.variance) == null ? void 0 : o.min) ?? 1, f = r.max !== void 0 && r.max > 1 && r.max < 2 ? r.max : ((c = (s = n.sizing) == null ? void 0 : s.variance) == null ? void 0 : c.max) ?? 1;
+    e.sizing.variance = { min: d, max: f };
+  }
+  if (t.rotation !== void 0 && (e.rotation = {
+    ...n.rotation,
+    ...t.rotation
+  }, t.rotation.range)) {
+    const r = t.rotation.range, d = r.min !== void 0 && r.min >= -180 && r.min <= 0 ? r.min : ((h = (a = n.rotation) == null ? void 0 : a.range) == null ? void 0 : h.min) ?? -15, f = r.max !== void 0 && r.max >= 0 && r.max <= 180 ? r.max : ((g = (l = n.rotation) == null ? void 0 : l.range) == null ? void 0 : g.max) ?? 15;
+    e.rotation.range = { min: d, max: f };
+  }
+  return e;
+}
+function Wt(n) {
+  var e;
+  const t = (e = n.layout) == null ? void 0 : e.rotation;
+  if (t && "enabled" in t)
+    return {
+      rotation: {
+        mode: t.enabled ? "random" : "none",
+        range: t.range
+      }
+    };
+}
+function Nt(n) {
+  var e, i;
+  const t = (i = (e = n.layout) == null ? void 0 : e.sizing) == null ? void 0 : i.variance;
+  if (t)
+    return {
+      sizing: {
+        variance: t
+      }
+    };
+}
+function qt(n = {}) {
+  var s;
+  const t = Wt(n), e = Nt(n);
+  let i = n.image;
+  (t || e) && (i = {
+    ...e || {},
+    ...t || {},
+    ...i
+  }, i.rotation && (t != null && t.rotation) && ((s = n.image) != null && s.rotation) && (i.rotation = {
+    ...t.rotation,
+    ...n.image.rotation
+  }));
+  const o = {
+    loader: { ...b.loader },
+    image: kt($t, i),
+    layout: { ...b.layout },
+    animation: { ...b.animation },
+    interaction: { ...b.interaction },
+    rendering: { ...b.rendering },
+    styling: Gt(Lt, n.styling),
+    debug: b.debug
+  };
+  return n.loader && (o.loader = {
+    ...b.loader,
+    ...n.loader
+  }, n.loader.googleDrive && (o.loader.googleDrive = {
+    ...b.loader.googleDrive,
+    ...n.loader.googleDrive,
+    sources: n.loader.googleDrive.sources || b.loader.googleDrive.sources,
+    allowedExtensions: n.loader.googleDrive.allowedExtensions || b.loader.googleDrive.allowedExtensions
+  }), n.loader.static && (o.loader.static = {
+    ...b.loader.static,
+    ...n.loader.static,
+    sources: n.loader.static.sources || b.loader.static.sources,
+    allowedExtensions: n.loader.static.allowedExtensions || b.loader.static.allowedExtensions
+  })), n.layout && (o.layout = {
+    ...b.layout,
+    ...n.layout
+  }, n.layout.sizing && (o.layout.sizing = {
+    ...b.layout.sizing,
+    ...n.layout.sizing,
+    responsive: n.layout.sizing.responsive || b.layout.sizing.responsive,
+    adaptive: n.layout.sizing.adaptive ? { ...b.layout.sizing.adaptive, ...n.layout.sizing.adaptive } : b.layout.sizing.adaptive
+  }), n.layout.spacing && (o.layout.spacing = {
+    ...b.layout.spacing,
+    ...n.layout.spacing
+  })), n.animation && (o.animation = {
+    ...b.animation,
+    ...n.animation
+  }, n.animation.easing && (o.animation.easing = {
+    ...b.animation.easing,
+    ...n.animation.easing
+  }), n.animation.queue && (o.animation.queue = {
+    ...b.animation.queue,
+    ...n.animation.queue
+  }), n.animation.performance && (o.animation.performance = {
+    ...b.animation.performance,
+    ...n.animation.performance
+  }), n.animation.entry && (o.animation.entry = {
+    ...b.animation.entry,
+    ...n.animation.entry,
+    start: n.animation.entry.start ? {
+      ...b.animation.entry.start,
+      ...n.animation.entry.start,
+      circular: n.animation.entry.start.circular ? { ...b.animation.entry.start.circular, ...n.animation.entry.start.circular } : b.animation.entry.start.circular
+    } : b.animation.entry.start,
+    timing: n.animation.entry.timing ? { ...b.animation.entry.timing, ...n.animation.entry.timing } : b.animation.entry.timing,
+    path: n.animation.entry.path ? { ...It, ...n.animation.entry.path } : b.animation.entry.path,
+    rotation: n.animation.entry.rotation ? { ...Rt, ...n.animation.entry.rotation } : b.animation.entry.rotation,
+    scale: n.animation.entry.scale ? { ...Et, ...n.animation.entry.scale } : b.animation.entry.scale
+  })), n.interaction && (o.interaction = {
+    ...b.interaction,
+    ...n.interaction
+  }, n.interaction.focus && (o.interaction.focus = {
+    ...b.interaction.focus,
+    ...n.interaction.focus
+  }), n.interaction.navigation && (o.interaction.navigation = {
+    ...b.interaction.navigation,
+    ...n.interaction.navigation
+  }), n.interaction.gestures && (o.interaction.gestures = {
+    ...b.interaction.gestures,
+    ...n.interaction.gestures
+  })), n.rendering && (o.rendering = {
+    ...b.rendering,
+    ...n.rendering
+  }, n.rendering.responsive && (o.rendering.responsive = {
+    ...b.rendering.responsive,
+    ...n.rendering.responsive,
+    breakpoints: n.rendering.responsive.breakpoints ? { ...b.rendering.responsive.breakpoints, ...n.rendering.responsive.breakpoints } : b.rendering.responsive.breakpoints,
+    mobileDetection: n.rendering.responsive.mobileDetection ? n.rendering.responsive.mobileDetection : b.rendering.responsive.mobileDetection
+  }), n.rendering.ui && (o.rendering.ui = {
+    ...b.rendering.ui,
+    ...n.rendering.ui
+  }), n.rendering.performance && (o.rendering.performance = {
+    ...b.rendering.performance,
+    ...n.rendering.performance
+  })), n.debug !== void 0 && (o.debug = n.debug), o;
+}
+function Yt(n, t) {
+  return { ...n ? zt[n] : zt.playful, ...t };
+}
+function Xt(n, t) {
+  return { ...n ? Tt[n] : Tt.gentle, ...t };
+}
+function Bt(n, t) {
+  return { ...n ? Mt[n] : Mt.gentle, ...t };
+}
+class Vt {
+  constructor(t) {
+    this.activeAnimations = /* @__PURE__ */ new Map(), this.animationIdCounter = 0, this.config = t;
+  }
+  /**
+   * Build transform string from transform params
+   * Always starts with centering transform to match image positioning system
+   */
+  buildTransformString(t) {
+    const e = ["translate(-50%, -50%)"];
+    if (t.x !== void 0 || t.y !== void 0) {
+      const i = t.x ?? 0, o = t.y ?? 0;
+      e.push(`translate(${i}px, ${o}px)`);
+    }
+    return t.rotation !== void 0 && e.push(`rotate(${t.rotation}deg)`), t.scale !== void 0 && e.push(`scale(${t.scale})`), e.join(" ");
+  }
+  /**
+   * Start a cancellable transform animation using Web Animations API
+   * @param element - The element to animate
+   * @param from - Starting transform state
+   * @param to - Ending transform state
+   * @param duration - Animation duration in ms (optional)
+   * @param easing - CSS easing function (optional)
+   * @returns AnimationHandle that can be used to cancel or query the animation
+   */
+  animateTransformCancellable(t, e, i, o = null, s = null) {
+    this.cancelAllAnimations(t);
+    const c = o ?? this.config.duration, a = s ?? this.config.easing.default, h = this.buildTransformString(e), l = this.buildTransformString(i);
+    t.style.transition = "none";
+    const g = t.animate(
+      [
+        { transform: h },
+        { transform: l }
+      ],
+      {
+        duration: c,
+        easing: a,
+        fill: "forwards"
+        // Keep final state after animation
+      }
+    ), r = {
+      id: `anim-${++this.animationIdCounter}`,
+      element: t,
+      animation: g,
+      fromState: e,
+      toState: i,
+      startTime: performance.now(),
+      duration: c
+    };
+    return this.activeAnimations.set(t, r), g.finished.then(() => {
+      t.style.transform = l, this.activeAnimations.delete(t);
+    }).catch(() => {
+      this.activeAnimations.delete(t);
+    }), r;
+  }
+  /**
+   * Cancel an active animation
+   * @param handle - The animation handle to cancel
+   * @param commitStyle - If true, keeps current position; if false, no style change
+   * @returns Snapshot of where the animation was when cancelled
+   */
+  cancelAnimation(t, e = !0) {
+    const i = this.getCurrentTransform(t.element);
+    if (t.animation.cancel(), e) {
+      const o = this.buildTransformString({
+        x: i.x,
+        y: i.y,
+        rotation: i.rotation,
+        scale: i.scale
+      });
+      t.element.style.transform = o;
+    }
+    return this.activeAnimations.delete(t.element), i;
+  }
+  /**
+   * Cancel all animations on an element
+   * Uses Web Animations API to find and cancel ALL animations, not just tracked ones
+   * @param element - The element to cancel animations for
+   */
+  cancelAllAnimations(t) {
+    const e = this.activeAnimations.get(t);
+    e && this.cancelAnimation(e, !1);
+    const i = t.getAnimations();
+    for (const o of i)
+      o.cancel();
+  }
+  /**
+   * Get current transform state of an element (works mid-animation)
+   * Uses DOMMatrix to parse the computed transform
+   * @param element - The element to query
+   * @returns Current transform snapshot
+   */
+  getCurrentTransform(t) {
+    const i = getComputedStyle(t).transform;
+    if (i === "none" || !i)
+      return { x: 0, y: 0, rotation: 0, scale: 1 };
+    const o = new DOMMatrix(i), s = Math.sqrt(o.a * o.a + o.b * o.b), c = Math.atan2(o.b, o.a) * (180 / Math.PI), a = o.e, h = o.f;
+    return { x: a, y: h, rotation: c, scale: s };
+  }
+  /**
+   * Check if an element has an active animation
+   * @param element - The element to check
+   * @returns True if animation is in progress
+   */
+  hasActiveAnimation(t) {
+    return this.activeAnimations.has(t);
+  }
+  /**
+   * Get animation handle for an element if it exists
+   * @param element - The element to query
+   * @returns AnimationHandle or undefined
+   */
+  getAnimationHandle(t) {
+    return this.activeAnimations.get(t);
+  }
+  /**
+   * Animate element transform with smooth easing (CSS transitions - legacy method)
+   * @param element - The element to animate
+   * @param properties - Transform properties {x, y, rotation, scale}
+   * @param duration - Animation duration in ms (optional)
+   * @param easing - CSS easing function (optional)
+   * @returns Promise that resolves when animation completes
+   */
+  animateTransform(t, e, i = null, o = null) {
+    return new Promise((s) => {
+      const c = i ?? this.config.duration, a = o ?? this.config.easing.default;
+      t.style.transition = `transform ${c}ms ${a}, box-shadow ${c}ms ${a}`, t.style.transform = this.buildTransformString(e), setTimeout(() => {
+        s();
+      }, c);
+    });
+  }
+  /**
+   * Reset element to its original transform
+   * @param element - The element to reset
+   * @param originalState - Original transform state {x, y, rotation, scale}
+   * @returns Promise that resolves when animation completes
+   */
+  resetTransform(t, e) {
+    return this.animateTransform(t, e);
+  }
+  /**
+   * Remove transition styles from element
+   * @param element - The element to clear
+   */
+  clearTransition(t) {
+    t.style.transition = "";
+  }
+  /**
+   * Utility: Wait for a specified duration
+   * @param ms - Milliseconds to wait
+   * @returns Promise that resolves after the specified duration
+   */
+  wait(t) {
+    return new Promise((e) => setTimeout(e, t));
+  }
+}
+function st(n, t, e) {
+  return n + (t - n) * e;
+}
+function Jt(n, t, e, i) {
+  const { overshoot: o, bounces: s, decayRatio: c } = i, a = e.x - t.x, h = e.y - t.y, l = Zt(s, c);
+  let g = 0, r = 0, d = 1, f = o, y = !1;
+  for (let u = 0; u < l.length; u++)
+    if (n <= l[u].time) {
+      r = u === 0 ? 0 : l[u - 1].time, d = l[u].time, f = l[u].overshoot, y = l[u].isOvershoot;
+      break;
+    }
+  const p = (n - r) / (d - r);
+  if (y)
+    g = 1 + f * ut(p);
+  else if (r === 0)
+    g = ut(p);
+  else {
+    const u = l.find(
+      (w, v) => w.time > r && v > 0 && l[v - 1].isOvershoot
+    ), m = 1 + ((u == null ? void 0 : u.overshoot) || f);
+    g = st(m, 1, ut(p));
+  }
+  return {
+    x: t.x + a * g,
+    y: t.y + h * g
+  };
+}
+function Zt(n, t) {
+  const e = [];
+  let i = 0.6;
+  e.push({ time: i, overshoot: 0, isOvershoot: !1 });
+  let o = 0.15;
+  const c = 0.4 / (n * 2);
+  for (let a = 0; a < n; a++)
+    i += c, e.push({ time: i, overshoot: o, isOvershoot: !0 }), i += c, e.push({ time: i, overshoot: o * t, isOvershoot: !1 }), o *= t;
+  return e.push({ time: 1, overshoot: 0, isOvershoot: !1 }), e;
+}
+function Qt(n, t, e, i) {
+  const { stiffness: o, damping: s, mass: c, oscillations: a } = i, h = e.x - t.x, l = e.y - t.y, g = Math.sqrt(o / c), r = s / (2 * Math.sqrt(o * c));
+  let d;
+  if (r < 1) {
+    const f = g * Math.sqrt(1 - r * r), y = Math.exp(-r * g * n * 3), p = Math.cos(f * n * a * Math.PI);
+    d = 1 - y * p;
+  } else
+    d = 1 - Math.exp(-g * n * 3);
+  return d = Math.max(0, Math.min(d, 1.3)), {
+    x: t.x + h * d,
+    y: t.y + l * d
+  };
+}
+function Kt(n, t, e, i) {
+  const { amplitude: o, frequency: s, decay: c, decayRate: a, phase: h } = i, l = e.x - t.x, g = e.y - t.y, r = Math.sqrt(l * l + g * g), d = r > 0 ? -g / r : 0, f = r > 0 ? l / r : 1, y = s * Math.PI * 2 * n + h, p = c ? Math.pow(1 - n, a) : 1, u = o * Math.sin(y) * p, m = te(n);
+  return {
+    x: st(t.x, e.x, m) + u * d,
+    y: st(t.y, e.y, m) + u * f
+  };
+}
+function ut(n) {
+  return 1 - (1 - n) * (1 - n);
+}
+function te(n) {
+  return 1 - Math.pow(1 - n, 3);
+}
+function ee(n, t, e) {
+  const { amplitude: i, frequency: o, decay: s } = e, c = Math.sin(n * o * Math.PI * 2), a = s ? Math.pow(1 - n, 2) : 1, h = i * c * a;
+  return t + h;
+}
+function ie(n, t, e) {
+  const { overshoot: i, bounces: o } = e, s = [];
+  s.push({ time: 0.5, scale: i });
+  let c = i;
+  const a = 0.5, l = 0.5 / (o * 2);
+  let g = 0.5;
+  for (let d = 0; d < o; d++) {
+    const f = 1 - (c - 1) * a;
+    g += l, s.push({ time: g, scale: f }), c = 1 + (c - 1) * a * a, g += l, d < o - 1 && s.push({ time: g, scale: c });
+  }
+  s.push({ time: 1, scale: 1 });
+  let r = 1;
+  for (let d = 0; d < s.length; d++)
+    if (n <= s[d].time) {
+      const f = d === 0 ? 0 : s[d - 1].time, y = d === 0 ? 1 : s[d - 1].scale, p = (n - f) / (s[d].time - f), u = ut(p);
+      r = y + (s[d].scale - y) * u;
+      break;
+    }
+  return r * t;
+}
+function ne(n) {
+  const {
+    element: t,
+    startPosition: e,
+    endPosition: i,
+    pathConfig: o,
+    duration: s,
+    imageWidth: c,
+    imageHeight: a,
+    rotation: h,
+    scale: l,
+    onComplete: g,
+    rotationConfig: r,
+    startRotation: d,
+    scaleConfig: f,
+    startScale: y
+  } = n, p = o.type, u = d !== void 0 && d !== h, m = (r == null ? void 0 : r.mode) === "wobble", w = (r == null ? void 0 : r.wobble) || { amplitude: 15, frequency: 3, decay: !0 }, v = u || m, E = y !== void 0 && y !== l, M = (f == null ? void 0 : f.mode) === "pop", x = (f == null ? void 0 : f.pop) || { overshoot: 1.2, bounces: 1 };
+  if ((p === "linear" || p === "arc") && !v && !(E || M)) {
+    g && g();
+    return;
+  }
+  const G = performance.now(), j = -c / 2, P = -a / 2;
+  function U(k) {
+    const F = k - G, I = Math.min(F / s, 1);
+    let A;
+    switch (p) {
+      case "bounce": {
+        const D = Yt(
+          o.bouncePreset,
+          o.bounce
+        );
+        A = Jt(I, e, i, D);
+        break;
+      }
+      case "elastic": {
+        const D = Xt(
+          o.elasticPreset,
+          o.elastic
+        );
+        A = Qt(I, e, i, D);
+        break;
+      }
+      case "wave": {
+        const D = Bt(
+          o.wavePreset,
+          o.wave
+        );
+        A = Kt(I, e, i, D);
+        break;
+      }
+      default:
+        A = {
+          x: st(e.x, i.x, I),
+          y: st(e.y, i.y, I)
+        };
+    }
+    const O = A.x - i.x, S = A.y - i.y;
+    let z;
+    m ? z = ee(I, h, w) : u ? z = st(d, h, I) : z = h;
+    let T;
+    M ? T = ie(I, l, x) : E ? T = st(y, l, I) : T = l, t.style.transform = `translate(${j}px, ${P}px) translate(${O}px, ${S}px) rotate(${z}deg) scale(${T})`, I < 1 ? requestAnimationFrame(U) : (t.style.transform = `translate(${j}px, ${P}px) rotate(${h}deg) scale(${l})`, g && g());
+  }
+  requestAnimationFrame(U);
+}
+function oe(n) {
+  return n === "bounce" || n === "elastic" || n === "wave";
+}
+const se = {
+  radial: "center",
+  spiral: "center",
+  grid: "top",
+  cluster: "nearest-edge",
+  random: "nearest-edge",
+  wave: "left"
+};
+class ae {
+  constructor(t, e) {
+    this.config = t, this.layoutAlgorithm = e, this.resolvedStartPosition = this.resolveStartPosition(), this.pathConfig = t.path || It, this.rotationConfig = t.rotation || Rt, this.scaleConfig = t.scale || Et;
+  }
+  /**
+   * Get the effective start position, considering layout-aware defaults
+   */
+  resolveStartPosition() {
+    return this.config.start.position ? this.config.start.position : se[this.layoutAlgorithm] || "nearest-edge";
+  }
+  /**
+   * Calculate the starting position for an image's entry animation
+   */
+  calculateStartPosition(t, e, i, o, s) {
+    const c = this.resolvedStartPosition, a = this.config.start.offset ?? 100;
+    switch (c) {
+      case "nearest-edge":
+        return this.calculateNearestEdge(t, e, i, a);
+      case "top":
+        return this.calculateEdgePosition("top", t, e, i, a);
+      case "bottom":
+        return this.calculateEdgePosition("bottom", t, e, i, a);
+      case "left":
+        return this.calculateEdgePosition("left", t, e, i, a);
+      case "right":
+        return this.calculateEdgePosition("right", t, e, i, a);
+      case "center":
+        return this.calculateCenterPosition(i, t, e);
+      case "random-edge":
+        return this.calculateRandomEdge(t, e, i, a);
+      case "circular":
+        return this.calculateCircularPosition(
+          t,
+          e,
+          i,
+          o,
+          s
+        );
+      default:
+        return this.calculateNearestEdge(t, e, i, a);
+    }
+  }
+  /**
+   * Calculate start position from the nearest edge (current default behavior)
+   */
+  calculateNearestEdge(t, e, i, o) {
+    const s = t.x, c = t.y, a = s, h = i.width - s, l = c, g = i.height - c, r = Math.min(a, h, l, g);
+    let d = t.x, f = t.y;
+    return r === a ? d = -(e.width + o) : r === h ? d = i.width + o : r === l ? f = -(e.height + o) : f = i.height + o, { x: d, y: f };
+  }
+  /**
+   * Calculate start position from a specific edge
+   */
+  calculateEdgePosition(t, e, i, o, s) {
+    let c = e.x, a = e.y;
+    switch (t) {
+      case "top":
+        a = -(i.height + s);
+        break;
+      case "bottom":
+        a = o.height + s;
+        break;
+      case "left":
+        c = -(i.width + s);
+        break;
+      case "right":
+        c = o.width + s;
+        break;
+    }
+    return { x: c, y: a };
+  }
+  /**
+   * Calculate start position from center with scale animation
+   */
+  calculateCenterPosition(t, e, i) {
+    const o = t.width / 2, s = t.height / 2;
+    return {
+      x: o,
+      y: s,
+      useScale: !0
+      // Signal to use scale animation from 0
+    };
+  }
+  /**
+   * Calculate start position from a random edge
+   */
+  calculateRandomEdge(t, e, i, o) {
+    const s = ["top", "bottom", "left", "right"], c = s[Math.floor(Math.random() * s.length)];
+    return this.calculateEdgePosition(c, t, e, i, o);
+  }
+  /**
+   * Calculate start position on a circle around the container
+   */
+  calculateCircularPosition(t, e, i, o, s) {
+    const c = this.config.start.circular || {}, a = c.distribution || "even";
+    let h;
+    const l = c.radius || "120%";
+    if (typeof l == "string" && l.endsWith("%")) {
+      const p = parseFloat(l) / 100;
+      h = Math.sqrt(
+        i.width ** 2 + i.height ** 2
+      ) * p / 2;
+    } else
+      h = typeof l == "number" ? l : 500;
+    let g;
+    a === "even" ? g = o / s * 2 * Math.PI : g = Math.random() * 2 * Math.PI;
+    const r = i.width / 2, d = i.height / 2, f = r + Math.cos(g) * h, y = d + Math.sin(g) * h;
+    return { x: f, y };
+  }
+  /**
+   * Get animation parameters for an image
+   */
+  getAnimationParams(t) {
+    const e = this.config.timing.duration, i = this.config.timing.stagger, o = this.config.easing;
+    return {
+      startTransform: "",
+      // Will be computed by caller based on start position
+      duration: e,
+      delay: t * i,
+      easing: o
+    };
+  }
+  /**
+   * Build a CSS transform string for the start position
+   * Uses pixel-based centering offset for reliable cross-browser behavior
+   */
+  buildStartTransform(t, e, i, o, s, c, a, h) {
+    const l = t.x - e.x, g = t.y - e.y, r = a !== void 0 ? a : i, d = h !== void 0 ? h : o, f = s !== void 0 ? -s / 2 : 0, y = c !== void 0 ? -c / 2 : 0, p = s !== void 0 ? `translate(${f}px, ${y}px)` : "translate(-50%, -50%)";
+    return t.useScale ? `${p} translate(${l}px, ${g}px) rotate(${r}deg) scale(0)` : `${p} translate(${l}px, ${g}px) rotate(${r}deg) scale(${d})`;
+  }
+  /**
+   * Build the final CSS transform string
+   * Uses pixel-based centering offset for reliable cross-browser behavior
+   */
+  buildFinalTransform(t, e, i, o) {
+    if (i !== void 0 && o !== void 0) {
+      const s = -i / 2, c = -o / 2;
+      return `translate(${s}px, ${c}px) rotate(${t}deg) scale(${e})`;
+    }
+    return `translate(-50%, -50%) rotate(${t}deg) scale(${e})`;
+  }
+  /**
+   * Get the transition CSS for entry animation
+   * For JS-animated paths, only animate opacity (transform handled by JS)
+   */
+  getTransitionCSS() {
+    const t = this.config.timing.duration, e = this.config.easing;
+    return this.requiresJSAnimation() ? `opacity ${t}ms ease-out` : `opacity ${t}ms ease-out, transform ${t}ms ${e}`;
+  }
+  /**
+   * Check if the current path type requires JavaScript animation
+   */
+  requiresJSAnimation() {
+    return oe(this.pathConfig.type);
+  }
+  /**
+   * Get the path configuration
+   */
+  getPathConfig() {
+    return this.pathConfig;
+  }
+  /**
+   * Get the path type
+   */
+  getPathType() {
+    return this.pathConfig.type;
+  }
+  /**
+   * Get animation timing configuration
+   */
+  getTiming() {
+    return {
+      duration: this.config.timing.duration,
+      stagger: this.config.timing.stagger
+    };
+  }
+  /**
+   * Get the rotation configuration
+   */
+  getRotationConfig() {
+    return this.rotationConfig;
+  }
+  /**
+   * Get the rotation mode
+   */
+  getRotationMode() {
+    return this.rotationConfig.mode;
+  }
+  /**
+   * Calculate the starting rotation for an entry animation
+   * @param finalRotation - The final rotation from the layout
+   * @returns The starting rotation in degrees
+   */
+  calculateStartRotation(t) {
+    switch (this.rotationConfig.mode) {
+      case "none":
+        return t;
+      case "settle": {
+        const i = this.rotationConfig.startRotation;
+        if (i === void 0)
+          return t + (Math.random() - 0.5) * 60;
+        if (typeof i == "number")
+          return i;
+        const o = i.max - i.min;
+        return i.min + Math.random() * o;
+      }
+      case "spin": {
+        const i = this.rotationConfig.spinCount ?? 1, o = this.resolveSpinDirection(t);
+        return t + i * 360 * o;
+      }
+      case "random":
+        return t + (Math.random() - 0.5) * 60;
+      case "wobble":
+        return t;
+      default:
+        return t;
+    }
+  }
+  /**
+   * Resolve spin direction based on config
+   * @returns 1 for clockwise, -1 for counterclockwise
+   */
+  resolveSpinDirection(t) {
+    switch (this.rotationConfig.direction ?? "auto") {
+      case "clockwise":
+        return -1;
+      case "counterclockwise":
+        return 1;
+      case "random":
+        return Math.random() < 0.5 ? 1 : -1;
+      case "auto":
+      default:
+        return t >= 0 ? 1 : -1;
+    }
+  }
+  /**
+   * Check if the current rotation mode requires JavaScript animation
+   * (as opposed to CSS transitions)
+   */
+  requiresJSRotation() {
+    return this.rotationConfig.mode === "wobble";
+  }
+  /**
+   * Calculate wobble rotation for a given animation progress
+   * @param progress - Animation progress from 0 to 1
+   * @param finalRotation - The final rotation in degrees
+   * @returns The current rotation in degrees
+   */
+  calculateWobbleRotation(t, e) {
+    if (this.rotationConfig.mode !== "wobble")
+      return e;
+    const i = this.rotationConfig.wobble || {
+      amplitude: 15,
+      frequency: 3,
+      decay: !0
+    }, { amplitude: o, frequency: s, decay: c } = i, a = Math.sin(t * s * Math.PI * 2), h = c ? Math.pow(1 - t, 2) : 1, l = o * a * h;
+    return e + l;
+  }
+  /**
+   * Get the scale configuration
+   */
+  getScaleConfig() {
+    return this.scaleConfig;
+  }
+  /**
+   * Get the scale mode
+   */
+  getScaleMode() {
+    return this.scaleConfig.mode;
+  }
+  /**
+   * Calculate the starting scale for an entry animation
+   * @param finalScale - The final scale from the layout
+   * @returns The starting scale
+   */
+  calculateStartScale(t) {
+    switch (this.scaleConfig.mode) {
+      case "none":
+        return t;
+      case "grow":
+        return (this.scaleConfig.startScale ?? 0.3) * t;
+      case "shrink":
+        return (this.scaleConfig.startScale ?? 1.5) * t;
+      case "pop":
+        return t;
+      case "random": {
+        const i = this.scaleConfig.range ?? { min: 0.5, max: 1 };
+        return (i.min + Math.random() * (i.max - i.min)) * t;
+      }
+      default:
+        return t;
+    }
+  }
+  /**
+   * Check if the current scale mode requires JavaScript animation
+   * (as opposed to CSS transitions)
+   */
+  requiresJSScale() {
+    return this.scaleConfig.mode === "pop";
+  }
+  /**
+   * Calculate pop scale for a given animation progress
+   * @param progress - Animation progress from 0 to 1
+   * @param finalScale - The final scale value
+   * @returns The current scale value with bounce effect
+   */
+  calculatePopScale(t, e) {
+    if (this.scaleConfig.mode !== "pop")
+      return e;
+    const i = this.scaleConfig.pop || {
+      overshoot: 1.2,
+      bounces: 1
+    }, { overshoot: o, bounces: s } = i, c = this.generateScaleBounceKeyframes(s, o);
+    let a = e;
+    for (let h = 0; h < c.length; h++)
+      if (t <= c[h].time) {
+        const l = h === 0 ? 0 : c[h - 1].time, g = h === 0 ? e : c[h - 1].scale, r = (t - l) / (c[h].time - l), d = this.easeOutQuad(r);
+        a = g + (c[h].scale - g) * d;
+        break;
+      }
+    return a * e;
+  }
+  /**
+   * Generate keyframes for scale bounce animation
+   */
+  generateScaleBounceKeyframes(t, e) {
+    const i = [];
+    i.push({ time: 0.5, scale: e });
+    let o = e;
+    const s = 0.5, a = 0.5 / (t * 2);
+    let h = 0.5;
+    for (let l = 0; l < t; l++) {
+      const g = 1 - (o - 1) * s;
+      h += a, i.push({ time: h, scale: g }), o = 1 + (o - 1) * s * s, h += a, l < t - 1 && i.push({ time: h, scale: o });
+    }
+    return i.push({ time: 1, scale: 1 }), i;
+  }
+  /**
+   * Easing function for smooth transitions
+   */
+  easeOutQuad(t) {
+    return 1 - (1 - t) * (1 - t);
+  }
+}
+class re {
+  constructor(t, e = {}) {
+    this.config = t, this.imageConfig = e;
+  }
+  /**
+   * Generate random layout positions for images
+   * @param imageCount - Number of images to layout
+   * @param containerBounds - Container dimensions {width, height}
+   * @param options - Optional overrides (includes fixedHeight)
+   * @returns Array of layout objects with position, rotation, scale
+   */
+  generate(t, e, i = {}) {
+    var x, L, G, j, P, U, k, F, I;
+    const o = [], { width: s, height: c } = e, a = this.config.spacing.padding, h = i.fixedHeight ?? this.config.sizing.base, l = ((x = this.imageConfig.rotation) == null ? void 0 : x.mode) ?? "none", g = ((G = (L = this.imageConfig.rotation) == null ? void 0 : L.range) == null ? void 0 : G.min) ?? -15, r = ((P = (j = this.imageConfig.rotation) == null ? void 0 : j.range) == null ? void 0 : P.max) ?? 15, d = ((k = (U = this.imageConfig.sizing) == null ? void 0 : U.variance) == null ? void 0 : k.min) ?? 1, f = ((I = (F = this.imageConfig.sizing) == null ? void 0 : F.variance) == null ? void 0 : I.max) ?? 1, y = d !== 1 || f !== 1, u = h * 1.5 / 2, m = h / 2, w = s - a - u, v = c - a - m, E = a + u, M = a + m;
+    for (let A = 0; A < t; A++) {
+      const O = this.random(E, w), S = this.random(M, v), z = l === "random" ? this.random(g, r) : 0, T = y ? this.random(d, f) : 1, D = h * T, Z = {
+        id: A,
+        x: O,
+        y: S,
+        rotation: z,
+        scale: T,
+        baseSize: D
+      };
+      o.push(Z);
+    }
+    return o;
+  }
+  /**
+   * Utility: Generate random number between min and max
+   * @param min - Minimum value
+   * @param max - Maximum value
+   * @returns Random number in range
+   */
+  random(t, e) {
+    return Math.random() * (e - t) + t;
+  }
+}
+class ce {
+  constructor(t, e = {}) {
+    this.config = t, this.imageConfig = e;
+  }
+  /**
+   * Generate radial layout positions for images
+   * @param imageCount - Number of images to layout
+   * @param containerBounds - Container dimensions {width, height}
+   * @param options - Optional overrides
+   * @returns Array of layout objects with position, rotation, scale
+   */
+  generate(t, e, i = {}) {
+    var L, G, j, P, U, k, F, I, A, O;
+    const o = [], { width: s, height: c } = e, { debugRadials: a } = this.config, h = this.config.sizing.base, l = ((L = this.imageConfig.rotation) == null ? void 0 : L.mode) ?? "none", g = ((j = (G = this.imageConfig.rotation) == null ? void 0 : G.range) == null ? void 0 : j.min) ?? -15, r = ((U = (P = this.imageConfig.rotation) == null ? void 0 : P.range) == null ? void 0 : U.max) ?? 15, d = ((F = (k = this.imageConfig.sizing) == null ? void 0 : k.variance) == null ? void 0 : F.min) ?? 1, f = ((A = (I = this.imageConfig.sizing) == null ? void 0 : I.variance) == null ? void 0 : A.max) ?? 1, y = d !== 1 || f !== 1, p = ((O = this.imageConfig.sizing) == null ? void 0 : O.scaleDecay) ?? 0, u = ["green", "blue", "red", "yellow", "orange", "purple"], m = i.fixedHeight ?? h, w = s / 2, v = c / 2, E = Math.ceil(Math.sqrt(t));
+    if (t > 0) {
+      const S = y ? this.random(d, f) : 1, z = m * S;
+      o.push({
+        id: 0,
+        x: w,
+        y: v,
+        rotation: l === "random" ? this.random(g * 0.33, r * 0.33) : 0,
+        // Less rotation for center
+        scale: S,
+        baseSize: z,
+        zIndex: 100,
+        // Center image is highest
+        borderColor: a ? "cyan" : void 0
+      });
+    }
+    let M = 1, x = 1;
+    for (; M < t; ) {
+      const S = x / E, z = p > 0 ? 1 - S * p * 0.5 : 1, T = x * (m * 0.8), D = T * 1.5, Z = Math.PI * (3 * (D + T) - Math.sqrt((3 * D + T) * (D + 3 * T))), et = this.estimateWidth(m), W = Math.floor(Z / (et * 0.7));
+      if (W === 0) {
+        x++;
+        continue;
+      }
+      const N = 2 * Math.PI / W, it = x * (20 * Math.PI / 180);
+      for (let Q = 0; Q < W && M < t; Q++) {
+        const B = Q * N + it, q = y ? this.random(d, f) : 1, nt = z * q, V = m * nt;
+        let C = w + Math.cos(B) * D, H = v + Math.sin(B) * T;
+        const $ = this.config.spacing.padding ?? 50, K = V * 1.5 / 2, _ = V / 2;
+        C - K < $ ? C = $ + K : C + K > s - $ && (C = s - $ - K), H - _ < $ ? H = $ + _ : H + _ > c - $ && (H = c - $ - _);
+        const tt = l === "random" ? this.random(g, r) : 0;
+        o.push({
+          id: M,
+          x: C,
+          y: H,
+          rotation: tt,
+          scale: nt,
+          baseSize: V,
+          zIndex: Math.max(1, 100 - x),
+          // Outer rings have lower z-index
+          borderColor: a ? u[(x - 1) % u.length] : void 0
+        }), M++;
+      }
+      x++;
+    }
+    return o;
+  }
+  /**
+   * Estimate image width based on height
+   * Assumes landscape aspect ratio (approximately 1.4:1)
+   * @param height - Image height
+   * @returns Estimated width
+   */
+  estimateWidth(t) {
+    return t * 1.4;
+  }
+  /**
+   * Utility: Generate random number between min and max
+   * @param min - Minimum value
+   * @param max - Maximum value
+   * @returns Random number in range
+   */
+  random(t, e) {
+    return Math.random() * (e - t) + t;
+  }
+}
+console.log("[GridPlacementGenerator] Module loaded");
+const le = {
+  columns: "auto",
+  rows: "auto",
+  stagger: "none",
+  jitter: 0,
+  overlap: 0,
+  fillDirection: "row",
+  alignment: "center",
+  gap: 10,
+  overflowOffset: 0.25
+}, Ft = [
+  { x: 1, y: 1 },
+  // bottom-right
+  { x: -1, y: -1 },
+  // upper-left
+  { x: 1, y: -1 },
+  // upper-right
+  { x: -1, y: 1 },
+  // bottom-left
+  { x: -1, y: 0 },
+  // left
+  { x: 1, y: 0 },
+  // right
+  { x: 0, y: -1 },
+  // up
+  { x: 0, y: 1 }
+  // down
+];
+class he {
+  constructor(t, e = {}) {
+    this.config = t, this.imageConfig = e;
+  }
+  /**
+   * Generate grid layout positions for images
+   * @param imageCount - Number of images to layout
+   * @param containerBounds - Container dimensions {width, height}
+   * @param options - Optional overrides (includes fixedHeight)
+   * @returns Array of layout objects with position, rotation, scale
+   */
+  generate(t, e, i = {}) {
+    var et, W, N, it, Q, B, q, nt, V;
+    const o = [], { width: s, height: c } = e, a = { ...le, ...this.config.grid }, h = this.config.spacing.padding, l = i.fixedHeight ?? this.config.sizing.base, g = ((et = this.imageConfig.rotation) == null ? void 0 : et.mode) ?? "none", r = ((N = (W = this.imageConfig.sizing) == null ? void 0 : W.variance) == null ? void 0 : N.min) ?? 1, d = ((Q = (it = this.imageConfig.sizing) == null ? void 0 : it.variance) == null ? void 0 : Q.max) ?? 1, f = r !== 1 || d !== 1, y = s - 2 * h, p = c - 2 * h, { columns: u, rows: m } = this.calculateGridDimensions(
+      t,
+      y,
+      p,
+      l,
+      a
+    ), w = a.stagger === "row", v = a.stagger === "column", E = w ? u + 0.5 : u, M = v ? m + 0.5 : m, x = (y - a.gap * (u - 1)) / E, L = (p - a.gap * (m - 1)) / M, G = w ? x / 2 : 0, j = v ? L / 2 : 0, P = 1 + a.overlap, U = Math.min(x, L) * P, k = i.fixedHeight ? Math.min(i.fixedHeight, U) : U, F = u * x + (u - 1) * a.gap + G, I = m * L + (m - 1) * a.gap + j, A = h + (y - F) / 2, O = h + (p - I) / 2, S = u * m, z = a.columns !== "auto" && a.rows !== "auto", T = z && t > S;
+    console.log("[GridGen] generate called, imageCount:", t, "gridConfig:", JSON.stringify({ columns: a.columns, rows: a.rows })), console.log("[GridGen] cellCount:", S, "hasFixedGrid:", z, "isOverflowMode:", T), typeof window < "u" && (window.__gridOverflowDebug = {
+      gridConfigColumns: a.columns,
+      gridConfigRows: a.rows,
+      columns: u,
+      rows: m,
+      cellCount: S,
+      hasFixedGrid: z,
+      imageCount: t,
+      isOverflowMode: T
+    });
+    const D = T ? new Array(S).fill(0) : [], Z = Math.min(x, L) * a.overflowOffset;
+    for (let C = 0; C < t; C++) {
+      let H, $, Y = 0;
+      if (T && C >= S) {
+        const J = C - S, X = J % S;
+        Y = Math.floor(J / S) + 1, D[X]++, a.fillDirection === "row" ? (H = X % u, $ = Math.floor(X / u)) : ($ = X % m, H = Math.floor(X / m));
+      } else
+        a.fillDirection === "row" ? (H = C % u, $ = Math.floor(C / u)) : ($ = C % m, H = Math.floor(C / m));
+      let K = A + H * (x + a.gap) + x / 2, _ = O + $ * (L + a.gap) + L / 2;
+      if (a.stagger === "row" && $ % 2 === 1 ? K += x / 2 : a.stagger === "column" && H % 2 === 1 && (_ += L / 2), Y > 0) {
+        const J = (Y - 1) % Ft.length, X = Ft[J];
+        K += X.x * Z, _ += X.y * Z;
+      }
+      if (a.jitter > 0) {
+        const J = x / 2 * a.jitter, X = L / 2 * a.jitter;
+        K += this.random(-J, J), _ += this.random(-X, X);
+      }
+      let tt = K, ot = _;
+      if (!T && a.fillDirection === "row") {
+        const J = t % u || u;
+        if ($ === Math.floor((t - 1) / u) && J < u) {
+          const At = J * x + (J - 1) * a.gap;
+          let xt = 0;
+          a.alignment === "center" ? xt = (F - At) / 2 : a.alignment === "end" && (xt = F - At), tt += xt;
+        }
+      }
+      const ft = f ? this.random(r, d) : 1, at = k * ft, dt = at * 1.5 / 2, gt = at / 2, yt = h + dt, bt = s - h - dt, Pt = h + gt, Ut = c - h - gt;
+      tt = Math.max(yt, Math.min(tt, bt)), ot = Math.max(Pt, Math.min(ot, Ut));
+      let vt = 0;
+      if (g === "random") {
+        const J = ((q = (B = this.imageConfig.rotation) == null ? void 0 : B.range) == null ? void 0 : q.min) ?? -15, X = ((V = (nt = this.imageConfig.rotation) == null ? void 0 : nt.range) == null ? void 0 : V.max) ?? 15;
+        a.jitter > 0 ? vt = this.random(J * a.jitter, X * a.jitter) : vt = this.random(J, X);
+      }
+      let wt;
+      T && Y > 0 ? wt = 50 - Y : wt = T ? 100 + C : C + 1, o.push({
+        id: C,
+        x: tt,
+        y: ot,
+        rotation: vt,
+        scale: ft,
+        baseSize: at,
+        zIndex: wt
+      });
+    }
+    return o;
+  }
+  /**
+   * Calculate optimal grid dimensions based on image count and container
+   */
+  calculateGridDimensions(t, e, i, o, s) {
+    let c, a;
+    if (s.columns !== "auto" && s.rows !== "auto")
+      c = s.columns, a = s.rows;
+    else if (s.columns !== "auto")
+      c = s.columns, a = Math.ceil(t / c);
+    else if (s.rows !== "auto")
+      a = s.rows, c = Math.ceil(t / a);
+    else {
+      const h = e / i;
+      for (c = Math.max(1, Math.round(Math.sqrt(t * h / 1.4))), a = Math.ceil(t / c); c > 1 && (c - 1) * a >= t; )
+        c--;
+    }
+    return { columns: Math.max(1, c), rows: Math.max(1, a) };
+  }
+  /**
+   * Utility: Generate random number between min and max
+   */
+  random(t, e) {
+    return Math.random() * (e - t) + t;
+  }
+}
+const de = Math.PI * (3 - Math.sqrt(5)), ge = {
+  spiralType: "golden",
+  direction: "counterclockwise",
+  tightness: 1,
+  scaleDecay: 0,
+  startAngle: 0
+};
+class ue {
+  constructor(t, e = {}) {
+    this.config = t, this.imageConfig = e;
+  }
+  /**
+   * Generate spiral layout positions for images
+   * @param imageCount - Number of images to layout
+   * @param containerBounds - Container dimensions {width, height}
+   * @param options - Optional overrides (includes fixedHeight)
+   * @returns Array of layout objects with position, rotation, scale
+   */
+  generate(t, e, i = {}) {
+    var M, x, L, G, j, P, U, k, F, I;
+    const o = [], { width: s, height: c } = e, a = { ...ge, ...this.config.spiral }, h = this.config.spacing.padding, l = i.fixedHeight ?? this.config.sizing.base, g = ((M = this.imageConfig.rotation) == null ? void 0 : M.mode) ?? "none", r = ((L = (x = this.imageConfig.rotation) == null ? void 0 : x.range) == null ? void 0 : L.min) ?? -15, d = ((j = (G = this.imageConfig.rotation) == null ? void 0 : G.range) == null ? void 0 : j.max) ?? 15, f = ((U = (P = this.imageConfig.sizing) == null ? void 0 : P.variance) == null ? void 0 : U.min) ?? 1, y = ((F = (k = this.imageConfig.sizing) == null ? void 0 : k.variance) == null ? void 0 : F.max) ?? 1, p = f !== 1 || y !== 1, u = ((I = this.imageConfig.sizing) == null ? void 0 : I.scaleDecay) ?? a.scaleDecay, m = s / 2, w = c / 2, v = Math.min(
+      m - h - l / 2,
+      w - h - l / 2
+    ), E = a.direction === "clockwise" ? -1 : 1;
+    for (let A = 0; A < t; A++) {
+      let O, S;
+      if (a.spiralType === "golden")
+        O = A * de * E + a.startAngle, S = this.calculateGoldenRadius(A, t, v, a.tightness);
+      else if (a.spiralType === "archimedean") {
+        const _ = A * 0.5 * a.tightness;
+        O = _ * E + a.startAngle, S = this.calculateArchimedeanRadius(_, t, v, a.tightness);
+      } else {
+        const _ = A * 0.3 * a.tightness;
+        O = _ * E + a.startAngle, S = this.calculateLogarithmicRadius(_, t, v, a.tightness);
+      }
+      const z = m + Math.cos(O) * S, T = w + Math.sin(O) * S, D = S / v, Z = u > 0 ? 1 - D * u * 0.5 : 1, et = p ? this.random(f, y) : 1, W = Z * et, N = l * W, Q = N * 1.5 / 2, B = N / 2, q = h + Q, nt = s - h - Q, V = h + B, C = c - h - B, H = Math.max(q, Math.min(z, nt)), $ = Math.max(V, Math.min(T, C));
+      let Y = 0;
+      if (g === "random") {
+        const _ = O * 180 / Math.PI % 360, tt = this.random(r, d);
+        Y = a.spiralType === "golden" ? tt : _ * 0.1 + tt * 0.9;
+      } else g === "tangent" && (Y = this.calculateSpiralTangent(O, S, a));
+      const K = t - A;
+      o.push({
+        id: A,
+        x: H,
+        y: $,
+        rotation: Y,
+        scale: W,
+        baseSize: N,
+        zIndex: K
+      });
+    }
+    return o;
+  }
+  /**
+   * Calculate tangent angle for spiral curve at given position
+   * This aligns the image along the spiral's direction of travel
+   */
+  calculateSpiralTangent(t, e, i) {
+    let o;
+    if (i.spiralType === "golden")
+      o = t + Math.PI / 2;
+    else if (i.spiralType === "archimedean") {
+      const c = 1 / i.tightness, a = Math.atan(e / c);
+      o = t + a;
+    } else {
+      const c = 0.15 / i.tightness, a = Math.atan(1 / c);
+      o = t + a;
+    }
+    return o * 180 / Math.PI % 360 - 90;
+  }
+  /**
+   * Calculate radius for golden spiral (Vogel's model)
+   * Creates even distribution like sunflower seeds
+   */
+  calculateGoldenRadius(t, e, i, o) {
+    const c = i / Math.sqrt(e) * Math.sqrt(t) / o;
+    return Math.min(c, i);
+  }
+  /**
+   * Calculate radius for Archimedean spiral
+   * r = a + b*θ (constant spacing between arms)
+   */
+  calculateArchimedeanRadius(t, e, i, o) {
+    const s = e * 0.5 * o;
+    return t / s * i;
+  }
+  /**
+   * Calculate radius for logarithmic (equiangular) spiral
+   * r = a * e^(b*θ)
+   */
+  calculateLogarithmicRadius(t, e, i, o) {
+    const s = i * 0.05, c = 0.15 / o, a = s * Math.exp(c * t), h = e * 0.3 * o, l = s * Math.exp(c * h);
+    return a / l * i;
+  }
+  /**
+   * Utility: Generate random number between min and max
+   */
+  random(t, e) {
+    return Math.random() * (e - t) + t;
+  }
+}
+const me = {
+  clusterCount: "auto",
+  clusterSpread: 150,
+  clusterSpacing: 200,
+  density: "uniform",
+  overlap: 0.3,
+  distribution: "gaussian"
+};
+class fe {
+  constructor(t, e = {}) {
+    this.config = t, this.imageConfig = e;
+  }
+  /**
+   * Generate cluster layout positions for images
+   * @param imageCount - Number of images to layout
+   * @param containerBounds - Container dimensions {width, height}
+   * @param options - Optional overrides (includes fixedHeight)
+   * @returns Array of layout objects with position, rotation, scale
+   */
+  generate(t, e, i = {}) {
+    var E, M, x, L, G, j, P, U, k;
+    const o = [], { width: s, height: c } = e, a = { ...me, ...this.config.cluster }, h = this.config.spacing.padding, l = i.fixedHeight ?? this.config.sizing.base, g = ((E = this.imageConfig.rotation) == null ? void 0 : E.mode) ?? "none", r = ((x = (M = this.imageConfig.rotation) == null ? void 0 : M.range) == null ? void 0 : x.min) ?? -15, d = ((G = (L = this.imageConfig.rotation) == null ? void 0 : L.range) == null ? void 0 : G.max) ?? 15, f = ((P = (j = this.imageConfig.sizing) == null ? void 0 : j.variance) == null ? void 0 : P.min) ?? 1, y = ((k = (U = this.imageConfig.sizing) == null ? void 0 : U.variance) == null ? void 0 : k.max) ?? 1, p = f !== 1 || y !== 1, u = this.calculateClusterCount(
+      t,
+      a.clusterCount,
+      s,
+      c,
+      a.clusterSpacing
+    ), m = this.generateClusterCenters(
+      u,
+      s,
+      c,
+      h,
+      a
+    ), w = new Array(u).fill(0);
+    for (let F = 0; F < t; F++)
+      w[F % u]++;
+    let v = 0;
+    for (let F = 0; F < u; F++) {
+      const I = m[F], A = w[F];
+      for (let O = 0; O < A; O++) {
+        let S, z;
+        if (a.distribution === "gaussian")
+          S = this.gaussianRandom() * I.spread, z = this.gaussianRandom() * I.spread;
+        else {
+          const $ = this.random(0, Math.PI * 2), Y = this.random(0, I.spread);
+          S = Math.cos($) * Y, z = Math.sin($) * Y;
+        }
+        const T = 1 + a.overlap * 0.5, D = 1 + a.overlap * 0.3;
+        S /= T, z /= T;
+        const Z = p ? this.random(f, y) : 1, et = D * Z, W = l * et;
+        let N = I.x + S, it = I.y + z;
+        const B = W * 1.5 / 2, q = W / 2;
+        N = Math.max(h + B, Math.min(N, s - h - B)), it = Math.max(h + q, Math.min(it, c - h - q));
+        const nt = g === "random" ? this.random(r, d) : 0, C = Math.sqrt(S * S + z * z) / I.spread, H = Math.round((1 - C) * 50) + 1;
+        o.push({
+          id: v,
+          x: N,
+          y: it,
+          rotation: nt,
+          scale: et,
+          baseSize: W,
+          zIndex: H
+        }), v++;
+      }
+    }
+    return o;
+  }
+  /**
+   * Calculate optimal number of clusters based on image count and container
+   */
+  calculateClusterCount(t, e, i, o, s) {
+    if (e !== "auto")
+      return Math.max(1, Math.min(e, t));
+    const a = Math.max(1, Math.ceil(t / 8)), h = Math.floor(
+      i / s * (o / s) * 0.6
+    );
+    return Math.max(1, Math.min(a, h, 10));
+  }
+  /**
+   * Generate cluster center positions with spacing constraints
+   */
+  generateClusterCenters(t, e, i, o, s) {
+    const c = [], h = o + s.clusterSpread, l = e - o - s.clusterSpread, g = o + s.clusterSpread, r = i - o - s.clusterSpread;
+    for (let d = 0; d < t; d++) {
+      let f = null, y = -1;
+      for (let p = 0; p < 100; p++) {
+        const u = {
+          x: this.random(h, l),
+          y: this.random(g, r),
+          spread: this.calculateClusterSpread(s)
+        };
+        let m = 1 / 0;
+        for (const w of c) {
+          const v = u.x - w.x, E = u.y - w.y, M = Math.sqrt(v * v + E * E);
+          m = Math.min(m, M);
+        }
+        if ((c.length === 0 || m > y) && (f = u, y = m), m >= s.clusterSpacing)
+          break;
+      }
+      f && c.push(f);
+    }
+    return c;
+  }
+  /**
+   * Calculate spread for a cluster (may vary if density='varied')
+   */
+  calculateClusterSpread(t) {
+    return t.density === "uniform" ? t.clusterSpread : t.clusterSpread * this.random(0.5, 1.5);
+  }
+  /**
+   * Generate a random number with approximately Gaussian distribution
+   * Using Box-Muller transform
+   */
+  gaussianRandom() {
+    let t = 0, e = 0;
+    for (; t === 0; ) t = Math.random();
+    for (; e === 0; ) e = Math.random();
+    const i = Math.sqrt(-2 * Math.log(t)) * Math.cos(2 * Math.PI * e);
+    return Math.max(-3, Math.min(3, i)) / 3;
+  }
+  /**
+   * Utility: Generate random number between min and max
+   */
+  random(t, e) {
+    return Math.random() * (e - t) + t;
+  }
+}
+class pe {
+  constructor(t, e = {}) {
+    this.config = t, this.imageConfig = e;
+  }
+  /**
+   * Generate wave layout positions for images
+   * @param imageCount - Number of images to layout
+   * @param containerBounds - Container dimensions {width, height}
+   * @param options - Optional overrides
+   * @returns Array of layout objects with position, rotation, scale
+   */
+  generate(t, e, i = {}) {
+    var T, D, Z, et, W, N, it, Q, B;
+    const o = [], { width: s, height: c } = e, a = this.config.sizing.base, h = this.config.spacing.padding ?? 50, l = ((T = this.imageConfig.rotation) == null ? void 0 : T.mode) ?? "none", g = ((Z = (D = this.imageConfig.rotation) == null ? void 0 : D.range) == null ? void 0 : Z.min) ?? -15, r = ((W = (et = this.imageConfig.rotation) == null ? void 0 : et.range) == null ? void 0 : W.max) ?? 15, d = ((it = (N = this.imageConfig.sizing) == null ? void 0 : N.variance) == null ? void 0 : it.min) ?? 1, f = ((B = (Q = this.imageConfig.sizing) == null ? void 0 : Q.variance) == null ? void 0 : B.max) ?? 1, y = d !== 1 || f !== 1, p = i.fixedHeight ?? a, u = {
+      ...Ht,
+      ...this.config.wave
+    }, { rows: m, amplitude: w, frequency: v, phaseShift: E, synchronization: M } = u, x = Math.ceil(t / m), j = p * 1.5 / 2, P = h + j, U = s - h - j, k = U - P, F = x > 1 ? k / (x - 1) : 0, I = h + w + p / 2, A = c - h - w - p / 2, O = A - I, S = m > 1 ? O / (m - 1) : 0;
+    let z = 0;
+    for (let q = 0; q < m && z < t; q++) {
+      const nt = m === 1 ? (I + A) / 2 : I + q * S;
+      let V = 0;
+      M === "offset" ? V = q * E : M === "alternating" && (V = q * Math.PI);
+      for (let C = 0; C < x && z < t; C++) {
+        const H = x === 1 ? (P + U) / 2 : P + C * F, $ = this.calculateWaveY(H, s, w, v, V), Y = H, K = nt + $, _ = y ? this.random(d, f) : 1, tt = p * _;
+        let ot = 0;
+        l === "tangent" ? ot = this.calculateRotation(H, s, w, v, V) : l === "random" && (ot = this.random(g, r));
+        const at = tt * 1.5 / 2, pt = tt / 2, dt = h + at, gt = s - h - at, yt = h + pt, bt = c - h - pt;
+        o.push({
+          id: z,
+          x: Math.max(dt, Math.min(Y, gt)),
+          y: Math.max(yt, Math.min(K, bt)),
+          rotation: ot,
+          scale: _,
+          baseSize: tt,
+          zIndex: z + 1
+        }), z++;
+      }
+    }
+    return o;
+  }
+  /**
+   * Calculate Y position displacement on wave curve
+   * @param x - Horizontal position
+   * @param containerWidth - Container width
+   * @param amplitude - Wave amplitude
+   * @param frequency - Wave frequency
+   * @param phase - Phase offset
+   * @returns Y displacement from baseline
+   */
+  calculateWaveY(t, e, i, o, s) {
+    const c = t / e;
+    return i * Math.sin(o * c * 2 * Math.PI + s);
+  }
+  /**
+   * Calculate rotation based on wave tangent
+   * @param x - Horizontal position
+   * @param containerWidth - Container width
+   * @param amplitude - Wave amplitude
+   * @param frequency - Wave frequency
+   * @param phase - Phase offset
+   * @returns Rotation angle in degrees
+   */
+  calculateRotation(t, e, i, o, s) {
+    const c = t / e, a = i * o * 2 * Math.PI * Math.cos(o * c * 2 * Math.PI + s) / e;
+    return Math.atan(a) * (180 / Math.PI);
+  }
+  /**
+   * Estimate image width based on height
+  /**
+   * Utility: Generate random number between min and max
+   * @param min - Minimum value
+   * @param max - Maximum value
+   * @returns Random number in range
+   */
+  random(t, e) {
+    return Math.random() * (e - t) + t;
+  }
+}
+class ye {
+  constructor(t) {
+    this.config = t.layout, this.imageConfig = t.image, this.breakpoints = t.breakpoints ?? { mobile: 768 }, this.layouts = /* @__PURE__ */ new Map(), this.generator = this.initGenerator();
+  }
+  /**
+   * Initialize the appropriate generator based on config type
+   * @returns Initialized placement generator
+   */
+  initGenerator() {
+    switch (this.config.algorithm) {
+      case "radial":
+        return new ce(this.config, this.imageConfig);
+      case "grid":
+        return new he(this.config, this.imageConfig);
+      case "spiral":
+        return new ue(this.config, this.imageConfig);
+      case "cluster":
+        return new fe(this.config, this.imageConfig);
+      case "wave":
+        return new pe(this.config, this.imageConfig);
+      case "random":
+      default:
+        return new re(this.config, this.imageConfig);
+    }
+  }
+  /**
+   * Generate layout positions for images
+   * @param imageCount - Number of images to layout
+   * @param containerBounds - Container dimensions {width, height}
+   * @param options - Optional overrides for configuration (e.g. fixedHeight)
+   * @returns Array of layout objects with position, rotation, scale
+   */
+  generateLayout(t, e, i = {}) {
+    const o = this.generator.generate(t, e, i);
+    return o.forEach((s) => {
+      this.layouts.set(s.id, s);
+    }), o;
+  }
+  /**
+   * Get the original layout state for an image
+   * @param imageId - The image ID (number or string)
+   * @returns Original layout state or undefined if not found
+   */
+  getOriginalState(t) {
+    return this.layouts.get(Number(t));
+  }
+  /**
+   * Reset all stored layouts
+   */
+  reset() {
+    this.layouts.clear();
+  }
+  /**
+   * Update config dynamically (useful for responsive changes)
+   * @param newConfig - Updated configuration
+   */
+  updateConfig(t) {
+    t.layout && (Object.assign(this.config, t.layout), t.layout.algorithm && t.layout.algorithm !== this.config.algorithm && (this.generator = this.initGenerator())), t.image && Object.assign(this.imageConfig, t.image), t.breakpoints && (this.breakpoints = t.breakpoints);
+  }
+  /**
+   * Resolve the effective base height based on image config and current viewport
+   * @param viewportWidth - Current viewport width
+   * @returns Resolved base height or undefined if should auto-calculate
+   */
+  resolveBaseHeight(t) {
+    var o;
+    const e = (o = this.imageConfig.sizing) == null ? void 0 : o.baseHeight;
+    if (e === void 0)
+      return;
+    if (typeof e == "number")
+      return e;
+    const i = e;
+    return t <= this.breakpoints.mobile ? i.mobile ?? i.tablet ?? i.default : this.breakpoints.tablet && t <= this.breakpoints.tablet ? i.tablet ?? i.default : i.default;
+  }
+  /**
+   * Calculate adaptive image size based on container dimensions and image count
+   * @param containerBounds - Container dimensions {width, height}
+   * @param imageCount - Number of images to display
+   * @param responsiveHeight - Current responsive breakpoint height (upper bound)
+   * @param viewportWidth - Current viewport width for baseHeight resolution
+   * @returns Calculated sizing result with height
+   */
+  calculateAdaptiveSize(t, e, i, o) {
+    const s = this.config.sizing.adaptive, c = this.resolveBaseHeight(o);
+    if (c !== void 0) {
+      let v = Math.min(c, i);
+      return s && (v = this.clamp(v, s.minSize, s.maxSize)), { height: v };
+    }
+    if (!s || !s.enabled)
+      return { height: i };
+    const { width: a, height: h } = t, { minSize: l, maxSize: g } = s, r = this.config.targetCoverage ?? 0.6, d = this.config.densityFactor ?? 1, p = a * h * r / e;
+    let m = Math.sqrt(p / 1.4);
+    m *= d, m = Math.min(m, i);
+    let w = this.clamp(m, l, g);
+    if (w === l && m < l) {
+      const v = Math.max(l * 0.05, 20);
+      w = Math.max(v, m);
+    }
+    return { height: w };
+  }
+  /**
+   * Utility: Clamp a value between min and max
+   */
+  clamp(t, e, i) {
+    return Math.max(e, Math.min(i, t));
+  }
+}
+var R = /* @__PURE__ */ ((n) => (n.IDLE = "idle", n.FOCUSING = "focusing", n.FOCUSED = "focused", n.UNFOCUSING = "unfocusing", n.CROSS_ANIMATING = "cross_animating", n))(R || {});
+function be(n) {
+  return n in St;
+}
+function ve(n) {
+  return n ? be(n) ? St[n] : n : St.md;
+}
+function we(n) {
+  if (!n) return "";
+  const t = [];
+  if (n.grayscale !== void 0 && t.push(`grayscale(${n.grayscale})`), n.blur !== void 0 && t.push(`blur(${n.blur}px)`), n.brightness !== void 0 && t.push(`brightness(${n.brightness})`), n.contrast !== void 0 && t.push(`contrast(${n.contrast})`), n.saturate !== void 0 && t.push(`saturate(${n.saturate})`), n.opacity !== void 0 && t.push(`opacity(${n.opacity})`), n.sepia !== void 0 && t.push(`sepia(${n.sepia})`), n.hueRotate !== void 0 && t.push(`hue-rotate(${n.hueRotate}deg)`), n.invert !== void 0 && t.push(`invert(${n.invert})`), n.dropShadow !== void 0)
+    if (typeof n.dropShadow == "string")
+      t.push(`drop-shadow(${n.dropShadow})`);
+    else {
+      const e = n.dropShadow;
+      t.push(`drop-shadow(${e.x}px ${e.y}px ${e.blur}px ${e.color})`);
+    }
+  return t.join(" ");
+}
+function ct(n) {
+  if (!n || n.style === "none" || n.width === 0)
+    return "none";
+  const t = n.width ?? 0, e = n.style ?? "solid", i = n.color ?? "#000000";
+  return `${t}px ${e} ${i}`;
+}
+function mt(n) {
+  var s, c;
+  if (!n) return {};
+  const t = {};
+  if (n.borderRadiusTopLeft !== void 0 || n.borderRadiusTopRight !== void 0 || n.borderRadiusBottomRight !== void 0 || n.borderRadiusBottomLeft !== void 0) {
+    const a = ((s = n.border) == null ? void 0 : s.radius) ?? 0;
+    n.borderRadiusTopLeft !== void 0 ? t.borderTopLeftRadius = `${n.borderRadiusTopLeft}px` : a && (t.borderTopLeftRadius = `${a}px`), n.borderRadiusTopRight !== void 0 ? t.borderTopRightRadius = `${n.borderRadiusTopRight}px` : a && (t.borderTopRightRadius = `${a}px`), n.borderRadiusBottomRight !== void 0 ? t.borderBottomRightRadius = `${n.borderRadiusBottomRight}px` : a && (t.borderBottomRightRadius = `${a}px`), n.borderRadiusBottomLeft !== void 0 ? t.borderBottomLeftRadius = `${n.borderRadiusBottomLeft}px` : a && (t.borderBottomLeftRadius = `${a}px`);
+  } else ((c = n.border) == null ? void 0 : c.radius) !== void 0 && (t.borderRadius = `${n.border.radius}px`);
+  if (n.borderTop || n.borderRight || n.borderBottom || n.borderLeft) {
+    const a = n.border || {}, h = { ...a, ...n.borderTop }, l = { ...a, ...n.borderRight }, g = { ...a, ...n.borderBottom }, r = { ...a, ...n.borderLeft };
+    t.borderTop = ct(h), t.borderRight = ct(l), t.borderBottom = ct(g), t.borderLeft = ct(r);
+  } else n.border && (t.border = ct(n.border));
+  n.shadow !== void 0 && (t.boxShadow = ve(n.shadow));
+  const o = we(n.filter);
+  if (o && (t.filter = o), n.opacity !== void 0 && (t.opacity = String(n.opacity)), n.cursor !== void 0 && (t.cursor = n.cursor), n.outline && n.outline.style !== "none" && (n.outline.width ?? 0) > 0) {
+    const a = n.outline.width ?? 0, h = n.outline.style ?? "solid", l = n.outline.color ?? "#000000";
+    t.outline = `${a}px ${h} ${l}`, n.outline.offset !== void 0 && (t.outlineOffset = `${n.outline.offset}px`);
+  }
+  return n.objectFit !== void 0 && (t.objectFit = n.objectFit), n.aspectRatio !== void 0 && (t.aspectRatio = n.aspectRatio), t;
+}
+function lt(n, t) {
+  t.borderRadius !== void 0 && (n.style.borderRadius = t.borderRadius), t.borderTopLeftRadius !== void 0 && (n.style.borderTopLeftRadius = t.borderTopLeftRadius), t.borderTopRightRadius !== void 0 && (n.style.borderTopRightRadius = t.borderTopRightRadius), t.borderBottomRightRadius !== void 0 && (n.style.borderBottomRightRadius = t.borderBottomRightRadius), t.borderBottomLeftRadius !== void 0 && (n.style.borderBottomLeftRadius = t.borderBottomLeftRadius), t.border !== void 0 && (n.style.border = t.border), t.borderTop !== void 0 && (n.style.borderTop = t.borderTop), t.borderRight !== void 0 && (n.style.borderRight = t.borderRight), t.borderBottom !== void 0 && (n.style.borderBottom = t.borderBottom), t.borderLeft !== void 0 && (n.style.borderLeft = t.borderLeft), t.boxShadow !== void 0 && (n.style.boxShadow = t.boxShadow), t.filter !== void 0 && (n.style.filter = t.filter), t.opacity !== void 0 && (n.style.opacity = t.opacity), t.cursor !== void 0 && (n.style.cursor = t.cursor), t.outline !== void 0 && (n.style.outline = t.outline), t.outlineOffset !== void 0 && (n.style.outlineOffset = t.outlineOffset), t.objectFit !== void 0 && (n.style.objectFit = t.objectFit), t.aspectRatio !== void 0 && (n.style.aspectRatio = t.aspectRatio);
+}
+function Ot(n) {
+  return n ? Array.isArray(n) ? n.join(" ") : n : "";
+}
+function ht(n, t) {
+  const e = Ot(t);
+  e && e.split(" ").forEach((i) => {
+    i.trim() && n.classList.add(i.trim());
+  });
+}
+function Dt(n, t) {
+  const e = Ot(t);
+  e && e.split(" ").forEach((i) => {
+    i.trim() && n.classList.remove(i.trim());
+  });
+}
+const Ct = {
+  UNFOCUSING: 999,
+  FOCUSING: 1e3
+};
+class xe {
+  constructor(t, e, i) {
+    var o, s;
+    this.state = R.IDLE, this.currentFocus = null, this.focusData = null, this.outgoing = null, this.incoming = null, this.focusGeneration = 0, this.config = t, this.animationEngine = e, this.defaultStyles = mt(i == null ? void 0 : i.default), this.focusedStyles = mt(i == null ? void 0 : i.focused), this.defaultClassName = (o = i == null ? void 0 : i.default) == null ? void 0 : o.className, this.focusedClassName = (s = i == null ? void 0 : i.focused) == null ? void 0 : s.className;
+  }
+  /**
+   * Get current state machine state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if any animation is in progress
+   */
+  isAnimating() {
+    return this.state !== R.IDLE && this.state !== R.FOCUSED;
+  }
+  /**
+   * Normalize scalePercent value
+   */
+  normalizeScalePercent(t) {
+    return t > 1 ? t / 100 : t;
+  }
+  /**
+   * Calculate target dimensions for focused image
+   * Returns actual pixel dimensions instead of scale factor for sharper rendering
+   */
+  calculateFocusDimensions(t, e, i) {
+    const o = this.normalizeScalePercent(this.config.scalePercent), s = i.height * o, c = t / e;
+    let a = s, h = a * c;
+    const l = i.width * o;
+    return h > l && (h = l, a = h / c), { width: h, height: a };
+  }
+  /**
+   * Calculate the transform needed to center an image (position only, no scale)
+   * Scale is handled by animating actual dimensions for sharper rendering
+   */
+  calculateFocusTransform(t, e) {
+    const i = t.width / 2, o = t.height / 2, s = i - e.x, c = o - e.y;
+    return {
+      x: s,
+      y: c,
+      rotation: 0,
+      scale: 1
+      // No scale transform - dimensions are animated instead
+    };
+  }
+  /**
+   * Build transform string for dimension-based zoom (no scale in transform)
+   */
+  buildDimensionZoomTransform(t) {
+    const e = ["translate(-50%, -50%)"];
+    if (t.x !== void 0 || t.y !== void 0) {
+      const i = t.x ?? 0, o = t.y ?? 0;
+      e.push(`translate(${i}px, ${o}px)`);
+    }
+    return t.rotation !== void 0 && e.push(`rotate(${t.rotation}deg)`), e.join(" ");
+  }
+  /**
+   * Create a Web Animation that animates both transform (position) and dimensions
+   * This provides sharper zoom by re-rendering at target size instead of scaling pixels
+   */
+  animateWithDimensions(t, e, i, o, s, c, a, h) {
+    const l = this.buildDimensionZoomTransform(e), g = this.buildDimensionZoomTransform(i);
+    return t.style.transition = "none", t.animate(
+      [
+        {
+          transform: l,
+          width: `${o}px`,
+          height: `${s}px`
+        },
+        {
+          transform: g,
+          width: `${c}px`,
+          height: `${a}px`
+        }
+      ],
+      {
+        duration: h,
+        easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+        fill: "forwards"
+      }
+    );
+  }
+  /**
+   * Apply focused styling to an element
+   */
+  applyFocusedStyling(t, e) {
+    t.style.zIndex = String(e), t.classList.add("fbn-ic-focused"), lt(t, this.focusedStyles), ht(t, this.focusedClassName);
+  }
+  /**
+   * Remove focused styling from an element
+   */
+  removeFocusedStyling(t, e) {
+    t.style.zIndex = e, t.classList.remove("fbn-ic-focused"), Dt(t, this.focusedClassName), lt(t, this.defaultStyles), ht(t, this.defaultClassName);
+  }
+  /**
+   * Start focus animation for an image using dimension-based zoom
+   * Animates actual width/height for sharper rendering instead of transform scale
+   * @param fromTransform - Optional starting transform (for mid-animation reversals)
+   * @param fromDimensions - Optional starting dimensions (for mid-animation reversals)
+   */
+  startFocusAnimation(t, e, i, o, s) {
+    const c = t.style.zIndex || "", a = t.offsetWidth, h = t.offsetHeight, l = this.calculateFocusDimensions(a, h, e), g = this.calculateFocusTransform(e, i);
+    this.applyFocusedStyling(t, Ct.FOCUSING), this.animationEngine.cancelAllAnimations(t);
+    const r = o ?? {
+      x: 0,
+      y: 0,
+      rotation: i.rotation,
+      scale: 1
+      // No scale - using dimensions
+    }, d = (s == null ? void 0 : s.width) ?? a, f = (s == null ? void 0 : s.height) ?? h, y = this.config.animationDuration ?? 600, p = this.animateWithDimensions(
+      t,
+      r,
+      g,
+      d,
+      f,
+      l.width,
+      l.height,
+      y
+    ), u = {
+      id: `focus-${Date.now()}`,
+      element: t,
+      animation: p,
+      fromState: r,
+      toState: g,
+      startTime: performance.now(),
+      duration: y
+    };
+    return this.focusData = {
+      element: t,
+      originalState: i,
+      focusTransform: g,
+      originalZIndex: c,
+      originalWidth: a,
+      originalHeight: h,
+      focusWidth: l.width,
+      focusHeight: l.height
+    }, {
+      element: t,
+      originalState: i,
+      animationHandle: u,
+      direction: "in",
+      originalWidth: a,
+      originalHeight: h
+    };
+  }
+  /**
+   * Start unfocus animation for an image using dimension-based zoom
+   * Animates back to original dimensions for consistent behavior
+   * @param fromDimensions - Optional starting dimensions (for mid-animation reversals)
+   */
+  startUnfocusAnimation(t, e, i, o) {
+    var y, p, u, m, w;
+    t.style.zIndex = String(Ct.UNFOCUSING), this.animationEngine.cancelAllAnimations(t);
+    const s = i ?? ((y = this.focusData) == null ? void 0 : y.focusTransform) ?? { x: 0, y: 0, rotation: 0, scale: 1 }, c = (o == null ? void 0 : o.width) ?? ((p = this.focusData) == null ? void 0 : p.focusWidth) ?? t.offsetWidth, a = (o == null ? void 0 : o.height) ?? ((u = this.focusData) == null ? void 0 : u.focusHeight) ?? t.offsetHeight, h = {
+      x: 0,
+      y: 0,
+      rotation: e.rotation,
+      scale: 1
+      // No scale - using dimensions
+    }, l = ((m = this.focusData) == null ? void 0 : m.originalWidth) ?? t.offsetWidth, g = ((w = this.focusData) == null ? void 0 : w.originalHeight) ?? t.offsetHeight, r = this.config.animationDuration ?? 600, d = this.animateWithDimensions(
+      t,
+      s,
+      h,
+      c,
+      a,
+      l,
+      g,
+      r
+    ), f = {
+      id: `unfocus-${Date.now()}`,
+      element: t,
+      animation: d,
+      fromState: s,
+      toState: h,
+      startTime: performance.now(),
+      duration: r
+    };
+    return {
+      element: t,
+      originalState: e,
+      animationHandle: f,
+      direction: "out",
+      originalWidth: l,
+      originalHeight: g
+    };
+  }
+  /**
+   * Handle animation completion
+   */
+  async waitForAnimation(t) {
+    try {
+      await t.animation.finished;
+    } catch {
+    }
+  }
+  /**
+   * Reset an element instantly to its original position and dimensions (no animation)
+   */
+  resetElementInstantly(t, e, i, o, s) {
+    this.animationEngine.cancelAllAnimations(t);
+    const c = ["translate(-50%, -50%)"];
+    c.push("translate(0px, 0px)"), c.push(`rotate(${e.rotation}deg)`), t.style.transition = "none", t.style.transform = c.join(" "), o !== void 0 && s !== void 0 && (t.style.width = `${o}px`, t.style.height = `${s}px`), this.removeFocusedStyling(t, i);
+  }
+  /**
+   * Focus (zoom) an image to center of container
+   * Implements cross-animation when swapping focus
+   */
+  async focusImage(t, e, i) {
+    var s, c, a, h, l, g, r, d, f, y, p, u;
+    if (this.currentFocus === t && this.state === R.FOCUSED)
+      return this.unfocusImage();
+    if (((s = this.incoming) == null ? void 0 : s.element) === t && this.state === R.FOCUSING) {
+      const m = this.animationEngine.cancelAnimation(this.incoming.animationHandle, !0), w = {
+        x: m.x,
+        y: m.y,
+        rotation: m.rotation,
+        scale: 1
+        // No scale transform - using dimensions
+      }, v = {
+        width: t.offsetWidth,
+        height: t.offsetHeight
+      };
+      this.outgoing = this.startUnfocusAnimation(
+        t,
+        this.incoming.originalState,
+        w,
+        v
+      ), this.incoming = null, this.state = R.UNFOCUSING, await this.waitForAnimation(this.outgoing.animationHandle), this.removeFocusedStyling(this.outgoing.element, ((c = this.focusData) == null ? void 0 : c.originalZIndex) || ""), this.outgoing = null, this.currentFocus = null, this.focusData = null, this.state = R.IDLE;
+      return;
+    }
+    const o = ++this.focusGeneration;
+    switch (this.state) {
+      case R.IDLE:
+        if (this.state = R.FOCUSING, this.incoming = this.startFocusAnimation(t, e, i), await this.waitForAnimation(this.incoming.animationHandle), this.focusGeneration !== o) return;
+        this.currentFocus = t, this.incoming = null, this.state = R.FOCUSED;
+        break;
+      case R.FOCUSED:
+        if (this.state = R.CROSS_ANIMATING, this.currentFocus && this.focusData && (this.outgoing = this.startUnfocusAnimation(
+          this.currentFocus,
+          this.focusData.originalState
+        )), this.incoming = this.startFocusAnimation(t, e, i), await Promise.all([
+          this.outgoing ? this.waitForAnimation(this.outgoing.animationHandle) : Promise.resolve(),
+          this.waitForAnimation(this.incoming.animationHandle)
+        ]), this.focusGeneration !== o)
+          return;
+        this.outgoing && (this.removeFocusedStyling(this.outgoing.element, ((a = this.outgoing.originalState.zIndex) == null ? void 0 : a.toString()) || ""), this.outgoing = null), this.currentFocus = t, this.incoming = null, this.state = R.FOCUSED;
+        break;
+      case R.FOCUSING:
+        if (this.incoming && (this.animationEngine.cancelAnimation(this.incoming.animationHandle, !1), this.resetElementInstantly(
+          this.incoming.element,
+          this.incoming.originalState,
+          ((h = this.focusData) == null ? void 0 : h.originalZIndex) || "",
+          (l = this.focusData) == null ? void 0 : l.originalWidth,
+          (g = this.focusData) == null ? void 0 : g.originalHeight
+        ), this.incoming = null), this.incoming = this.startFocusAnimation(t, e, i), await this.waitForAnimation(this.incoming.animationHandle), this.focusGeneration !== o) return;
+        this.currentFocus = t, this.incoming = null, this.state = R.FOCUSED;
+        break;
+      case R.UNFOCUSING:
+        if (this.state = R.CROSS_ANIMATING, this.incoming = this.startFocusAnimation(t, e, i), await Promise.all([
+          this.outgoing ? this.waitForAnimation(this.outgoing.animationHandle) : Promise.resolve(),
+          this.waitForAnimation(this.incoming.animationHandle)
+        ]), this.focusGeneration !== o) return;
+        this.outgoing && (this.removeFocusedStyling(this.outgoing.element, ((r = this.outgoing.originalState.zIndex) == null ? void 0 : r.toString()) || ""), this.outgoing = null), this.currentFocus = t, this.incoming = null, this.state = R.FOCUSED;
+        break;
+      case R.CROSS_ANIMATING:
+        if (((d = this.incoming) == null ? void 0 : d.element) === t)
+          return;
+        if (((f = this.outgoing) == null ? void 0 : f.element) === t) {
+          const m = this.animationEngine.cancelAnimation(this.outgoing.animationHandle, !0), w = {
+            x: m.x,
+            y: m.y,
+            rotation: m.rotation,
+            scale: 1
+            // No scale - using dimensions
+          }, v = {
+            width: t.offsetWidth,
+            height: t.offsetHeight
+          };
+          if (this.incoming) {
+            const E = this.animationEngine.cancelAnimation(this.incoming.animationHandle, !0), M = {
+              x: E.x,
+              y: E.y,
+              rotation: E.rotation,
+              scale: 1
+              // No scale - using dimensions
+            }, x = {
+              width: this.incoming.element.offsetWidth,
+              height: this.incoming.element.offsetHeight
+            };
+            this.outgoing = this.startUnfocusAnimation(
+              this.incoming.element,
+              this.incoming.originalState,
+              M,
+              x
+            );
+          } else
+            this.outgoing = null;
+          if (this.incoming = this.startFocusAnimation(t, e, i, w, v), await Promise.all([
+            this.outgoing ? this.waitForAnimation(this.outgoing.animationHandle) : Promise.resolve(),
+            this.waitForAnimation(this.incoming.animationHandle)
+          ]), this.focusGeneration !== o) return;
+          this.outgoing && (this.removeFocusedStyling(this.outgoing.element, ((y = this.outgoing.originalState.zIndex) == null ? void 0 : y.toString()) || ""), this.outgoing = null), this.currentFocus = t, this.incoming = null, this.state = R.FOCUSED;
+          return;
+        }
+        if (this.outgoing && (this.animationEngine.cancelAnimation(this.outgoing.animationHandle, !1), this.resetElementInstantly(
+          this.outgoing.element,
+          this.outgoing.originalState,
+          ((p = this.outgoing.originalState.zIndex) == null ? void 0 : p.toString()) || "",
+          this.outgoing.originalWidth,
+          this.outgoing.originalHeight
+        ), this.outgoing = null), this.incoming) {
+          const m = this.animationEngine.cancelAnimation(this.incoming.animationHandle, !0), w = {
+            x: m.x,
+            y: m.y,
+            rotation: m.rotation,
+            scale: 1
+            // No scale - using dimensions
+          }, v = {
+            width: this.incoming.element.offsetWidth,
+            height: this.incoming.element.offsetHeight
+          };
+          this.outgoing = this.startUnfocusAnimation(
+            this.incoming.element,
+            this.incoming.originalState,
+            w,
+            v
+          );
+        }
+        if (this.incoming = this.startFocusAnimation(t, e, i), await Promise.all([
+          this.outgoing ? this.waitForAnimation(this.outgoing.animationHandle) : Promise.resolve(),
+          this.waitForAnimation(this.incoming.animationHandle)
+        ]), this.focusGeneration !== o) return;
+        this.outgoing && (this.removeFocusedStyling(this.outgoing.element, ((u = this.outgoing.originalState.zIndex) == null ? void 0 : u.toString()) || ""), this.outgoing = null), this.currentFocus = t, this.incoming = null, this.state = R.FOCUSED;
+        break;
+    }
+  }
+  /**
+   * Unfocus current image, returning it to original position
+   */
+  async unfocusImage() {
+    var s, c, a;
+    const t = ++this.focusGeneration;
+    if (!this.currentFocus || !this.focusData) {
+      if (this.incoming && this.state === R.FOCUSING) {
+        const h = this.animationEngine.cancelAnimation(this.incoming.animationHandle, !0), l = {
+          x: h.x,
+          y: h.y,
+          rotation: h.rotation,
+          scale: 1
+          // No scale - using dimensions
+        }, g = {
+          width: this.incoming.element.offsetWidth,
+          height: this.incoming.element.offsetHeight
+        };
+        if (this.outgoing = this.startUnfocusAnimation(
+          this.incoming.element,
+          this.incoming.originalState,
+          l,
+          g
+        ), this.incoming = null, this.state = R.UNFOCUSING, await this.waitForAnimation(this.outgoing.animationHandle), this.focusGeneration !== t) return;
+        this.removeFocusedStyling(this.outgoing.element, ((s = this.focusData) == null ? void 0 : s.originalZIndex) || ""), this.outgoing = null, this.focusData = null, this.state = R.IDLE;
+      }
+      return;
+    }
+    if (this.state === R.CROSS_ANIMATING && this.incoming) {
+      const h = this.animationEngine.cancelAnimation(this.incoming.animationHandle, !0), l = {
+        x: h.x,
+        y: h.y,
+        rotation: h.rotation,
+        scale: 1
+        // No scale - using dimensions
+      }, g = {
+        width: this.incoming.element.offsetWidth,
+        height: this.incoming.element.offsetHeight
+      }, r = this.startUnfocusAnimation(
+        this.incoming.element,
+        this.incoming.originalState,
+        l,
+        g
+      );
+      if (await Promise.all([
+        this.outgoing ? this.waitForAnimation(this.outgoing.animationHandle) : Promise.resolve(),
+        this.waitForAnimation(r.animationHandle)
+      ]), this.focusGeneration !== t) return;
+      this.outgoing && this.removeFocusedStyling(this.outgoing.element, ((c = this.outgoing.originalState.zIndex) == null ? void 0 : c.toString()) || ""), this.removeFocusedStyling(r.element, ((a = this.incoming.originalState.zIndex) == null ? void 0 : a.toString()) || ""), this.outgoing = null, this.incoming = null, this.currentFocus = null, this.focusData = null, this.state = R.IDLE;
+      return;
+    }
+    this.state = R.UNFOCUSING;
+    const e = this.currentFocus, i = this.focusData.originalState, o = this.focusData.originalZIndex;
+    this.outgoing = this.startUnfocusAnimation(e, i), await this.waitForAnimation(this.outgoing.animationHandle), this.focusGeneration === t && (this.removeFocusedStyling(e, o), this.outgoing = null, this.currentFocus = null, this.focusData = null, this.state = R.IDLE);
+  }
+  /**
+   * Swap focus from current image to a new one (alias for focusImage with cross-animation)
+   */
+  async swapFocus(t, e, i) {
+    return this.focusImage(t, e, i);
+  }
+  /**
+   * Get currently focused image element
+   */
+  getCurrentFocus() {
+    return this.currentFocus;
+  }
+  /**
+   * Check if an image is currently focused (stable state)
+   */
+  isFocused(t) {
+    return this.currentFocus === t && this.state === R.FOCUSED;
+  }
+  /**
+   * Check if an image is the target of current focus animation
+   */
+  isTargetingFocus(t) {
+    var e;
+    return ((e = this.incoming) == null ? void 0 : e.element) === t;
+  }
+  /**
+   * Check if an image is involved in any focus/animation state
+   * Returns true if the image is focused, animating in, or animating out
+   * Useful for hover state management - don't apply hover to animating images
+   */
+  isInvolved(t) {
+    var e, i;
+    return this.currentFocus === t || ((e = this.incoming) == null ? void 0 : e.element) === t || ((i = this.outgoing) == null ? void 0 : i.element) === t;
+  }
+  /**
+   * Reset zoom state (cancels all animations)
+   */
+  reset() {
+    var t, e, i, o;
+    this.outgoing && (this.animationEngine.cancelAnimation(this.outgoing.animationHandle, !1), this.resetElementInstantly(
+      this.outgoing.element,
+      this.outgoing.originalState,
+      ((t = this.outgoing.originalState.zIndex) == null ? void 0 : t.toString()) || "",
+      this.outgoing.originalWidth,
+      this.outgoing.originalHeight
+    )), this.incoming && (this.animationEngine.cancelAnimation(this.incoming.animationHandle, !1), this.resetElementInstantly(
+      this.incoming.element,
+      this.incoming.originalState,
+      ((e = this.focusData) == null ? void 0 : e.originalZIndex) || "",
+      (i = this.focusData) == null ? void 0 : i.originalWidth,
+      (o = this.focusData) == null ? void 0 : o.originalHeight
+    )), this.currentFocus && this.focusData && this.resetElementInstantly(
+      this.currentFocus,
+      this.focusData.originalState,
+      this.focusData.originalZIndex,
+      this.focusData.originalWidth,
+      this.focusData.originalHeight
+    ), this.state = R.IDLE, this.currentFocus = null, this.focusData = null, this.outgoing = null, this.incoming = null;
+  }
+}
+class Se {
+  constructor(t = {}) {
+    if (this._prepared = !1, this._discoveredUrls = [], this.apiKey = t.apiKey ?? "", this.apiEndpoint = t.apiEndpoint ?? "https://www.googleapis.com/drive/v3/files", this.debugLogging = t.debugLogging ?? !1, this.sources = t.sources ?? [], !this.sources || this.sources.length === 0)
+      throw new Error("GoogleDriveLoader requires at least one source to be configured");
+  }
+  /**
+   * Prepare the loader by discovering all images from configured sources
+   * @param filter - Filter to apply to discovered images
+   */
+  async prepare(t) {
+    this._discoveredUrls = [];
+    for (const e of this.sources)
+      if (e.type === "folder")
+        for (const i of e.folders) {
+          const o = e.recursive !== void 0 ? e.recursive : !0, s = await this.loadFromFolder(i, t, o);
+          this._discoveredUrls.push(...s);
+        }
+      else if (e.type === "files") {
+        const i = await this.loadFiles(e.files, t);
+        this._discoveredUrls.push(...i);
+      }
+    this._prepared = !0;
+  }
+  /**
+   * Get the number of discovered images
+   * @throws Error if called before prepare()
+   */
+  imagesLength() {
+    if (!this._prepared)
+      throw new Error("GoogleDriveLoader.imagesLength() called before prepare()");
+    return this._discoveredUrls.length;
+  }
+  /**
+   * Get the ordered list of image URLs
+   * @throws Error if called before prepare()
+   */
+  imageURLs() {
+    if (!this._prepared)
+      throw new Error("GoogleDriveLoader.imageURLs() called before prepare()");
+    return [...this._discoveredUrls];
+  }
+  /**
+   * Check if the loader has been prepared
+   */
+  isPrepared() {
+    return this._prepared;
+  }
+  /**
+   * Extract folder ID from various Google Drive URL formats
+   * @param folderUrl - Google Drive folder URL
+   * @returns Folder ID or null if invalid
+   */
+  extractFolderId(t) {
+    const e = [
+      /\/folders\/([a-zA-Z0-9_-]+)/,
+      // Standard format
+      /id=([a-zA-Z0-9_-]+)/
+      // Alternative format
+    ];
+    for (const i of e) {
+      const o = t.match(i);
+      if (o && o[1])
+        return o[1];
+    }
+    return null;
+  }
+  /**
+   * Load images from a Google Drive folder
+   * @param folderUrl - Google Drive folder URL
+   * @param filter - Filter to apply to discovered images
+   * @param recursive - Whether to include images from subfolders
+   * @returns Promise resolving to array of image URLs
+   */
+  async loadFromFolder(t, e, i = !0) {
+    const o = this.extractFolderId(t);
+    if (!o)
+      throw new Error("Invalid Google Drive folder URL. Please check the URL format.");
+    if (!this.apiKey || this.apiKey === "YOUR_API_KEY_HERE")
+      return this.loadImagesDirectly(o, e);
+    try {
+      return i ? await this.loadImagesRecursively(o, e) : await this.loadImagesFromSingleFolder(o, e);
+    } catch (s) {
+      return console.error("Error loading from Google Drive API:", s), this.loadImagesDirectly(o, e);
+    }
+  }
+  /**
+   * Load images from a single folder (non-recursive)
+   * @param folderId - Google Drive folder ID
+   * @param filter - Filter to apply to discovered images
+   * @returns Promise resolving to array of image URLs
+   */
+  async loadImagesFromSingleFolder(t, e) {
+    const i = [], o = `'${t}' in parents and trashed=false`, c = `${this.apiEndpoint}?q=${encodeURIComponent(o)}&fields=files(id,name,mimeType,thumbnailLink)&key=${this.apiKey}`, a = await fetch(c);
+    if (!a.ok)
+      throw new Error(`API request failed: ${a.status} ${a.statusText}`);
+    const l = (await a.json()).files.filter(
+      (g) => g.mimeType.startsWith("image/") && e.isAllowed(g.name)
+    );
+    return this.log(`Found ${l.length} images in folder ${t} (non-recursive)`), l.forEach((g) => {
+      i.push(`https://lh3.googleusercontent.com/d/${g.id}=s1600`), this.log(`Added file: ${g.name}`);
+    }), i;
+  }
+  /**
+   * Load specific files by their URLs or IDs
+   * @param fileUrls - Array of Google Drive file URLs or IDs
+   * @param filter - Filter to apply to discovered images
+   * @returns Promise resolving to array of image URLs
+   */
+  async loadFiles(t, e) {
+    const i = [];
+    for (const o of t) {
+      const s = this.extractFileId(o);
+      if (!s) {
+        this.log(`Skipping invalid file URL: ${o}`);
+        continue;
+      }
+      if (this.apiKey && this.apiKey !== "YOUR_API_KEY_HERE")
+        try {
+          const c = `${this.apiEndpoint}/${s}?fields=name,mimeType&key=${this.apiKey}`, a = await fetch(c);
+          if (a.ok) {
+            const h = await a.json();
+            h.mimeType.startsWith("image/") && e.isAllowed(h.name) ? (i.push(`https://lh3.googleusercontent.com/d/${s}=s1600`), this.log(`Added file: ${h.name}`)) : this.log(`Skipping non-image file: ${h.name} (${h.mimeType})`);
+          } else
+            this.log(`Failed to fetch metadata for file ${s}: ${a.status}`);
+        } catch (c) {
+          this.log(`Error fetching metadata for file ${s}:`, c);
+        }
+      else
+        i.push(`https://lh3.googleusercontent.com/d/${s}=s1600`);
+    }
+    return i;
+  }
+  /**
+   * Extract file ID from Google Drive file URL
+   * @param fileUrl - Google Drive file URL or file ID
+   * @returns File ID or null if invalid
+   */
+  extractFileId(t) {
+    if (!/[/:.]/.test(t))
+      return t;
+    const e = [
+      /\/file\/d\/([a-zA-Z0-9_-]+)/,
+      // Standard file format
+      /\/open\?id=([a-zA-Z0-9_-]+)/,
+      // Alternative format
+      /id=([a-zA-Z0-9_-]+)/
+      // Generic id parameter
+    ];
+    for (const i of e) {
+      const o = t.match(i);
+      if (o && o[1])
+        return o[1];
+    }
+    return null;
+  }
+  /**
+   * Recursively load images from a folder and all its subfolders
+   * @param folderId - Google Drive folder ID
+   * @param filter - Filter to apply to discovered images
+   * @returns Promise resolving to array of image URLs
+   */
+  async loadImagesRecursively(t, e) {
+    const i = [], o = `'${t}' in parents and trashed=false`, c = `${this.apiEndpoint}?q=${encodeURIComponent(o)}&fields=files(id,name,mimeType,thumbnailLink)&key=${this.apiKey}`, a = await fetch(c);
+    if (!a.ok)
+      throw new Error(`API request failed: ${a.status} ${a.statusText}`);
+    const h = await a.json(), l = h.files.filter(
+      (r) => r.mimeType.startsWith("image/") && e.isAllowed(r.name)
+    ), g = h.files.filter(
+      (r) => r.mimeType === "application/vnd.google-apps.folder"
+    );
+    this.log(`Found ${h.files.length} total items in folder ${t}`), h.files.forEach((r) => this.log(` - File: ${r.name} (${r.mimeType})`)), this.log(`- ${l.length} valid files (images only)`), this.log(`- ${g.length} subfolders`), l.forEach((r) => {
+      i.push(`https://lh3.googleusercontent.com/d/${r.id}=s1600`), this.log(`Added file: ${r.name}`);
+    });
+    for (const r of g) {
+      this.log(`Loading images from subfolder: ${r.name}`);
+      const d = await this.loadImagesRecursively(r.id, e);
+      i.push(...d);
+    }
+    return i;
+  }
+  /**
+   * Direct loading method (no API key required, but less reliable)
+   * Uses embedded folder view to scrape image IDs
+   * @param folderId - Google Drive folder ID
+   * @param filter - Filter to apply (not used in fallback mode)
+   * @returns Promise resolving to array of image URLs
+   */
+  async loadImagesDirectly(t, e) {
+    try {
+      const i = `https://drive.google.com/embeddedfolderview?id=${t}`, o = await fetch(i, { mode: "cors" });
+      if (!o.ok)
+        throw new Error("Cannot access folder directly (CORS or permissions issue)");
+      const s = await o.text(), c = /\/file\/d\/([a-zA-Z0-9_-]+)/g, a = [...s.matchAll(c)];
+      return [...new Set(a.map((g) => g[1]))].map(
+        (g) => `https://drive.google.com/uc?export=view&id=${g}`
+      );
+    } catch (i) {
+      throw console.error("Direct loading failed:", i), new Error(
+        `Unable to load images. Please ensure:
+1. The folder is shared publicly (Anyone with the link can view)
+2. The folder contains image files
+3. Consider adding a Google Drive API key in config.js for better reliability`
+      );
+    }
+  }
+  /**
+   * Manually add image URLs (for testing or when auto-loading fails)
+   * @param imageIds - Array of Google Drive file IDs
+   * @returns Array of direct image URLs
+   */
+  manualImageUrls(t) {
+    return t.map((e) => `https://drive.google.com/uc?export=view&id=${e}`);
+  }
+  /**
+   * Debug logging helper
+   * @param args - Arguments to log
+   */
+  log(...t) {
+    this.debugLogging && typeof console < "u" && console.log(...t);
+  }
+}
+class Ie {
+  constructor(t = {}) {
+    if (this._prepared = !1, this._discoveredUrls = [], this.validateUrls = t.validateUrls !== !1, this.validationTimeout = t.validationTimeout ?? 5e3, this.validationMethod = t.validationMethod ?? "head", this.sources = t.sources ?? [], this.debugLogging = t.debugLogging ?? !1, !this.sources || this.sources.length === 0)
+      throw new Error("StaticImageLoader requires at least one source to be configured");
+    this.log("StaticImageLoader initialized with config:", t);
+  }
+  /**
+   * Prepare the loader by discovering all images from configured sources
+   * @param filter - Filter to apply to discovered images
+   */
+  async prepare(t) {
+    this._discoveredUrls = [], this.log(`Processing ${this.sources.length} source(s)`);
+    for (const e of this.sources)
+      try {
+        const i = await this.processSource(e, t);
+        this._discoveredUrls.push(...i);
+      } catch (i) {
+        console.warn("Failed to process source:", e, i);
+      }
+    this._prepared = !0, this.log(`Successfully loaded ${this._discoveredUrls.length} image(s)`);
+  }
+  /**
+   * Get the number of discovered images
+   * @throws Error if called before prepare()
+   */
+  imagesLength() {
+    if (!this._prepared)
+      throw new Error("StaticImageLoader.imagesLength() called before prepare()");
+    return this._discoveredUrls.length;
+  }
+  /**
+   * Get the ordered list of image URLs
+   * @throws Error if called before prepare()
+   */
+  imageURLs() {
+    if (!this._prepared)
+      throw new Error("StaticImageLoader.imageURLs() called before prepare()");
+    return [...this._discoveredUrls];
+  }
+  /**
+   * Check if the loader has been prepared
+   */
+  isPrepared() {
+    return this._prepared;
+  }
+  /**
+   * Process a single source object
+   * @param source - Source configuration with type, urls, basePath, files
+   * @param filter - Filter to apply to discovered images
+   * @returns Promise resolving to array of valid URLs from this source
+   */
+  async processSource(t, e) {
+    return !t || !t.type ? (console.warn("Invalid source object (missing type):", t), []) : t.type === "urls" ? await this.processUrls(t.urls || [], e) : t.type === "path" ? await this.processPath(t.basePath, t.files || [], e) : (console.warn(`Unknown source type: ${t.type}`), []);
+  }
+  /**
+   * Process a list of direct URLs
+   * @param urls - Array of image URLs
+   * @param filter - Filter to apply to discovered images
+   * @returns Promise resolving to array of validated URLs
+   */
+  async processUrls(t, e) {
+    if (!Array.isArray(t))
+      return console.warn("URLs must be an array:", t), [];
+    const i = [];
+    for (const o of t) {
+      const s = o.split("/").pop() || o;
+      if (!e.isAllowed(s)) {
+        this.log(`Skipping filtered URL: ${o}`);
+        continue;
+      }
+      this.validateUrls ? await this.validateUrl(o) ? i.push(o) : console.warn(`Skipping invalid/missing URL: ${o}`) : i.push(o);
+    }
+    return i;
+  }
+  /**
+   * Process a path-based source
+   * @param basePath - Base path (relative or absolute)
+   * @param files - Array of filenames
+   * @param filter - Filter to apply to discovered images
+   * @returns Promise resolving to array of validated URLs
+   */
+  async processPath(t, e, i) {
+    if (!t)
+      return console.warn("basePath is required for path-type sources"), [];
+    if (!Array.isArray(e))
+      return console.warn("files must be an array:", e), [];
+    const o = [];
+    for (const s of e) {
+      if (!i.isAllowed(s)) {
+        this.log(`Skipping filtered file: ${s}`);
+        continue;
+      }
+      const c = this.constructUrl(t, s);
+      this.validateUrls ? await this.validateUrl(c) ? o.push(c) : console.warn(`Skipping invalid/missing file: ${c}`) : o.push(c);
+    }
+    return o;
+  }
+  /**
+   * Validate a single URL using HEAD request
+   * @param url - URL to validate
+   * @returns Promise resolving to true if valid and accessible
+   */
+  async validateUrl(t) {
+    if (this.validationMethod === "none")
+      return !0;
+    if (this.validationMethod === "simple")
+      try {
+        return typeof window < "u" ? new URL(t, window.location.origin) : new URL(t), !0;
+      } catch {
+        return !1;
+      }
+    if (typeof window > "u")
+      return !0;
+    if (!(t.startsWith(window.location.origin) || t.startsWith("/")))
+      return this.log(`Skipping validation for cross-origin URL: ${t}`), !0;
+    try {
+      const i = new AbortController(), o = setTimeout(() => i.abort(), this.validationTimeout), s = await fetch(t, {
+        method: "HEAD",
+        signal: i.signal
+      });
+      return clearTimeout(o), s.ok ? !0 : (this.log(`Validation failed for ${t}: HTTP ${s.status}`), !1);
+    } catch (i) {
+      return i instanceof Error && (i.name === "AbortError" ? this.log(`Validation timeout for ${t}`) : this.log(`Validation failed for ${t}:`, i.message)), !1;
+    }
+  }
+  /**
+   * Construct full URL from basePath and filename
+   * @param basePath - Base path (relative or absolute)
+   * @param filename - Filename to append
+   * @returns Complete URL
+   */
+  constructUrl(t, e) {
+    const i = t.replace(/\/$/, "");
+    if (this.isAbsoluteUrl(t))
+      return `${i}/${e}`;
+    if (typeof window > "u")
+      return `${i}/${e}`;
+    const o = window.location.origin, c = (t.startsWith("/") ? t : "/" + t).replace(/\/$/, "");
+    return `${o}${c}/${e}`;
+  }
+  /**
+   * Check if URL is absolute (contains protocol)
+   * @param url - URL to check
+   * @returns True if absolute URL
+   */
+  isAbsoluteUrl(t) {
+    try {
+      return new URL(t), !0;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Debug logging helper
+   * @param args - Arguments to log
+   */
+  log(...t) {
+    this.debugLogging && typeof console < "u" && console.log(...t);
+  }
+}
+class Re {
+  constructor(t) {
+    if (this._prepared = !1, this._discoveredUrls = [], this.loaders = t.loaders, this.debugLogging = t.debugLogging ?? !1, !this.loaders || this.loaders.length === 0)
+      throw new Error("CompositeLoader requires at least one loader to be configured");
+    this.log(`CompositeLoader initialized with ${this.loaders.length} loader(s)`);
+  }
+  /**
+   * Prepare all loaders in parallel and combine their results
+   * @param filter - Filter to apply to discovered images
+   */
+  async prepare(t) {
+    this._discoveredUrls = [], this.log(`Preparing ${this.loaders.length} loader(s) in parallel`);
+    const e = this.loaders.map((i, o) => i.prepare(t).then(() => {
+      this.log(`Loader ${o} prepared with ${i.imagesLength()} images`);
+    }).catch((s) => {
+      console.warn(`Loader ${o} failed to prepare:`, s);
+    }));
+    await Promise.all(e);
+    for (const i of this.loaders)
+      if (i.isPrepared()) {
+        const o = i.imageURLs();
+        this._discoveredUrls.push(...o);
+      }
+    this._prepared = !0, this.log(`CompositeLoader prepared with ${this._discoveredUrls.length} total images`);
+  }
+  /**
+   * Get the combined number of discovered images
+   * @throws Error if called before prepare()
+   */
+  imagesLength() {
+    if (!this._prepared)
+      throw new Error("CompositeLoader.imagesLength() called before prepare()");
+    return this._discoveredUrls.length;
+  }
+  /**
+   * Get the combined ordered list of image URLs
+   * @throws Error if called before prepare()
+   */
+  imageURLs() {
+    if (!this._prepared)
+      throw new Error("CompositeLoader.imageURLs() called before prepare()");
+    return [...this._discoveredUrls];
+  }
+  /**
+   * Check if the loader has been prepared
+   */
+  isPrepared() {
+    return this._prepared;
+  }
+  /**
+   * Debug logging helper
+   * @param args - Arguments to log
+   */
+  log(...t) {
+    this.debugLogging && typeof console < "u" && console.log("[CompositeLoader]", ...t);
+  }
+}
+class Ee {
+  /**
+   * Create a new ImageFilter
+   * @param extensions - Array of allowed file extensions (without dots)
+   *                     Defaults to common image formats if not provided
+   */
+  constructor(t) {
+    this.allowedExtensions = t || [
+      "jpg",
+      "jpeg",
+      "png",
+      "gif",
+      "webp",
+      "bmp"
+    ];
+  }
+  /**
+   * Check if a filename has an allowed extension
+   * @param filename - The filename to check (can include path or query string)
+   * @returns True if the file extension is allowed
+   */
+  isAllowed(t) {
+    var o;
+    const i = (o = t.split("?")[0].split(".").pop()) == null ? void 0 : o.toLowerCase();
+    return i ? this.allowedExtensions.includes(i) : !1;
+  }
+  /**
+   * Get the list of allowed extensions
+   * @returns Array of allowed extensions
+   */
+  getAllowedExtensions() {
+    return [...this.allowedExtensions];
+  }
+  // Future expansion methods:
+  // isAllowedSize(sizeBytes: number): boolean
+  // isAllowedDate(date: Date): boolean
+  // isAllowedDimensions(width: number, height: number): boolean
+}
+class Ae {
+  constructor(t = {}) {
+    var i, o, s, c, a, h;
+    this.fullConfig = qt(t), t.container instanceof HTMLElement ? (this.containerRef = t.container, this.containerId = null) : (this.containerRef = null, this.containerId = t.container || "imageCloud"), this.imagesLoaded = !1, this.imageElements = [], this.imageLayouts = [], this.currentImageHeight = 225, this.currentFocusIndex = null, this.hoveredImage = null, this.resizeTimeout = null, this.displayQueue = [], this.queueInterval = null, this.loadGeneration = 0, this.animationEngine = new Vt(this.fullConfig.animation), this.layoutEngine = new ye({
+      layout: this.fullConfig.layout,
+      image: this.fullConfig.image,
+      breakpoints: this.fullConfig.rendering.responsive.breakpoints
+    }), this.zoomEngine = new xe(this.fullConfig.interaction.focus, this.animationEngine, this.fullConfig.styling), this.defaultStyles = mt((i = this.fullConfig.styling) == null ? void 0 : i.default), this.hoverStyles = mt((o = this.fullConfig.styling) == null ? void 0 : o.hover), this.defaultClassName = (c = (s = this.fullConfig.styling) == null ? void 0 : s.default) == null ? void 0 : c.className, this.hoverClassName = (h = (a = this.fullConfig.styling) == null ? void 0 : a.hover) == null ? void 0 : h.className;
+    const e = this.fullConfig.animation.entry || b.animation.entry;
+    this.entryAnimationEngine = new ae(
+      e,
+      this.fullConfig.layout.algorithm
+    ), this.imageFilter = this.createImageFilter(), this.imageLoader = this.createLoader(), this.containerEl = null, this.loadingEl = null, this.errorEl = null;
+  }
+  /**
+   * Create image filter based on config
+   */
+  createImageFilter() {
+    var i, o;
+    const t = this.fullConfig.loader.type;
+    let e;
+    return t === "googleDrive" ? e = (i = this.fullConfig.loader.googleDrive) == null ? void 0 : i.allowedExtensions : e = (o = this.fullConfig.loader.static) == null ? void 0 : o.allowedExtensions, new Ee(e);
+  }
+  /**
+   * Create appropriate image loader based on config
+   */
+  createLoader() {
+    return this.createLoaderFromConfig(this.fullConfig.loader);
+  }
+  /**
+   * Create a loader from a LoaderConfig object (supports recursive composite loaders)
+   */
+  createLoaderFromConfig(t) {
+    const e = t.type;
+    if (e === "static") {
+      const i = t.static;
+      return new Ie(i);
+    } else if (e === "composite") {
+      const i = t.composite, o = i.loaders.map(
+        (s) => this.createLoaderFromConfig(s)
+      );
+      return new Re({
+        loaders: o,
+        debugLogging: i.debugLogging
+      });
+    } else {
+      const i = t.googleDrive;
+      return new Se(i);
+    }
+  }
+  /**
+   * Initialize the gallery
+   */
+  async init() {
+    try {
+      if (this.containerRef)
+        this.containerEl = this.containerRef;
+      else if (this.containerEl = document.getElementById(this.containerId), !this.containerEl)
+        throw new Error(`Container #${this.containerId} not found`);
+      this.containerEl.classList.add("fbn-ic-gallery"), this.setupUI(), this.setupEventListeners(), this.logDebug("ImageCloud initialized"), await this.loadImages();
+    } catch (t) {
+      console.error("Gallery initialization failed:", t), this.errorEl && t instanceof Error && this.showError("Gallery failed to initialize: " + t.message);
+    }
+  }
+  setupUI() {
+    this.loadingEl = document.getElementById("loading"), this.errorEl = document.getElementById("error");
+  }
+  setupEventListeners() {
+    document.addEventListener("keydown", (t) => {
+      t.key === "Escape" ? (this.zoomEngine.unfocusImage(), this.currentFocusIndex = null) : t.key === "ArrowRight" ? this.navigateToNextImage() : t.key === "ArrowLeft" ? this.navigateToPreviousImage() : (t.key === "Enter" || t.key === " ") && this.hoveredImage && (this.handleImageClick(this.hoveredImage.element, this.hoveredImage.layout), t.preventDefault());
+    }), document.addEventListener("click", (t) => {
+      t.target.closest(".fbn-ic-image") || (this.zoomEngine.unfocusImage(), this.currentFocusIndex = null);
+    }), window.addEventListener("resize", () => this.handleResize());
+  }
+  /**
+   * Navigate to the next image (Right arrow)
+   */
+  navigateToNextImage() {
+    if (this.currentFocusIndex === null || this.imageElements.length === 0) return;
+    const t = (this.currentFocusIndex + 1) % this.imageElements.length;
+    this.navigateToImage(t);
+  }
+  /**
+   * Navigate to the previous image (Left arrow)
+   */
+  navigateToPreviousImage() {
+    if (this.currentFocusIndex === null || this.imageElements.length === 0) return;
+    const t = (this.currentFocusIndex - 1 + this.imageElements.length) % this.imageElements.length;
+    this.navigateToImage(t);
+  }
+  /**
+   * Navigate to a specific image by index
+   */
+  async navigateToImage(t) {
+    if (t < 0 || t >= this.imageElements.length) return;
+    const e = this.imageElements[t], i = this.imageLayouts[t];
+    !e || !i || await this.handleImageClick(e, i);
+  }
+  handleResize() {
+    this.imagesLoaded && (this.resizeTimeout !== null && clearTimeout(this.resizeTimeout), this.resizeTimeout = window.setTimeout(() => {
+      const t = this.getImageHeight();
+      t !== this.currentImageHeight ? (this.logDebug(`Window resized to new breakpoint (height: ${t}px). Reloading images...`), this.loadImages()) : this.logDebug("Window resized (no breakpoint change)");
+    }, 500));
+  }
+  getImageHeight() {
+    const t = window.innerWidth, e = this.fullConfig.layout.sizing.responsive || [];
+    for (const i of e)
+      if (t >= i.minWidth)
+        return i.height;
+    return 120;
+  }
+  /**
+   * Get container bounds for layout calculations
+   */
+  getContainerBounds() {
+    return this.containerEl ? {
+      width: this.containerEl.offsetWidth,
+      height: this.containerEl.offsetHeight || window.innerHeight * 0.7
+    } : { width: window.innerWidth, height: window.innerHeight * 0.7 };
+  }
+  /**
+   * Load images using the unified loader interface
+   */
+  async loadImages() {
+    try {
+      this.showLoading(!0), this.hideError(), this.clearImageCloud(), await this.imageLoader.prepare(this.imageFilter);
+      const t = this.imageLoader.imagesLength();
+      let e = this.imageLoader.imageURLs();
+      if (t === 0) {
+        this.showError("No images found."), this.showLoading(!1);
+        return;
+      }
+      const i = this.getContainerBounds(), o = this.getImageHeight(), s = window.innerWidth;
+      this.logDebug(`Adaptive sizing input: container=${i.width}x${i.height}px, images=${t}, responsiveMax=${o}px`);
+      const c = this.layoutEngine.calculateAdaptiveSize(
+        i,
+        t,
+        o,
+        s
+      );
+      this.logDebug(`Adaptive sizing result: height=${c.height}px`), await this.createImageCloud(e, c.height), this.showLoading(!1), this.imagesLoaded = !0;
+    } catch (t) {
+      console.error("Error loading images:", t), t instanceof Error && this.showError(t.message || "Failed to load images."), this.showLoading(!1);
+    }
+  }
+  /**
+   * Helper for debug logging
+   */
+  logDebug(...t) {
+    this.fullConfig.debug && typeof console < "u" && console.log(...t);
+  }
+  async createImageCloud(t, e) {
+    if (!this.containerEl) return;
+    const i = this.getContainerBounds();
+    this.currentImageHeight = e;
+    const o = this.loadGeneration, s = this.layoutEngine.generateLayout(t.length, i, { fixedHeight: e });
+    this.imageLayouts = s, this.displayQueue = [];
+    let c = 0;
+    const a = (l) => {
+      this.containerEl && (this.containerEl.appendChild(l), this.imageElements.push(l), requestAnimationFrame(() => {
+        if (l.offsetWidth, l.style.opacity = this.defaultStyles.opacity ?? "1", l.dataset.startX && (this.entryAnimationEngine.requiresJSAnimation() || this.entryAnimationEngine.requiresJSRotation() || this.entryAnimationEngine.requiresJSScale() || l.dataset.startRotation !== l.dataset.rotation || l.dataset.startScale !== l.dataset.scale)) {
+          const d = {
+            x: parseFloat(l.dataset.startX),
+            y: parseFloat(l.dataset.startY)
+          }, f = {
+            x: parseFloat(l.dataset.endX),
+            y: parseFloat(l.dataset.endY)
+          }, y = parseFloat(l.dataset.imageWidth), p = parseFloat(l.dataset.imageHeight), u = parseFloat(l.dataset.rotation), m = parseFloat(l.dataset.scale), w = l.dataset.startRotation ? parseFloat(l.dataset.startRotation) : u, v = l.dataset.startScale ? parseFloat(l.dataset.startScale) : m, E = this.entryAnimationEngine.getTiming();
+          ne({
+            element: l,
+            startPosition: d,
+            endPosition: f,
+            pathConfig: this.entryAnimationEngine.getPathConfig(),
+            duration: E.duration,
+            imageWidth: y,
+            imageHeight: p,
+            rotation: u,
+            scale: m,
+            rotationConfig: this.entryAnimationEngine.getRotationConfig(),
+            startRotation: w,
+            scaleConfig: this.entryAnimationEngine.getScaleConfig(),
+            startScale: v
+          });
+        } else {
+          const d = l.dataset.finalTransform || "";
+          l.style.transform = d;
+        }
+        const r = parseInt(l.dataset.imageId || "0");
+        if (this.fullConfig.debug && r < 3) {
+          const d = l.dataset.finalTransform || "";
+          console.log(`Image ${r} final state:`, {
+            left: l.style.left,
+            top: l.style.top,
+            width: l.style.width,
+            height: l.style.height,
+            computedWidth: l.offsetWidth,
+            computedHeight: l.offsetHeight,
+            transform: d,
+            pathType: this.entryAnimationEngine.getPathType()
+          });
+        }
+      }), c++);
+    }, h = () => {
+      if (this.logDebug("Starting queue processing, enabled:", this.fullConfig.animation.queue.enabled), !this.fullConfig.animation.queue.enabled) {
+        for (; this.displayQueue.length > 0; ) {
+          const l = this.displayQueue.shift();
+          l && a(l);
+        }
+        return;
+      }
+      this.queueInterval !== null && clearInterval(this.queueInterval), this.queueInterval = window.setInterval(() => {
+        if (o !== this.loadGeneration) {
+          this.queueInterval !== null && (clearInterval(this.queueInterval), this.queueInterval = null);
+          return;
+        }
+        if (this.displayQueue.length > 0) {
+          const l = this.displayQueue.shift();
+          l && a(l);
+        }
+        c >= t.length && this.displayQueue.length === 0 && this.queueInterval !== null && (clearInterval(this.queueInterval), this.queueInterval = null);
+      }, this.fullConfig.animation.queue.interval);
+    };
+    if ("IntersectionObserver" in window && this.containerEl) {
+      const l = new IntersectionObserver((g) => {
+        g.forEach((r) => {
+          r.isIntersecting && (h(), l.disconnect());
+        });
+      }, { threshold: 0.1, rootMargin: "50px" });
+      l.observe(this.containerEl);
+    } else
+      h();
+    this.fullConfig.layout.debugCenters && this.containerEl && (this.containerEl.querySelectorAll(".fbn-ic-debug-center").forEach((l) => l.remove()), s.forEach((l, g) => {
+      const r = document.createElement("div");
+      r.className = "fbn-ic-debug-center", r.style.position = "absolute", r.style.width = "12px", r.style.height = "12px", r.style.borderRadius = "50%", r.style.backgroundColor = "red", r.style.border = "2px solid yellow", r.style.zIndex = "9999", r.style.pointerEvents = "none";
+      const d = l.x, f = l.y;
+      r.style.left = `${d - 6}px`, r.style.top = `${f - 6}px`, r.title = `Image ${g}: center (${Math.round(d)}, ${Math.round(f)})`, this.containerEl.appendChild(r);
+    })), t.forEach((l, g) => {
+      var f, y;
+      const r = document.createElement("img");
+      r.referrerPolicy = "no-referrer", r.classList.add("fbn-ic-image"), r.dataset.imageId = String(g);
+      const d = s[g];
+      r.style.position = "absolute", r.style.width = "auto", r.style.height = `${e}px`, r.style.left = `${d.x}px`, r.style.top = `${d.y}px`, d.borderColor && !((y = (f = this.fullConfig.styling) == null ? void 0 : f.default) != null && y.border) && (r.style.border = `5px solid ${d.borderColor}`, r.style.boxSizing = "border-box"), d.zIndex && (r.style.zIndex = String(d.zIndex)), lt(r, this.defaultStyles), ht(r, this.defaultClassName), r.addEventListener("mouseenter", () => {
+        this.hoveredImage = { element: r, layout: d }, this.zoomEngine.isInvolved(r) || (lt(r, this.hoverStyles), ht(r, this.hoverClassName));
+      }), r.addEventListener("mouseleave", () => {
+        this.hoveredImage = null, this.zoomEngine.isInvolved(r) || (lt(r, this.defaultStyles), Dt(r, this.hoverClassName), ht(r, this.defaultClassName));
+      }), r.addEventListener("click", (p) => {
+        p.stopPropagation(), this.handleImageClick(r, d);
+      }), r.style.opacity = "0", r.style.transition = this.entryAnimationEngine.getTransitionCSS(), r.onload = () => {
+        if (o !== this.loadGeneration)
+          return;
+        const p = r.naturalWidth / r.naturalHeight, u = e * p;
+        r.style.width = `${u}px`;
+        const m = { x: d.x, y: d.y }, w = { width: u, height: e }, v = this.entryAnimationEngine.calculateStartPosition(
+          m,
+          w,
+          i,
+          g,
+          t.length
+        ), E = this.entryAnimationEngine.calculateStartRotation(d.rotation), M = this.entryAnimationEngine.calculateStartScale(d.scale), x = this.entryAnimationEngine.buildFinalTransform(
+          d.rotation,
+          d.scale,
+          u,
+          e
+        ), L = this.entryAnimationEngine.buildStartTransform(
+          v,
+          m,
+          d.rotation,
+          d.scale,
+          u,
+          e,
+          E,
+          M
+        );
+        this.fullConfig.debug && g < 3 && console.log(`Image ${g}:`, {
+          finalPosition: m,
+          imageSize: w,
+          left: d.x,
+          top: d.y,
+          finalTransform: x,
+          renderedWidth: u,
+          renderedHeight: e
+        }), r.style.transform = L, r.dataset.finalTransform = x, (this.entryAnimationEngine.requiresJSAnimation() || this.entryAnimationEngine.requiresJSRotation() || this.entryAnimationEngine.requiresJSScale() || E !== d.rotation || M !== d.scale) && (r.dataset.startX = String(v.x), r.dataset.startY = String(v.y), r.dataset.endX = String(m.x), r.dataset.endY = String(m.y), r.dataset.imageWidth = String(u), r.dataset.imageHeight = String(e), r.dataset.rotation = String(d.rotation), r.dataset.scale = String(d.scale), r.dataset.startRotation = String(E), r.dataset.startScale = String(M)), this.displayQueue.push(r);
+      }, r.onerror = () => c++, r.src = l;
+    });
+  }
+  async handleImageClick(t, e) {
+    if (!this.containerEl) return;
+    const i = this.zoomEngine.isFocused(t), o = {
+      width: this.containerEl.offsetWidth,
+      height: this.containerEl.offsetHeight
+    };
+    if (i)
+      await this.zoomEngine.unfocusImage(), this.currentFocusIndex = null;
+    else {
+      const s = t.dataset.imageId;
+      this.currentFocusIndex = s !== void 0 ? parseInt(s, 10) : null, await this.zoomEngine.focusImage(t, o, e);
+    }
+  }
+  /**
+   * Clear the image cloud and reset state
+   */
+  clearImageCloud() {
+    this.queueInterval !== null && (clearInterval(this.queueInterval), this.queueInterval = null), this.loadGeneration++, this.displayQueue = [], this.containerEl && (this.containerEl.innerHTML = ""), this.imageElements = [], this.imageLayouts = [], this.currentFocusIndex = null, this.hoveredImage = null, this.layoutEngine.reset(), this.zoomEngine.reset(), this.imagesLoaded = !1;
+  }
+  showLoading(t) {
+    !this.fullConfig.rendering.ui.showLoadingSpinner || !this.loadingEl || (t ? this.loadingEl.classList.remove("fbn-ic-hidden") : this.loadingEl.classList.add("fbn-ic-hidden"));
+  }
+  showError(t) {
+    this.errorEl && (this.errorEl.textContent = t, this.errorEl.classList.remove("fbn-ic-hidden"));
+  }
+  hideError() {
+    this.errorEl && this.errorEl.classList.add("fbn-ic-hidden");
+  }
+  /**
+   * Destroy the gallery and clean up resources
+   */
+  destroy() {
+    this.clearImageCloud(), this.resizeTimeout !== null && clearTimeout(this.resizeTimeout);
+  }
+}
+export {
+  Vt as AnimationEngine,
+  zt as BOUNCE_PRESETS,
+  fe as ClusterPlacementGenerator,
+  Re as CompositeLoader,
+  b as DEFAULT_CONFIG,
+  Tt as ELASTIC_PRESETS,
+  ae as EntryAnimationEngine,
+  Se as GoogleDriveLoader,
+  he as GridPlacementGenerator,
+  Ae as ImageCloud,
+  Ee as ImageFilter,
+  Ae as ImageGallery,
+  ye as LayoutEngine,
+  ce as RadialPlacementGenerator,
+  re as RandomPlacementGenerator,
+  ue as SpiralPlacementGenerator,
+  Ie as StaticImageLoader,
+  Mt as WAVE_PATH_PRESETS,
+  xe as ZoomEngine,
+  ne as animatePath,
+  oe as requiresJSAnimation
+};
+//# sourceMappingURL=image-cloud.js.map