@vanillaskyai/video 0.8.8 → 0.9.0

package/dist/chunk-QAAO7OAY.js

@@ -1,19 +0,0 @@
-// src/visual-system/scene-templates/celebration-particle-timing.ts
-var SECOND_WAVE_INTERVAL = 4;
-var SECOND_WAVE_START = 0.33;
-var SECOND_WAVE_DURATION = 1;
-var EXIT_FADE_START = 0.76;
-var EXIT_FADE_END = 0.85;
-function getCelebrationParticleTiming(sceneProgress, particleIndex, durationFactor) {
-  if (sceneProgress >= EXIT_FADE_END) return null;
-  const isSecondWave = particleIndex % SECOND_WAVE_INTERVAL === 0;
-  if (isSecondWave && sceneProgress <= SECOND_WAVE_START) return null;
-  const waveProgress = isSecondWave ? (sceneProgress - SECOND_WAVE_START) / SECOND_WAVE_DURATION : sceneProgress;
-  const progress = Math.min(1, Math.max(0, waveProgress / durationFactor));
-  const opacity = sceneProgress <= EXIT_FADE_START ? 1 : (EXIT_FADE_END - sceneProgress) / (EXIT_FADE_END - EXIT_FADE_START);
-  return { progress, opacity };
-}
-
-export {
-  getCelebrationParticleTiming
-};

package/dist/chunk-S7HFLYNN.js

@@ -1,35 +0,0 @@
-// src/visual-system/scene-templates/text-utils.ts
-function stripPipe(text) {
-  const idx = text.indexOf("|");
-  return idx === -1 ? text : text.slice(0, idx);
-}
-function getResponsiveFontSize(text, width, role = "headline", height) {
-  const s = height ? Math.min(width, height) / 1080 : width / 1080;
-  const words = text.split(/\s+/).filter(Boolean).length;
-  const chars = text.length;
-  if (role === "subtitle") {
-    if (chars > 60) return 24 * s;
-    if (chars > 30) return 28 * s;
-    return 32 * s;
-  }
-  if (words <= 2 && chars <= 12) return Math.max(36 * s, 96 * s);
-  if (words <= 3 && chars <= 20) return Math.max(36 * s, 80 * s);
-  if (words <= 5 && chars <= 35) return Math.max(36 * s, 64 * s);
-  if (words <= 8 && chars <= 60) return Math.max(36 * s, 48 * s);
-  return 36 * s;
-}
-function fitTextSize(text, baseFontSize, maxWidth, opts) {
-  if (!text) return baseFontSize;
-  const minScale = opts?.minScale ?? 0.5;
-  const charWidthRatio = opts?.charWidthRatio ?? 0.55;
-  const estWidth = text.length * baseFontSize * charWidthRatio;
-  if (estWidth <= maxWidth) return baseFontSize;
-  const scaled = maxWidth / estWidth * baseFontSize;
-  return Math.max(scaled, baseFontSize * minScale);
-}
-
-export {
-  stripPipe,
-  getResponsiveFontSize,
-  fitTextSize
-};

package/dist/chunk-W3VDIBGR.js

