@pixerate/editor 0.27.0 → 0.28.0

package/dist/chunk-PWJARCI4.js

@@ -0,0 +1,637 @@
+import {
+  hexToRgba,
+  normalizeTokenColor,
+  rgbaToHex
+} from "./chunk-TGD52FEZ.js";
+
+// src/animation/easing.ts
+var ANIMATION_EASING_PRESETS = [
+  "linear",
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "ease-in-back",
+  "ease-out-back",
+  "spring",
+  "hold"
+];
+var ANIMATION_EASING_LABELS = {
+  linear: "Linear",
+  hold: "Hold",
+  ease: "Ease",
+  "ease-in": "Ease in",
+  "ease-out": "Ease out",
+  "ease-in-out": "Ease in-out",
+  "ease-in-back": "Back in",
+  "ease-out-back": "Back out",
+  spring: "Spring"
+};
+var CUBIC_BEZIER_PRESETS = {
+  linear: [0, 0, 1, 1],
+  ease: [0.25, 0.1, 0.25, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1],
+  "ease-in-back": [0.36, 0, 0.66, -0.56],
+  "ease-out-back": [0.34, 1.56, 0.64, 1]
+};
+var DEFAULT_SPRING = { stiffness: 170, damping: 26, mass: 1, velocity: 0 };
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var finite = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+function cubicBezierAt(x1, y1, x2, y2, x) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  x1 = clamp(x1, 0, 1);
+  x2 = clamp(x2, 0, 1);
+  const bx = (s2) => 3 * (1 - s2) * (1 - s2) * s2 * x1 + 3 * (1 - s2) * s2 * s2 * x2 + s2 * s2 * s2;
+  const by = (s2) => 3 * (1 - s2) * (1 - s2) * s2 * y1 + 3 * (1 - s2) * s2 * s2 * y2 + s2 * s2 * s2;
+  const dbx = (s2) => 3 * (1 - s2) * (1 - s2) * x1 + 6 * (1 - s2) * s2 * (x2 - x1) + 3 * s2 * s2 * (1 - x2);
+  let s = x;
+  for (let i = 0; i < 8; i++) {
+    const d = dbx(s);
+    if (Math.abs(d) < 1e-9) break;
+    const next = s - (bx(s) - x) / d;
+    if (!(next >= 0 && next <= 1)) break;
+    s = next;
+  }
+  if (Math.abs(bx(s) - x) > 1e-7) {
+    let lo = 0;
+    let hi = 1;
+    for (let i = 0; i < 60; i++) {
+      s = (lo + hi) / 2;
+      if (bx(s) < x) lo = s;
+      else hi = s;
+    }
+  }
+  return by(s);
+}
+function springAt(spring, seconds) {
+  const stiffness = Math.max(1e-6, finite(spring.stiffness, DEFAULT_SPRING.stiffness));
+  const damping = Math.max(0, finite(spring.damping, DEFAULT_SPRING.damping));
+  const mass = Math.max(1e-6, finite(spring.mass, DEFAULT_SPRING.mass));
+  const v0 = -finite(spring.velocity, DEFAULT_SPRING.velocity);
+  const t = Math.max(0, seconds);
+  const w0 = Math.sqrt(stiffness / mass);
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  let x;
+  if (zeta < 1 - 1e-6) {
+    const wd = w0 * Math.sqrt(1 - zeta * zeta);
+    x = Math.exp(-zeta * w0 * t) * (Math.cos(wd * t) + (zeta * w0 + v0) / wd * Math.sin(wd * t));
+  } else if (zeta <= 1 + 1e-6) {
+    x = Math.exp(-w0 * t) * (1 + (w0 + v0) * t);
+  } else {
+    const r = Math.sqrt(zeta * zeta - 1);
+    const s1 = -w0 * (zeta - r);
+    const s2 = -w0 * (zeta + r);
+    const c2 = (v0 - s1) / (s2 - s1);
+    const c1 = 1 - c2;
+    x = c1 * Math.exp(s1 * t) + c2 * Math.exp(s2 * t);
+  }
+  return 1 - x;
+}
+function resolveEasing(easing) {
+  if (easing === "hold") return "hold";
+  if (easing === "spring") return { type: "spring", ...DEFAULT_SPRING };
+  if (typeof easing === "string") {
+    const preset = CUBIC_BEZIER_PRESETS[easing];
+    if (preset) return { type: "cubic-bezier", x1: preset[0], y1: preset[1], x2: preset[2], y2: preset[3] };
+    const parsed = parseCssEasing(easing);
+    return parsed ? resolveEasing(parsed) : { type: "cubic-bezier", x1: 0, y1: 0, x2: 1, y2: 1 };
+  }
+  if (easing && typeof easing === "object") {
+    if (easing.type === "spring") {
+      return {
+        type: "spring",
+        stiffness: finite(easing.stiffness, DEFAULT_SPRING.stiffness),
+        damping: finite(easing.damping, DEFAULT_SPRING.damping),
+        mass: finite(easing.mass, DEFAULT_SPRING.mass),
+        velocity: finite(easing.velocity, DEFAULT_SPRING.velocity)
+      };
+    }
+    if (easing.type === "cubic-bezier") {
+      return {
+        type: "cubic-bezier",
+        x1: clamp(finite(easing.x1, 0), 0, 1),
+        y1: finite(easing.y1, 0),
+        x2: clamp(finite(easing.x2, 1), 0, 1),
+        y2: finite(easing.y2, 1)
+      };
+    }
+  }
+  return { type: "cubic-bezier", x1: 0, y1: 0, x2: 1, y2: 1 };
+}
+function evaluateEasing(easing, u, durationMs = 1e3) {
+  if (!(u > 0)) return 0;
+  if (u >= 1) return 1;
+  const resolved = resolveEasing(easing);
+  if (resolved === "hold") return 0;
+  if (resolved.type === "spring") return springAt(resolved, u * Math.max(0, durationMs) / 1e3);
+  const { x1, y1, x2, y2 } = resolved;
+  if (x1 === y1 && x2 === y2) return u;
+  return cubicBezierAt(x1, y1, x2, y2, u);
+}
+function easingFromInfluence(outInfluence = 1 / 3, inInfluence = 1 / 3) {
+  return {
+    type: "cubic-bezier",
+    x1: clamp(outInfluence, 0.01, 1),
+    y1: 0,
+    x2: 1 - clamp(inInfluence, 0.01, 1),
+    y2: 1
+  };
+}
+var NUMBER = String.raw`\s*(-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)\s*`;
+var CUBIC_RE = new RegExp(`^cubic-bezier\\(${NUMBER},${NUMBER},${NUMBER},${NUMBER}\\)$`, "i");
+function parseCssEasing(text) {
+  const value = text.trim().toLowerCase();
+  if (value.length > 200) return null;
+  if (ANIMATION_EASING_PRESETS.includes(value)) return value;
+  if (value === "step-end" || /^steps\(\s*1\s*(,\s*(end|jump-end)\s*)?\)$/.test(value)) return "hold";
+  const m = CUBIC_RE.exec(value);
+  if (!m) return null;
+  const [x1, y1, x2, y2] = m.slice(1).map(Number);
+  if (![x1, y1, x2, y2].every(Number.isFinite) || x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) return null;
+  return { type: "cubic-bezier", x1, y1, x2, y2 };
+}
+function isAnimationEasing(value) {
+  if (typeof value === "string") return parseCssEasing(value) !== null;
+  if (typeof value !== "object" || value === null) return false;
+  const e = value;
+  if (e.type === "spring") return true;
+  return e.type === "cubic-bezier" && [e.x1, e.y1, e.x2, e.y2].every((v) => typeof v === "number" && Number.isFinite(v));
+}
+var round = (v, digits = 4) => {
+  const p = 10 ** digits;
+  return Math.round(v * p) / p;
+};
+function easingToCss(easing, durationMs = 1e3, samples = 24) {
+  const resolved = resolveEasing(easing);
+  if (resolved === "hold") return "steps(1, end)";
+  if (resolved.type === "spring") {
+    const n = Math.max(2, Math.floor(samples));
+    const points = [];
+    for (let i = 0; i <= n; i++) points.push(String(round(i === n ? 1 : springAt(resolved, i / n * durationMs / 1e3))));
+    return `linear(${points.join(", ")})`;
+  }
+  const { x1, y1, x2, y2 } = resolved;
+  for (const [name, p] of Object.entries(CUBIC_BEZIER_PRESETS)) {
+    if (["linear", "ease", "ease-in", "ease-out", "ease-in-out"].includes(name) && p[0] === x1 && p[1] === y1 && p[2] === x2 && p[3] === y2) {
+      return name;
+    }
+  }
+  return `cubic-bezier(${round(x1)}, ${round(y1)}, ${round(x2)}, ${round(y2)})`;
+}
+function easingLabel(easing) {
+  if (easing === void 0 || easing === null) return ANIMATION_EASING_LABELS.linear;
+  if (typeof easing === "string") return ANIMATION_EASING_LABELS[easing] ?? easing;
+  return easing.type === "spring" ? "Spring" : "Custom";
+}
+
+// src/animation/color.ts
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+var toGamma = (c) => c <= 31308e-7 ? 12.92 * c : 1.055 * Math.sign(c) * Math.abs(c) ** (1 / 2.4) - 0.055;
+function rgbToOklab(r, g, b, alpha = 1) {
+  const lr = toLinear(r);
+  const lg = toLinear(g);
+  const lb = toLinear(b);
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return {
+    l: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    alpha
+  };
+}
+function oklabToRgb(color) {
+  const l_ = color.l + 0.3963377774 * color.a + 0.2158037573 * color.b;
+  const m_ = color.l - 0.1055613458 * color.a - 0.0638541728 * color.b;
+  const s_ = color.l - 0.0894841775 * color.a - 1.291485548 * color.b;
+  const l = l_ ** 3;
+  const m = m_ ** 3;
+  const s = s_ ** 3;
+  const clamp01 = (v) => Math.min(1, Math.max(0, v));
+  return {
+    r: clamp01(toGamma(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s)),
+    g: clamp01(toGamma(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s)),
+    b: clamp01(toGamma(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)),
+    a: clamp01(color.alpha)
+  };
+}
+function parseOklab(input) {
+  const hex = normalizeTokenColor(input);
+  if (hex === null) return null;
+  const c = hexToRgba(hex);
+  return rgbToOklab(c.r, c.g, c.b, c.a);
+}
+function formatOklab(color) {
+  const { r, g, b, a } = oklabToRgb(color);
+  return rgbaToHex(r, g, b, a);
+}
+function mixColorsOklab(from, to, t) {
+  const a = parseOklab(from);
+  const b = parseOklab(to);
+  if (!a || !b) return null;
+  const alpha = a.alpha + (b.alpha - a.alpha) * t;
+  const premul = (k) => a[k] * a.alpha + (b[k] * b.alpha - a[k] * a.alpha) * t;
+  if (alpha <= 1e-9) return formatOklab({ l: a.l + (b.l - a.l) * t, a: 0, b: 0, alpha: 0 });
+  return formatOklab({ l: premul("l") / alpha, a: premul("a") / alpha, b: premul("b") / alpha, alpha });
+}
+
+// src/animation/keyframes.ts
+var ANIMATION_TIME_EPSILON = 1e-6;
+function isValue(value) {
+  return typeof value === "number" && Number.isFinite(value) || typeof value === "string";
+}
+function isAnimationKeyframe(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const k = value;
+  return typeof k.time === "number" && Number.isFinite(k.time) && isValue(k.value) && (k.easing === void 0 || isAnimationEasing(k.easing));
+}
+var sortedCache = /* @__PURE__ */ new WeakMap();
+function normalizeKeyframes(keyframes) {
+  if (!Array.isArray(keyframes)) return [];
+  const cached = sortedCache.get(keyframes);
+  if (cached && cached.items.length === keyframes.length && cached.items.every((k, i) => k === keyframes[i])) return cached.out;
+  const indexed = keyframes.map((k, i) => ({ k, i })).filter(({ k }) => isAnimationKeyframe(k)).sort((a, b) => a.k.time - b.k.time || a.i - b.i);
+  const out = [];
+  let lastIndex = -1;
+  for (const { k, i } of indexed) {
+    const prev = out[out.length - 1];
+    if (prev && Math.abs(k.time - prev.time) <= ANIMATION_TIME_EPSILON) {
+      if (i > lastIndex) {
+        out[out.length - 1] = k;
+        lastIndex = i;
+      }
+      continue;
+    }
+    out.push(k);
+    lastIndex = i;
+  }
+  sortedCache.set(keyframes, { items: [...keyframes], out });
+  return out;
+}
+
+// src/animation/evaluate.ts
+function interpolateAnimationValue(from, to, t, type = "number") {
+  if (typeof from === "number" && typeof to === "number") return from + (to - from) * t;
+  if (t <= 0) return from;
+  if (t >= 1) return to;
+  if (type === "color" || typeof from === "string" && typeof to === "string") {
+    const mixed = mixColorsOklab(from, to, t);
+    if (mixed !== null) return mixed;
+  }
+  return from;
+}
+function segmentIndex(keys, time) {
+  let lo = 0;
+  let hi = keys.length - 1;
+  let found = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (keys[mid].time <= time) {
+      found = mid;
+      lo = mid + 1;
+    } else hi = mid - 1;
+  }
+  return found;
+}
+function evaluateTrack(track, time, type = "number") {
+  const keyframes = Array.isArray(track) ? track : track?.keyframes;
+  const keys = normalizeKeyframes(keyframes);
+  if (keys.length === 0) return void 0;
+  if (!(time > keys[0].time)) return keys[0].value;
+  const last = keys[keys.length - 1];
+  if (time >= last.time) return last.value;
+  const i = segmentIndex(keys, time);
+  const a = keys[i];
+  const b = keys[i + 1];
+  if (time === a.time) return a.value;
+  const span = b.time - a.time;
+  const u = (time - a.time) / span;
+  if (a.easing === "hold") return a.value;
+  return interpolateAnimationValue(a.value, b.value, evaluateEasing(a.easing, u, span), type);
+}
+function wrapAnimationTime(time, duration, loop = "none") {
+  if (!Number.isFinite(time)) return 0;
+  if (!(duration > 0)) return 0;
+  if (loop === "loop") return (time % duration + duration) % duration;
+  if (loop === "ping-pong") {
+    const period = duration * 2;
+    const m = (time % period + period) % period;
+    return m <= duration ? m : period - m;
+  }
+  return Math.min(duration, Math.max(0, time));
+}
+
+// src/animation/clock.ts
+var pageHidden = () => typeof document !== "undefined" && document.hidden;
+var realClock = {
+  live: true,
+  now: () => typeof performance !== "undefined" ? performance.now() : Date.now(),
+  frame: () => new Promise((resolve) => {
+    if (typeof requestAnimationFrame === "function" && !pageHidden()) {
+      requestAnimationFrame(() => resolve());
+    } else {
+      setTimeout(resolve, 16);
+    }
+  }),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)))
+};
+var settle = () => new Promise((resolve) => setTimeout(resolve, 0));
+var ManualClock = class {
+  live = false;
+  time;
+  frames = [];
+  sleepers = [];
+  seq = 0;
+  constructor(start = 0) {
+    this.time = start;
+  }
+  now() {
+    return this.time;
+  }
+  frame() {
+    return new Promise((resolve) => this.frames.push(resolve));
+  }
+  sleep(ms) {
+    return new Promise(
+      (resolve) => this.sleepers.push({
+        at: this.time + Math.max(0, ms),
+        seq: this.seq++,
+        resolve
+      })
+    );
+  }
+  /** Whether any frames or sleep timers are currently pending. */
+  get pending() {
+    return this.frames.length > 0 || this.sleepers.length > 0;
+  }
+  /** Advances time by `ms`, resolving due sleep timers in order, followed by queued frames. */
+  async advance(ms) {
+    const end = this.time + Math.max(0, ms);
+    await settle();
+    while (true) {
+      let next;
+      for (const s of this.sleepers) {
+        if (s.at <= end && (!next || s.at < next.at || s.at === next.at && s.seq < next.seq)) {
+          next = s;
+        }
+      }
+      if (!next) break;
+      this.sleepers.splice(this.sleepers.indexOf(next), 1);
+      this.time = Math.max(this.time, next.at);
+      next.resolve();
+      await settle();
+    }
+    this.time = end;
+    const dueFrames = this.frames.splice(0, this.frames.length);
+    for (const resolveFrame of dueFrames) {
+      resolveFrame();
+    }
+    await settle();
+  }
+  /** Convenience method to advance by 1 frame at a given fps (default: 60fps = 16.67ms). */
+  async tick(fps = 60) {
+    await this.advance(Math.round(1e3 / fps));
+  }
+};
+
+// src/animation/player.ts
+var AnimationPlayer = class {
+  clock;
+  durationSource;
+  onTime;
+  onEnd;
+  time;
+  playing = false;
+  scrubbing = false;
+  resumeAfterScrub = false;
+  loop;
+  rate;
+  /** Unwrapped time at `anchorAt` (keeps the ping-pong direction across frames). */
+  anchorRaw = 0;
+  anchorAt = 0;
+  generation = 0;
+  cached;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.clock = options.clock ?? realClock;
+    this.durationSource = options.duration ?? 1e3;
+    this.loop = options.loop ?? "none";
+    this.rate = Number.isFinite(options.playbackRate) && options.playbackRate !== 0 ? options.playbackRate : 1;
+    this.onTime = options.onTime;
+    this.onEnd = options.onEnd;
+    this.time = this.clamp(options.time ?? 0);
+    this.cached = this.snapshot();
+  }
+  /** Current timeline length (ms). */
+  get duration() {
+    const d = typeof this.durationSource === "function" ? this.durationSource() : this.durationSource;
+    return Number.isFinite(d) && d > 0 ? d : 0;
+  }
+  get currentTime() {
+    return this.time;
+  }
+  get isPlaying() {
+    return this.playing;
+  }
+  getState() {
+    return this.cached;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Replaces the callbacks (hooks keep them current without recreating the player). */
+  setCallbacks(callbacks) {
+    this.onTime = callbacks.onTime;
+    this.onEnd = callbacks.onEnd;
+  }
+  setDuration(duration) {
+    this.durationSource = duration;
+    this.time = this.clamp(this.time);
+    this.emit(false);
+  }
+  setLoop(loop) {
+    if (loop === this.loop) return;
+    this.reanchor();
+    this.loop = loop;
+    this.emit(false);
+  }
+  setPlaybackRate(rate) {
+    if (!Number.isFinite(rate) || rate === 0 || rate === this.rate) return;
+    this.reanchor();
+    this.rate = rate;
+    this.emit(false);
+  }
+  /** Starts playing from the playhead (from the start again when a one-shot play had ended). */
+  play() {
+    if (this.playing) return;
+    const d = this.duration;
+    if (this.loop === "none" && d > 0) {
+      if (this.rate > 0 && this.time >= d) this.time = 0;
+      if (this.rate < 0 && this.time <= 0) this.time = d;
+    }
+    this.playing = true;
+    this.scrubbing = false;
+    this.anchorRaw = this.time;
+    this.anchorAt = this.clock.now();
+    this.emit(false);
+    this.schedule();
+  }
+  pause() {
+    if (!this.playing) return;
+    this.tick(false);
+    this.playing = false;
+    this.generation++;
+    this.emit(true);
+  }
+  toggle() {
+    if (this.playing) this.pause();
+    else this.play();
+  }
+  /** Pauses and returns to the start. */
+  stop() {
+    this.playing = false;
+    this.generation++;
+    this.seek(0);
+  }
+  /** Moves the playhead (clamped to the timeline); playback continues from there. */
+  seek(time) {
+    if (!Number.isFinite(time)) return;
+    this.time = this.clamp(time);
+    this.anchorRaw = this.time;
+    this.anchorAt = this.clock.now();
+    this.emit(true);
+  }
+  /** Seeks while dragging the playhead: playback pauses until `endScrub`. */
+  scrub(time) {
+    if (!this.scrubbing) {
+      this.resumeAfterScrub = this.playing;
+      if (this.playing) {
+        this.playing = false;
+        this.generation++;
+      }
+      this.scrubbing = true;
+    }
+    this.seek(time);
+  }
+  /** Ends a scrub, resuming playback if it was playing when the scrub began. */
+  endScrub() {
+    if (!this.scrubbing) return;
+    this.scrubbing = false;
+    const resume = this.resumeAfterScrub;
+    this.resumeAfterScrub = false;
+    if (resume) this.play();
+    else this.emit(false);
+  }
+  /** Stops scheduling frames and drops listeners. */
+  destroy() {
+    this.playing = false;
+    this.generation++;
+    this.listeners.clear();
+  }
+  clamp(time) {
+    return Math.min(this.duration, Math.max(0, Number.isFinite(time) ? time : 0));
+  }
+  reanchor() {
+    if (!this.playing) return;
+    this.tick(false);
+    this.anchorRaw = this.rawNow();
+    this.anchorAt = this.clock.now();
+  }
+  rawNow() {
+    return this.anchorRaw + (this.clock.now() - this.anchorAt) * this.rate;
+  }
+  schedule() {
+    const generation = this.generation;
+    this.clock.frame().then(() => {
+      if (generation !== this.generation || !this.playing) return;
+      this.tick(true);
+      if (this.playing) this.schedule();
+    });
+  }
+  /** Advances the playhead to the clock's time; `notify` emits the change. */
+  tick(notify) {
+    if (!this.playing) return;
+    const d = this.duration;
+    const raw = this.rawNow();
+    let ended = false;
+    if (this.loop === "none" || d <= 0) {
+      if (this.rate > 0 && raw >= d) {
+        this.time = d;
+        ended = true;
+      } else if (this.rate < 0 && raw <= 0) {
+        this.time = 0;
+        ended = true;
+      } else this.time = this.clamp(raw);
+    } else {
+      this.time = wrapAnimationTime(raw, d, this.loop);
+    }
+    if (ended) {
+      this.playing = false;
+      this.generation++;
+    }
+    if (notify || ended) this.emit(true);
+    if (ended) this.onEnd?.();
+  }
+  snapshot() {
+    return {
+      time: this.time,
+      playing: this.playing,
+      scrubbing: this.scrubbing,
+      loop: this.loop,
+      playbackRate: this.rate,
+      duration: this.duration
+    };
+  }
+  emit(timeChanged) {
+    const next = this.snapshot();
+    const prev = this.cached;
+    if (prev.time === next.time && prev.playing === next.playing && prev.scrubbing === next.scrubbing && prev.loop === next.loop && prev.playbackRate === next.playbackRate && prev.duration === next.duration) {
+      return;
+    }
+    this.cached = next;
+    if (timeChanged && prev.time !== next.time) this.onTime?.(next.time);
+    for (const listener of this.listeners) listener(next);
+  }
+};
+function createAnimationPlayer(options) {
+  return new AnimationPlayer(options);
+}
+
+export {
+  ANIMATION_EASING_PRESETS,
+  ANIMATION_EASING_LABELS,
+  CUBIC_BEZIER_PRESETS,
+  cubicBezierAt,
+  springAt,
+  resolveEasing,
+  evaluateEasing,
+  easingFromInfluence,
+  parseCssEasing,
+  isAnimationEasing,
+  easingToCss,
+  easingLabel,
+  rgbToOklab,
+  oklabToRgb,
+  parseOklab,
+  formatOklab,
+  mixColorsOklab,
+  ANIMATION_TIME_EPSILON,
+  isAnimationKeyframe,
+  normalizeKeyframes,
+  interpolateAnimationValue,
+  evaluateTrack,
+  wrapAnimationTime,
+  pageHidden,
+  realClock,
+  ManualClock,
+  AnimationPlayer,
+  createAnimationPlayer
+};
+//# sourceMappingURL=chunk-PWJARCI4.js.map