@@ -1,217 +0,0 @@
-import {
-  interpolate
-} from "./chunk-XTOXFMLM.js";
-import {
-  darken,
-  resolveTokens
-} from "./chunk-XWWLKRNU.js";
-
-// src/visual-system/theme/colors.ts
-function withOpacity(hex, opacity) {
-  const match = hex.match(/^#([0-9a-f]{3,8})$/i);
-  if (!match) return hex;
-  const h = match[1];
-  let r;
-  let g;
-  let b;
-  if (h.length === 3) {
-    r = parseInt(h[0] + h[0], 16);
-    g = parseInt(h[1] + h[1], 16);
-    b = parseInt(h[2] + h[2], 16);
-  } else if (h.length >= 6) {
-    r = parseInt(h.slice(0, 2), 16);
-    g = parseInt(h.slice(2, 4), 16);
-    b = parseInt(h.slice(4, 6), 16);
-  } else {
-    return hex;
-  }
-  return `rgba(${r},${g},${b},${opacity})`;
-}
-function orderDarkToLight(a, b) {
-  const luminance = (hex) => {
-    const match = hex.match(/^#([0-9a-f]{6})$/i);
-    if (!match) return 0;
-    const h = match[1];
-    return 0.299 * parseInt(h.slice(0, 2), 16) + 0.587 * parseInt(h.slice(2, 4), 16) + 0.114 * parseInt(h.slice(4, 6), 16);
-  };
-  return luminance(a) <= luminance(b) ? [a, b] : [b, a];
-}
-function relativeLuminance(hex) {
-  const match = hex.match(/^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i);
-  if (!match) return void 0;
-  const value = match[1].length === 3 ? match[1].split("").map((character) => character + character).join("") : match[1].slice(0, 6);
-  const channel = (offset) => {
-    const encoded = Number.parseInt(value.slice(offset, offset + 2), 16) / 255;
-    return encoded <= 0.04045 ? encoded / 12.92 : ((encoded + 0.055) / 1.055) ** 2.4;
-  };
-  return 0.2126 * channel(0) + 0.7152 * channel(2) + 0.0722 * channel(4);
-}
-function contrastRatio(first, second) {
-  const firstLuminance = relativeLuminance(first);
-  const secondLuminance = relativeLuminance(second);
-  if (firstLuminance == null || secondLuminance == null) return 0;
-  return (Math.max(firstLuminance, secondLuminance) + 0.05) / (Math.min(firstLuminance, secondLuminance) + 0.05);
-}
-function accessibleTextColor(background, preferred) {
-  if (preferred && contrastRatio(background, preferred) >= 4.5) return preferred;
-  return contrastRatio(background, "#FFFFFF") >= contrastRatio(background, "#000000") ? "#FFFFFF" : "#000000";
-}
-function autoTextColor(background) {
-  return accessibleTextColor(background);
-}
-
-// src/visual-system/scene-templates/color-utils.ts
-import React from "react";
-var TOP_TEXT_AREA_RATIO = 0.32;
-function gradientBackground({
-  colorA,
-  colorB,
-  solidBg,
-  progress,
-  sceneDuration,
-  seed,
-  family
-}) {
-  if (solidBg) return solidBg;
-  const normalizedProgress = Math.max(0, Math.min(1, progress));
-  const atBoundary = normalizedProgress === 0 || normalizedProgress === 1;
-  const easedLoop = normalizedProgress * normalizedProgress * (3 - 2 * normalizedProgress);
-  const seedEnvelope = atBoundary ? 0 : Math.sin(normalizedProgress * Math.PI) ** 2;
-  void sceneDuration;
-  const seededRandom = (s) => {
-    const x = Math.sin(s * 12.9898 + s * 78.233) * 43758.5453;
-    return x - Math.floor(x);
-  };
-  const phase = seededRandom(seed) * Math.PI * 2 * seedEnvelope;
-  const t = (atBoundary ? 0 : easedLoop * Math.PI * 2) + phase;
-  const [topColor, bottomColor] = orderDarkToLight(colorA, colorB);
-  if (family === "wash") {
-    const shift = Math.sin(t) * 6;
-    return `linear-gradient(${175 + shift}deg, ${topColor} 0%, ${bottomColor} 100%)`;
-  }
-  if (family === "spotlight") {
-    const x = 50 + Math.sin(t) * 8;
-    const y = 28 + Math.cos(t + 1) * 5;
-    return `
-      radial-gradient(ellipse 70% 55% at ${x}% ${y}%, ${colorA}66 0%, ${colorA}1a 45%, transparent 72%),
-      linear-gradient(180deg, ${darken(topColor, 0.55)} 0%, ${darken(bottomColor, 0.7)} 100%)
-    `;
-  }
-  const x1 = 25 + Math.sin(t) * 25;
-  const y1 = 30 + Math.cos(t + 1) * 25;
-  const x2 = 75 + Math.sin(t + 2) * 25;
-  const y2 = 70 + Math.cos(t + 3.5) * 25;
-  return `
-    radial-gradient(ellipse 60% 60% at ${x1}% ${y1}%, ${colorA}4d 0%, transparent 65%),
-    radial-gradient(ellipse 60% 60% at ${x2}% ${y2}%, ${colorB}4d 0%, transparent 65%),
-    linear-gradient(180deg, ${topColor} 0%, ${bottomColor} 100%)
-  `;
-}
-var BrandGradientOverlay = ({ style: globalStyle, progress, sceneDuration, seed }) => {
-  const tokens = resolveTokens(globalStyle);
-  const [first, second] = tokens.background.type === "gradient" ? tokens.background.colors : [tokens.background.color, tokens.background.color];
-  const solidBg = tokens.background.type === "solid" ? tokens.background.color : void 0;
-  return React.createElement("div", {
-    "data-brand-gradient": "true",
-    style: {
-      position: "absolute",
-      inset: 0,
-      background: gradientBackground({ colorA: first, colorB: second, solidBg, progress, sceneDuration, seed, family: tokens.preset.background }),
-      pointerEvents: "none"
-    }
-  });
-};
-
-// src/visual-system/scene-templates/background-effect.ts
-var DIRECTIONS = ["right", "left", "up", "down"];
-function getKenBurnsTransform(progress, direction) {
-  const scale = interpolate(progress, [0, 1], [1.05, 1.15]);
-  const mainAxis = direction === "right" || direction === "left";
-  const sign = direction === "right" || direction === "down" ? 1 : -1;
-  const primary = interpolate(progress, [0, 1], [-2 * sign, 2 * sign]);
-  const secondary = interpolate(progress, [0, 1], [-0.5, 0.5]);
-  const x = mainAxis ? primary : secondary;
-  const y = mainAxis ? secondary : primary;
-  return {
-    transform: `scale(${scale}) translate(${x}%, ${y}%)`,
-    transformOrigin: "center"
-  };
-}
-function getDriftTransform(progress, direction) {
-  const horizontal = direction === "right" || direction === "left";
-  const sign = direction === "right" || direction === "down" ? 1 : -1;
-  const offset = interpolate(progress, [0, 1], [-2 * sign, 2 * sign]);
-  return {
-    transform: horizontal ? `scale(1.1) translateX(${offset}%)` : `scale(1.1) translateY(${offset}%)`,
-    transformOrigin: "center"
-  };
-}
-function getBackgroundTransform(effect, progress, beatIntensity = 0, sceneIndex = 0) {
-  const dir = DIRECTIONS[sceneIndex % DIRECTIONS.length];
-  const resolved = effect ?? "static";
-  switch (resolved) {
-    case "slow-zoom-in":
-      return {
-        transform: `scale(${interpolate(progress, [0, 1], [1, 1.12])})`,
-        transformOrigin: "center"
-      };
-    case "slow-zoom-out":
-      return {
-        transform: `scale(${interpolate(progress, [0, 1], [1.12, 1])})`,
-        transformOrigin: "center"
-      };
-    case "ken-burns":
-      return getKenBurnsTransform(progress, dir);
-    case "drift":
-      return getDriftTransform(progress, dir);
-    case "pulse": {
-      const base = 1 + beatIntensity * 0.04;
-      const breathe = 1 + Math.sin(progress * Math.PI * 2) * 0.02;
-      return {
-        transform: `scale(${base * breathe})`,
-        transformOrigin: "center"
-      };
-    }
-    case "breathe": {
-      const s = 1 + Math.sin(progress * Math.PI) * 0.03;
-      const y = Math.sin(progress * Math.PI) * 0.5;
-      return {
-        transform: `scale(${s}) translateY(${y}%)`,
-        transformOrigin: "center"
-      };
-    }
-    case "slow-tilt": {
-      const angle = interpolate(progress, [0, 1], [0, 2.5]);
-      return {
-        transform: `scale(1.08) rotate(${angle}deg)`,
-        transformOrigin: "center"
-      };
-    }
-    case "camera-shake": {
-      const t = progress * 40;
-      const sx = Math.sin(t * 2.3) * 0.4 + Math.sin(t * 5.7) * 0.2;
-      const sy = Math.cos(t * 3.1) * 0.3 + Math.cos(t * 4.9) * 0.15;
-      const sr = Math.sin(t * 1.7) * 0.3;
-      return {
-        transform: `scale(1.05) translate(${sx}%, ${sy}%) rotate(${sr}deg)`,
-        transformOrigin: "center"
-      };
-    }
-    case "static":
-    default:
-      return {
-        transform: "none",
-        transformOrigin: "center"
-      };
-  }
-}
-
-export {
-  withOpacity,
-  accessibleTextColor,
-  autoTextColor,
-  TOP_TEXT_AREA_RATIO,
-  gradientBackground,
-  BrandGradientOverlay,
-  getBackgroundTransform
-};

package/dist/chunk-XGRA2MUV.js

@@ -1,242 +0,0 @@
-// src/protocol/background.ts
-var BACKGROUND_PRESETS = {
-  cosmic: { type: "gradient", colors: ["#8711C1", "#2167E3"] },
-  horizon: { type: "gradient", colors: ["#5967C4", "#133A94"] },
-  twilight: { type: "gradient", colors: ["#0C1740", "#3D1B66"] },
-  meadow: { type: "gradient", colors: ["#348756", "#54B6CA"] },
-  velvet: { type: "gradient", colors: ["#76030F", "#121B67"] },
-  flamingo: { type: "gradient", colors: ["#C72D50", "#3E3B92"] },
-  peach: { type: "gradient", colors: ["#B45A4A", "#AD336D"] },
-  saffron: { type: "gradient", colors: ["#F3696E", "#F8A902"] },
-  black: { type: "solid", color: "#000000" },
-  midnight: { type: "solid", color: "#070B20" },
-  aubergine: { type: "solid", color: "#170A2E" },
-  coal: { type: "solid", color: "#0A0A0A" },
-  navy: { type: "solid", color: "#0A2240" }
-};
-var DEFAULT_BACKGROUND_PRESET = "cosmic";
-var DEFAULT_COLORS = {
-  primary: "#00E5A0",
-  secondary: "#006BE5",
-  foreground: "#FFFFFF",
-  surface: "#0A0A14",
-  surfaceElevated: "#14152A",
-  muted: "#A7A6B0"
-};
-var HEX_COLOR = /^#[0-9a-f]{6}$/i;
-var MINIMUM_TEXT_CONTRAST = 4.5;
-function normalizeColor(value, path) {
-  if (!HEX_COLOR.test(value)) throw new Error(`${path} must be a hex color`);
-  return value.toUpperCase();
-}
-function resolveBackground(input) {
-  if (input == null || typeof input === "string") {
-    const preset = BACKGROUND_PRESETS[input ?? DEFAULT_BACKGROUND_PRESET];
-    return preset.type === "solid" ? { type: "solid", color: preset.color } : { type: "gradient", colors: [...preset.colors] };
-  }
-  if ("color" in input) {
-    return { type: "solid", color: normalizeColor(input.color, "brand.background.color") };
-  }
-  return {
-    type: "gradient",
-    colors: [
-      normalizeColor(input.colors[0], "brand.background.colors[0]"),
-      normalizeColor(input.colors[1], "brand.background.colors[1]")
-    ]
-  };
-}
-function channel(value) {
-  const normalized = value / 255;
-  return normalized <= 0.04045 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
-}
-function luminance(color) {
-  return 0.2126 * channel(Number.parseInt(color.slice(1, 3), 16)) + 0.7152 * channel(Number.parseInt(color.slice(3, 5), 16)) + 0.0722 * channel(Number.parseInt(color.slice(5, 7), 16));
-}
-function gradientLuminanceAt(colors, progress) {
-  const channels = colors.map((color) => [1, 3, 5].map((offset) => Number.parseInt(color.slice(offset, offset + 2), 16)));
-  return 0.2126 * channel(channels[0][0] + (channels[1][0] - channels[0][0]) * progress) + 0.7152 * channel(channels[0][1] + (channels[1][1] - channels[0][1]) * progress) + 0.0722 * channel(channels[0][2] + (channels[1][2] - channels[0][2]) * progress);
-}
-function backgroundLuminanceRange(background) {
-  if (background.type === "solid") {
-    const value = luminance(background.color);
-    return [value, value];
-  }
-  const start = luminance(background.colors[0]);
-  const end = luminance(background.colors[1]);
-  let left = 0;
-  let right = 1;
-  for (let iteration = 0; iteration < 64; iteration += 1) {
-    const first = left + (right - left) / 3;
-    const second = right - (right - left) / 3;
-    if (gradientLuminanceAt(background.colors, first) <= gradientLuminanceAt(background.colors, second)) {
-      right = second;
-    } else {
-      left = first;
-    }
-  }
-  const minimum = Math.min(start, end, gradientLuminanceAt(background.colors, (left + right) / 2));
-  return [minimum, Math.max(start, end)];
-}
-function minimumBackgroundContrast(background, foreground) {
-  const foregroundLuminance = luminance(foreground);
-  const [minimum, maximum] = backgroundLuminanceRange(background);
-  if (foregroundLuminance < minimum) {
-    return (minimum + 0.05) / (foregroundLuminance + 0.05);
-  }
-  if (foregroundLuminance > maximum) {
-    return (foregroundLuminance + 0.05) / (maximum + 0.05);
-  }
-  return 1;
-}
-function resolveForeground(input, background) {
-  const supplied = input?.colors?.foreground;
-  if (supplied != null) return normalizeColor(supplied, "brand.colors.foreground");
-  const candidates = ["#FFFFFF", "#000000"];
-  const foreground = candidates.map((color) => ({ color, contrast: minimumBackgroundContrast(background, color) })).sort((left, right) => right.contrast - left.contrast)[0];
-  if (foreground.contrast < MINIMUM_TEXT_CONTRAST) {
-    throw new Error(
-      "brand.colors.foreground is required because neither black nor white contrasts with the entire background; choose a background with one consistently readable foreground"
-    );
-  }
-  return foreground.color;
-}
-function validateResolvedBrandContrast(brand, path) {
-  const contrast = minimumBackgroundContrast(brand.background, brand.colors.foreground);
-  if (contrast < MINIMUM_TEXT_CONTRAST) {
-    throw new Error(
-      `${path}.colors.foreground must have at least 4.5:1 contrast across ${path}.background (minimum ${contrast.toFixed(2)}:1); choose a different foreground or background)`
-    );
-  }
-}
-function resolveVideoBrand(input) {
-  validateBrandInput(input, "brand");
-  const background = resolveBackground(input?.background);
-  const colors = Object.fromEntries(Object.entries({
-    ...DEFAULT_COLORS,
-    ...input?.colors,
-    foreground: resolveForeground(input, background)
-  }).map(([name, value]) => [name, normalizeColor(value, `brand.colors.${name}`)]));
-  const brand = {
-    ...input?.name?.trim() ? { name: input.name.trim() } : {},
-    ...input?.logoUrl?.trim() ? { logoUrl: input.logoUrl.trim() } : {},
-    font: input?.font?.trim() || "Inter",
-    scriptFont: input?.scriptFont?.trim() || "Caveat",
-    background,
-    colors
-  };
-  validateResolvedBrandContrast(brand, "brand");
-  return brand;
-}
-function isBackgroundPreset(value) {
-  return Object.prototype.hasOwnProperty.call(BACKGROUND_PRESETS, value);
-}
-function validateBrandBackgroundInput(value, path) {
-  if (typeof value === "string") {
-    if (!isBackgroundPreset(value)) throw new Error(`${path} preset is unsupported`);
-    return;
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${path} must be a preset or custom color object`);
-  }
-  const background = value;
-  const keys = Object.keys(background);
-  if (keys.length !== 1 || keys[0] !== "color" && keys[0] !== "colors") {
-    throw new Error(`${path} must contain either color or colors`);
-  }
-  if ("color" in background) {
-    if (typeof background.color !== "string") throw new Error(`${path}.color must be a hex color`);
-    normalizeColor(background.color, `${path}.color`);
-    return;
-  }
-  if (!Array.isArray(background.colors) || background.colors.length !== 2 || background.colors.some((color) => typeof color !== "string")) {
-    throw new Error(`${path}.colors must contain two colors`);
-  }
-  background.colors.forEach((color, index) => normalizeColor(color, `${path}.colors[${index}]`));
-}
-function validateBrandInput(value, path) {
-  if (value == null) return;
-  if (typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must be an object`);
-  const input = value;
-  const allowed = /* @__PURE__ */ new Set(["name", "logoUrl", "font", "scriptFont", "background", "colors"]);
-  for (const key of Object.keys(input)) {
-    if (!allowed.has(key)) throw new Error(`${path} contains unsupported field ${key}`);
-  }
-  for (const key of ["name", "logoUrl", "font", "scriptFont"]) {
-    if (input[key] != null && (typeof input[key] !== "string" || !input[key].trim())) {
-      throw new Error(`${path}.${key} must be a non-empty string`);
-    }
-  }
-  if (input.background != null) validateBrandBackgroundInput(input.background, `${path}.background`);
-  if (input.colors != null) {
-    if (typeof input.colors !== "object" || Array.isArray(input.colors)) {
-      throw new Error(`${path}.colors must be an object`);
-    }
-    const colors = input.colors;
-    const colorNames = new Set(Object.keys(DEFAULT_COLORS));
-    for (const [name, color] of Object.entries(colors)) {
-      if (!colorNames.has(name)) throw new Error(`${path}.colors contains unsupported field ${name}`);
-      if (typeof color !== "string") throw new Error(`${path}.colors.${name} must be a hex color`);
-      normalizeColor(color, `${path}.colors.${name}`);
-    }
-  }
-}
-function validateVideoBrand(value, path) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${path} must be an object`);
-  }
-  const brand = value;
-  const allowed = /* @__PURE__ */ new Set(["name", "logoUrl", "font", "scriptFont", "background", "colors"]);
-  for (const key of Object.keys(brand)) {
-    if (!allowed.has(key)) throw new Error(`${path} contains unsupported field ${key}`);
-  }
-  for (const key of ["font", "scriptFont"]) {
-    if (typeof brand[key] !== "string" || !brand[key].trim()) {
-      throw new Error(`${path}.${key} must be a non-empty string`);
-    }
-  }
-  for (const key of ["name", "logoUrl"]) {
-    if (brand[key] != null && (typeof brand[key] !== "string" || !brand[key].trim())) {
-      throw new Error(`${path}.${key} must be a non-empty string`);
-    }
-  }
-  if (!brand.background || typeof brand.background !== "object" || Array.isArray(brand.background)) {
-    throw new Error(`${path}.background must be an object`);
-  }
-  const background = brand.background;
-  if (background.type === "solid") {
-    if (Object.keys(background).some((key) => key !== "type" && key !== "color")) {
-      throw new Error(`${path}.background contains unsupported fields`);
-    }
-    if (typeof background.color !== "string") throw new Error(`${path}.background.color must be a hex color`);
-    normalizeColor(background.color, `${path}.background.color`);
-  } else if (background.type === "gradient") {
-    if (Object.keys(background).some((key) => key !== "type" && key !== "colors")) {
-      throw new Error(`${path}.background contains unsupported fields`);
-    }
-    if (!Array.isArray(background.colors) || background.colors.length !== 2 || background.colors.some((color) => typeof color !== "string")) {
-      throw new Error(`${path}.background.colors must contain two colors`);
-    }
-    background.colors.forEach((color, index) => normalizeColor(color, `${path}.background.colors[${index}]`));
-  } else {
-    throw new Error(`${path}.background.type is unsupported`);
-  }
-  if (!brand.colors || typeof brand.colors !== "object" || Array.isArray(brand.colors)) {
-    throw new Error(`${path}.colors must be an object`);
-  }
-  const colors = brand.colors;
-  const requiredColors = Object.keys(DEFAULT_COLORS);
-  for (const name of requiredColors) {
-    if (typeof colors[name] !== "string") throw new Error(`${path}.colors.${name} must be a hex color`);
-    normalizeColor(colors[name], `${path}.colors.${name}`);
-  }
-  for (const name of Object.keys(colors)) {
-    if (!requiredColors.includes(name)) throw new Error(`${path}.colors contains unsupported field ${name}`);
-  }
-  validateResolvedBrandContrast(brand, path);
-}
-
-export {
-  resolveVideoBrand,
-  validateBrandInput,
-  validateVideoBrand
-};

package/dist/chunk-XTOXFMLM.js

@@ -1,105 +0,0 @@
-// src/visual-system/motion/curves.ts
-function cubicBezier(x1, y1, x2, y2) {
-  const cx = 3 * x1;
-  const bx = 3 * (x2 - x1) - cx;
-  const ax = 1 - cx - bx;
-  const cy = 3 * y1;
-  const by = 3 * (y2 - y1) - cy;
-  const ay = 1 - cy - by;
-  const sampleX = (t) => ((ax * t + bx) * t + cx) * t;
-  const sampleY = (t) => ((ay * t + by) * t + cy) * t;
-  const sampleDX = (t) => (3 * ax * t + 2 * bx) * t + cx;
-  return (x) => {
-    if (x <= 0) return 0;
-    if (x >= 1) return 1;
-    let t = x;
-    for (let i = 0; i < 8; i++) {
-      const err = sampleX(t) - x;
-      if (Math.abs(err) < 1e-6) return sampleY(t);
-      const d = sampleDX(t);
-      if (Math.abs(d) < 1e-6) break;
-      t -= err / d;
-    }
-    let lo = 0;
-    let hi = 1;
-    t = x;
-    for (let i = 0; i < 24; i++) {
-      const v = sampleX(t);
-      if (Math.abs(v - x) < 1e-6) break;
-      if (v < x) lo = t;
-      else hi = t;
-      t = (lo + hi) / 2;
-    }
-    return sampleY(t);
-  };
-}
-var Easing = {
-  /** Easing.bezier(0.16, 1, 0.3, 1) — the canonical curve syntax from docs/motion-library.md. */
-  bezier: cubicBezier,
-  // Curves
-  linear: (t) => t,
-  quad: (t) => t * t,
-  cubic: (t) => t * t * t,
-  sin: (t) => 1 - Math.cos(t * Math.PI / 2),
-  exp: (t) => t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),
-  circle: (t) => 1 - Math.sqrt(1 - t * t),
-  // Directional modifiers
-  in: (fn) => fn,
-  out: (fn) => (t) => 1 - fn(1 - t),
-  inOut: (fn) => (t) => t < 0.5 ? fn(t * 2) / 2 : 1 - fn((1 - t) * 2) / 2
-};
-function interpolate(value, inputRange, outputRange, options) {
-  const { easing, extrapolateLeft = "extend", extrapolateRight = "extend" } = options ?? {};
-  let i = 0;
-  for (; i < inputRange.length - 2; i++) {
-    if (value < inputRange[i + 1]) break;
-  }
-  const inputMin = inputRange[i];
-  const inputMax = inputRange[i + 1];
-  const outputMin = outputRange[i];
-  const outputMax = outputRange[i + 1];
-  let t = inputMax === inputMin ? 0 : (value - inputMin) / (inputMax - inputMin);
-  if (t < 0 && extrapolateLeft === "clamp") t = 0;
-  if (t > 1 && extrapolateRight === "clamp") t = 1;
-  if (easing && t >= 0 && t <= 1) {
-    t = easing(t);
-  }
-  return outputMin + t * (outputMax - outputMin);
-}
-var SPRING_SMOOTH = { damping: 26, stiffness: 170 };
-var SPRING_SNAPPY = { damping: 20, stiffness: 300 };
-var SPRING_BOUNCY = { damping: 10, stiffness: 180 };
-var SPRING_CRISP = { damping: 14, stiffness: 320 };
-function spring(progress, config) {
-  if (progress <= 0) return 0;
-  if (progress >= 1) {
-    const { damping: damping2 = 26 } = config ?? {};
-    if (damping2 >= 20) return 1;
-  }
-  const { damping = 26, stiffness = 170, mass = 1 } = config ?? {};
-  const omega = Math.sqrt(stiffness / mass);
-  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
-  const t = progress * 3.5;
-  let value;
-  if (zeta < 1) {
-    const omegaD = omega * Math.sqrt(1 - zeta * zeta);
-    value = 1 - Math.exp(-zeta * omega * t) * (Math.cos(omegaD * t) + zeta * omega / omegaD * Math.sin(omegaD * t));
-  } else if (zeta === 1) {
-    value = 1 - Math.exp(-omega * t) * (1 + omega * t);
-  } else {
-    const s1 = -omega * (zeta + Math.sqrt(zeta * zeta - 1));
-    const s2 = -omega * (zeta - Math.sqrt(zeta * zeta - 1));
-    value = 1 + (s1 * Math.exp(s2 * t) - s2 * Math.exp(s1 * t)) / (s2 - s1);
-  }
-  return value;
-}
-
-export {
-  Easing,
-  interpolate,
-  SPRING_SMOOTH,
-  SPRING_SNAPPY,
-  SPRING_BOUNCY,
-  SPRING_CRISP,
-  spring
-};