@exponential_app/eui 0.3.0 → 0.4.0

package/dist/chunks/index-t2mwfbb6.js

@@ -0,0 +1,1515 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __chunkGraphs;
+var __chunkSeen;
+var __chunkNonce;
+var __preload = (id, seenOnly) => {
+  for (var [base, graph, ids] of __chunkGraphs || [])
+    for (var stack = [id], g = globalThis, d = g.document, head, j, node, k, link;j = stack.pop(); )
+      if (!__chunkSeen[j] && (node = graph[j])) {
+        __chunkSeen[j] = 1;
+        for (k = 1;k < node.length; k++)
+          stack.push(ids[node[k]]);
+        if (!seenOnly && j !== id && (head = d && d.head)) {
+          if (__chunkNonce === undefined)
+            __chunkNonce = (k = d.querySelector("meta[property=csp-nonce]")) && (k.nonce || k.getAttribute("nonce")) || "";
+          link = d.createElement("link");
+          link.rel = "modulepreload";
+          link.crossOrigin = "";
+          if (__chunkNonce)
+            link.nonce = __chunkNonce;
+          link.href = new g.URL(node[0], base);
+          head.appendChild(link);
+        }
+      }
+};
+var __chunks = (base, ids, nodes, entry) => {
+  for (var graph = {}, i = 0;i < ids.length; i++)
+    graph[ids[i]] = nodes[i];
+  (__chunkGraphs ||= []).push([base, graph, ids]);
+  __chunkSeen ||= {};
+  __preload(ids[entry], 1);
+};
+
+// packages/exponential-ui/src/web/urls.ts
+import { DEFAULT_MEDIA_SCHEMES, decideUrl, isPrivateHost, mediaRequest, safeHref } from "@exponential_app/eui";
+var documentBase = () => typeof document !== `undefined` && document.baseURI ? document.baseURI : undefined;
+function ownPrivateHosts2() {
+  try {
+    const base = documentBase();
+    if (!base)
+      return [];
+    const host = new URL(base).hostname.toLowerCase();
+    return isPrivateHost(host) ? [host] : [];
+  } catch {
+    return [];
+  }
+}
+function withOwnOrigin(allow) {
+  const own = ownPrivateHosts2();
+  if (!own.length)
+    return allow;
+  return [...allow ?? [], ...own.filter((h) => !(allow ?? []).includes(h))];
+}
+function urlPolicyOf2(host) {
+  const urls = host.urls ?? {};
+  const withBase = urls.baseUrl ? urls : { ...urls, baseUrl: host.media?.baseUrl ?? documentBase() };
+  return { ...withBase, allowPrivate: withOwnOrigin(withBase.allowPrivate) };
+}
+function linkHref2(host, href) {
+  return safeHref(urlPolicyOf2(host), href);
+}
+function mediaRequestOf2(host, src) {
+  if (typeof src !== `string` || !src)
+    return null;
+  const rewritten = host.resolveUrl ? host.resolveUrl(src) : src;
+  const req = host.mediaRequest ? host.mediaRequest(rewritten) : mediaRequest(rewritten, { baseUrl: documentBase(), ...host.media, allowPrivate: withOwnOrigin(host.media?.allowPrivate) });
+  if (!req)
+    return null;
+  return mediaUrlAllowed2(host, req.url) ? req : null;
+}
+function mediaUrlAllowed2(host, url) {
+  return decideUrl({ schemes: host.media?.schemes ?? DEFAULT_MEDIA_SCHEMES, hosts: host.media?.hosts, allowPrivate: withOwnOrigin(host.media?.allowPrivate) }, url).allowed;
+}
+function openAllowed2(host, url) {
+  const href = linkHref2(host, url);
+  if (!href)
+    return;
+  if (host.openUrl)
+    host.openUrl(href);
+  else if (typeof window !== `undefined`)
+    window.open(href, `_blank`, `noopener,noreferrer`);
+}
+
+// packages/exponential-ui/src/web/media.ts
+import { MEDIA_LIMITS, mediaImageWithinLimits } from "@exponential_app/eui";
+var MEDIA_CACHE_IDLE_MAX2 = 64;
+var blobs = new Map;
+function mediaCacheKey2(url, headers) {
+  return `${url}
+${JSON.stringify(headers)}`;
+}
+function touch(k, e) {
+  blobs.delete(k);
+  blobs.set(k, e);
+}
+function acquireMedia2(k, load) {
+  let e = blobs.get(k);
+  if (!e) {
+    const entry = { refs: 0, promise: Promise.resolve(``) };
+    entry.promise = load().then((url) => {
+      entry.url = url;
+      if (blobs.get(k) !== entry)
+        URL.revokeObjectURL(url);
+      return url;
+    });
+    entry.promise.catch(() => {
+      if (blobs.get(k) === entry)
+        blobs.delete(k);
+    });
+    e = entry;
+  }
+  e.refs += 1;
+  touch(k, e);
+  return e;
+}
+function releaseMedia2(k, e) {
+  e.refs -= 1;
+  if (e.refs > 0 || blobs.get(k) !== e)
+    return;
+  touch(k, e);
+  let idle = 0;
+  for (const v of blobs.values())
+    if (v.refs === 0)
+      idle += 1;
+  for (const [ok, v] of blobs) {
+    if (idle <= MEDIA_CACHE_IDLE_MAX2)
+      break;
+    if (v.refs > 0)
+      continue;
+    blobs.delete(ok);
+    if (v.url)
+      URL.revokeObjectURL(v.url);
+    idle -= 1;
+  }
+}
+function mediaCacheStats2() {
+  let inUse = 0;
+  for (const v of blobs.values())
+    if (v.refs > 0)
+      inUse += 1;
+  return { entries: blobs.size, inUse };
+}
+function clearMediaCache2() {
+  for (const [k, v] of blobs) {
+    if (v.refs > 0)
+      continue;
+    blobs.delete(k);
+    if (v.url)
+      URL.revokeObjectURL(v.url);
+  }
+}
+function openMediaSource2(host, src, kind = `image`) {
+  const req = mediaRequestOf2(host, src);
+  const headers = req?.headers ?? {};
+  const fetched = req !== null && Object.keys(headers).length > 0;
+  const k = fetched ? `${kind}
+${mediaCacheKey2(req.url, headers)}` : ``;
+  return {
+    fetched,
+    key: k,
+    direct: req ? req.url : undefined,
+    denied: Boolean(src) && req === null,
+    open: () => {
+      if (!req || !fetched)
+        return { promise: Promise.resolve(req ? req.url : ``), release: () => {} };
+      const hosted = kind === `stream` && host.mediaStreamUrl !== undefined;
+      const allowed = (url) => mediaUrlAllowed2(host, url);
+      const entry = hosted ? streamEntry2(host, req) : acquireMedia2(k, () => (kind === `stream` ? fetchStream2(req.url, headers, MEDIA_LIMITS, allowed) : fetchLimited2(req.url, headers, MEDIA_LIMITS, true, allowed)).then((b) => URL.createObjectURL(b)));
+      return { promise: entry.promise, release: hosted ? () => {} : () => releaseMedia2(k, entry) };
+    }
+  };
+}
+function streamEntry2(host, req) {
+  const promise = Promise.resolve(host.mediaStreamUrl(req)).then((url) => {
+    if (typeof url !== `string` || !mediaUrlAllowed2(host, url))
+      throw new Error(`stream url denied by the media policy`);
+    return url;
+  });
+  return { promise, refs: 0 };
+}
+function fetchStream2(url, headers, limits = MEDIA_LIMITS, allowed = defaultAllowed) {
+  return fetchLimited2(url, headers, { ...limits, maxPixels: Infinity }, false, allowed);
+}
+function defaultAllowed(url) {
+  return mediaUrlAllowed2({}, url);
+}
+async function fetchLimited2(url, headers, limits = MEDIA_LIMITS, image = true, allowed = defaultAllowed) {
+  const abort = new AbortController;
+  const timer = setTimeout(() => abort.abort(new Error(`media timed out after ${limits.timeoutMs} ms`)), limits.timeoutMs);
+  const over = () => new Error(`media is over ${limits.maxBytes} bytes`);
+  try {
+    const r = await fetch(url, { headers, signal: abort.signal });
+    if (r.redirected && !allowed(r.url)) {
+      abort.abort();
+      throw new Error(`media redirect denied by the media policy`);
+    }
+    if (!r.ok)
+      throw new Error(`HTTP ${r.status}`);
+    if (Number(r.headers.get(`content-length`) ?? NaN) > limits.maxBytes)
+      throw over();
+    const chunks = [];
+    let total = 0;
+    if (r.body) {
+      const reader = r.body.getReader();
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        total += value.byteLength;
+        if (total > limits.maxBytes) {
+          abort.abort();
+          throw over();
+        }
+        chunks.push(value);
+      }
+    } else {
+      const all = new Uint8Array(await r.arrayBuffer());
+      if (all.byteLength > limits.maxBytes)
+        throw over();
+      chunks.push(all);
+    }
+    if (image) {
+      const refused = mediaImageWithinLimits(chunks.length === 1 ? chunks[0] : concat(chunks), limits);
+      if (refused)
+        throw new Error(refused);
+    }
+    return new Blob(chunks, { type: r.headers.get(`content-type`) ?? `` });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function concat(chunks) {
+  const out = new Uint8Array(chunks.reduce((n, c) => n + c.byteLength, 0));
+  let at = 0;
+  for (const c of chunks) {
+    out.set(c, at);
+    at += c.byteLength;
+  }
+  return out;
+}
+
+// packages/exponential-ui/src/web/primitives/measure.ts
+var near = (a, b) => Math.abs(a - b) < 1;
+var unit = (v) => Math.round(v * 64) / 64;
+var sized = (width, height) => ({ width: unit(width), height: unit(height) });
+function layoutSize2(el, entry) {
+  const r = el.getBoundingClientRect();
+  const ow = el.offsetWidth;
+  const oh = el.offsetHeight;
+  if (ow === 0 && oh === 0)
+    return { width: r.width, height: r.height };
+  if (near(r.width, ow) && near(r.height, oh))
+    return { width: r.width, height: r.height };
+  const box = entry?.borderBoxSize?.[0];
+  if (box) {
+    if (near(box.inlineSize, ow) && near(box.blockSize, oh))
+      return sized(box.inlineSize, box.blockSize);
+    if (near(box.blockSize, ow) && near(box.inlineSize, oh))
+      return sized(box.blockSize, box.inlineSize);
+  }
+  const zoom = el.currentCSSZoom;
+  if (zoom && zoom !== 1 && near(r.width / zoom, ow) && near(r.height / zoom, oh))
+    return sized(r.width / zoom, r.height / zoom);
+  return { width: ow, height: oh };
+}
+function visualScale2(visual, layout) {
+  return layout > 0 && !near(visual, layout) ? visual / layout : 1;
+}
+function elementScale2(el, rect = el.getBoundingClientRect()) {
+  return { x: visualScale2(rect.width, el.offsetWidth), y: visualScale2(rect.height, el.offsetHeight) };
+}
+
+// packages/exponential-ui/src/web/primitives/voice-wave.ts
+var VOICE_WAVE_SIZES2 = [`sm`, `md`, `lg`, `xl`];
+var VOICE_WAVE_SIZE_PX2 = { sm: 32, md: 56, lg: 160, xl: 200 };
+function voiceWaveAnimates2(activity) {
+  return activity === `listening` || activity === `thinking` || activity === `speaking`;
+}
+function voiceWaveQuiet2(activity) {
+  return !voiceWaveAnimates2(activity);
+}
+var NAMED = [`idle`, `listening`, `thinking`, `speaking`, `muted`];
+function voiceWaveName2(label, activity) {
+  return label ? `${label}, ${NAMED.includes(activity) ? activity : `idle`}` : undefined;
+}
+function voiceWaveClock2(onFrame) {
+  if (typeof requestAnimationFrame !== `function`)
+    return () => {};
+  let start = null;
+  let id = 0;
+  const tick = (now) => {
+    if (start === null)
+      start = now;
+    else
+      onFrame((now - start) / 1000);
+    id = requestAnimationFrame(tick);
+  };
+  id = requestAnimationFrame(tick);
+  return () => cancelAnimationFrame(id);
+}
+function voiceWaveFitChild2(el, scaleOf) {
+  const apply = (width, height) => {
+    const s = scaleOf({ width, height });
+    el.style.transform = s === 1 ? `` : `scale(${s})`;
+  };
+  if (typeof ResizeObserver !== `function`) {
+    apply(el.offsetWidth, el.offsetHeight);
+    return () => {};
+  }
+  const ro = new ResizeObserver((entries) => {
+    const e = entries[entries.length - 1];
+    const b = e.borderBoxSize?.[0];
+    if (b)
+      apply(b.inlineSize, b.blockSize);
+    else
+      apply(el.offsetWidth, el.offsetHeight);
+  });
+  ro.observe(el, { box: `border-box` });
+  return () => ro.disconnect();
+}
+var VOICE_WAVE_CLASSES2 = {
+  root: `relative inline-flex shrink-0 items-center justify-center`,
+  quiet: `opacity-35`,
+  size: { sm: `size-8`, md: `size-14`, lg: `size-40`, xl: `size-50` },
+  svg: `pointer-events-none absolute inset-0 size-full overflow-visible`,
+  ring: { outer: `text-blue-500`, mid: `text-primary`, inner: `text-primary` },
+  ringQuiet: `text-muted-foreground`,
+  child: `relative flex shrink-0 items-center justify-center text-foreground`,
+  childHidden: `invisible pointer-events-none`,
+  childMuted: `text-muted-foreground`
+};
+
+// packages/exponential-ui/src/web/primitives/motion.ts
+import { MEDIA_LIMITS as MEDIA_LIMITS2, parseColor, resolveToken } from "@exponential_app/eui";
+
+// packages/exponential-ui/src/web/primitives/motion-paint.ts
+var MOTION_PACKED_VERSION = 1;
+var BLENDS = [
+  `source-over`,
+  `multiply`,
+  `screen`,
+  `overlay`,
+  `darken`,
+  `lighten`,
+  `color-dodge`,
+  `color-burn`,
+  `hard-light`,
+  `soft-light`,
+  `difference`,
+  `exclusion`,
+  `hue`,
+  `saturation`,
+  `color`,
+  `luminosity`,
+  `destination-in`,
+  `destination-out`,
+  `destination-in`,
+  `destination-out`,
+  `xor`
+];
+var LUMA_IN = 18;
+var LUMA_OUT = 19;
+var CAPS = [`butt`, `round`, `square`];
+var JOINS = [`miter`, `round`, `bevel`];
+function motionFitMatrix2(cw, ch, bw, bh, fit = `contain`) {
+  if (!(cw > 0) || !(ch > 0))
+    return [1, 0, 0, 1, 0, 0];
+  if (fit === `fill`)
+    return [bw / cw, 0, 0, bh / ch, 0, 0];
+  const s = fit === `cover` ? Math.max(bw / cw, bh / ch) : Math.min(bw / cw, bh / ch);
+  return [s, 0, 0, s, (bw - cw * s) / 2, (bh - ch * s) / 2];
+}
+function motionConcat2(a, b) {
+  return [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
+}
+function motionFrameSize2(packed) {
+  return { width: Number(packed[1]) || 0, height: Number(packed[2]) || 0 };
+}
+
+class MotionCanvasPool2 {
+  make;
+  free = [];
+  constructor(make = defaultCanvas) {
+    this.make = make;
+  }
+  take(w, h) {
+    let c = this.free.pop() ?? this.make(w, h);
+    if (!c)
+      return null;
+    if (c.width !== w || c.height !== h) {
+      c.width = w;
+      c.height = h;
+    }
+    const ctx = c.getContext(`2d`);
+    if (!ctx)
+      return null;
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.globalAlpha = 1;
+    ctx.globalCompositeOperation = `source-over`;
+    ctx.clearRect(0, 0, w, h);
+    return { canvas: c, ctx };
+  }
+  give(c) {
+    if (this.free.length < 8)
+      this.free.push(c);
+  }
+}
+function defaultCanvas(w, h) {
+  if (typeof OffscreenCanvas === `function`)
+    return new OffscreenCanvas(w, h);
+  if (typeof document === `undefined`)
+    return null;
+  const c = document.createElement(`canvas`);
+  c.width = w;
+  c.height = h;
+  return c;
+}
+function paintMotionFrame2(ctx, width, height, packed, base, images = [], pool = new MotionCanvasPool2) {
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  ctx.globalAlpha = 1;
+  ctx.globalCompositeOperation = `source-over`;
+  ctx.clearRect(0, 0, width, height);
+  if (packed[0] !== MOTION_PACKED_VERSION)
+    return false;
+  const scale = Math.sqrt(Math.abs(base[0] * base[3] - base[1] * base[2]));
+  let i = 3;
+  const n = packed.length;
+  const f = () => Number(packed[i++]);
+  const mat = () => [f(), f(), f(), f(), f(), f()];
+  const readPath = () => {
+    const count = f();
+    const p = typeof Path2D === `function` ? new Path2D : null;
+    let any = false;
+    for (let k = 0;k < count; k++) {
+      const v = f();
+      if (v === 0) {
+        const x = f(), y = f();
+        p?.moveTo(x, y);
+        any = true;
+      } else if (v === 1) {
+        const x = f(), y = f();
+        p?.lineTo(x, y);
+        any = true;
+      } else if (v === 2) {
+        const x1 = f(), y1 = f(), x2 = f(), y2 = f(), x = f(), y = f();
+        p?.bezierCurveTo(x1, y1, x2, y2, x, y);
+        any = true;
+      } else
+        p?.closePath();
+    }
+    return any ? p : null;
+  };
+  const readStops = () => {
+    const count = f();
+    const out = [];
+    for (let k = 0;k < count; k++)
+      out.push({ offset: f(), color: [f(), f(), f(), f()] });
+    return out;
+  };
+  const readBrush = () => {
+    const kind = f();
+    if (kind === 1)
+      return { kind: 1, x0: f(), y0: f(), x1: f(), y1: f(), stops: readStops() };
+    if (kind === 2)
+      return { kind: 2, cx: f(), cy: f(), fx: f(), fy: f(), r: f(), stops: readStops() };
+    return { kind: 0, color: [f(), f(), f(), f()] };
+  };
+  const readFilters = () => {
+    const count = f();
+    const out = [];
+    for (let k = 0;k < count; k++) {
+      const kind = f();
+      if (kind === 0)
+        out.push({ kind: 0, sx: f(), sy: f() });
+      else if (kind === 1) {
+        const m = [];
+        for (let j = 0;j < 20; j++)
+          m.push(f());
+        out.push({ kind: 1, m });
+      } else if (kind === 2)
+        out.push({ kind: 2, amount: f(), stops: readStops() });
+      else
+        out.push({ kind: 3, color: [f(), f(), f(), f()], dx: f(), dy: f(), sigma: f() });
+    }
+    return out;
+  };
+  const clips = [];
+  const stack = [];
+  const top = () => {
+    for (let k = stack.length - 1;k >= 0; k--) {
+      const fr = stack[k];
+      if (fr.kind === `layer`)
+        return fr.ctx;
+    }
+    return ctx;
+  };
+  const applyClips = (c, list) => {
+    for (const clip of list) {
+      if (!clip.path)
+        return false;
+      const m = motionConcat2(base, clip.m);
+      c.setTransform(m[0], m[1], m[2], m[3], m[4], m[5]);
+      c.clip(clip.path, `nonzero`);
+    }
+    return true;
+  };
+  const setStyle = (c, brush, stroke) => {
+    let style;
+    if (brush.kind === 0)
+      style = css(brush.color);
+    else {
+      const g = brush.kind === 1 ? c.createLinearGradient(brush.x0, brush.y0, brush.x1, brush.y1) : c.createRadialGradient(brush.fx, brush.fy, 0, brush.cx, brush.cy, Math.max(0, brush.r));
+      let last = 0;
+      for (const s of brush.stops) {
+        last = Math.max(last, clamp01(s.offset));
+        g.addColorStop(last, css(s.color));
+      }
+      style = g;
+    }
+    if (stroke)
+      c.strokeStyle = style;
+    else
+      c.fillStyle = style;
+  };
+  while (i < n) {
+    const op = f();
+    if (op === 1) {
+      const blend = f();
+      const alpha = f();
+      const t = mat();
+      const path = readPath();
+      const filters = readFilters();
+      const group = pool.take(width, height);
+      const clip = { m: t, path };
+      if (!group)
+        return false;
+      stack.push({ kind: `layer`, clips: clips.length, canvas: group.canvas, ctx: group.ctx, blend, alpha, filters, clip });
+      clips.push(clip);
+    } else if (op === 2) {
+      const t = mat();
+      const path = readPath();
+      stack.push({ kind: `clip`, clips: clips.length });
+      clips.push({ m: t, path });
+    } else if (op === 3) {
+      const fr = stack.pop();
+      if (!fr)
+        continue;
+      clips.length = fr.clips;
+      if (fr.kind === `clip`)
+        continue;
+      const dst = top();
+      const needsPixels = fr.blend === LUMA_IN || fr.blend === LUMA_OUT || fr.filters.length > 0;
+      if (needsPixels) {
+        const img = fr.ctx.getImageData(0, 0, width, height);
+        const px = premultiply(img.data);
+        if (fr.blend === LUMA_IN || fr.blend === LUMA_OUT)
+          lumaMask(px);
+        applyFilters(px, width, height, fr.filters, base, scale);
+        unpremultiply(px, img.data);
+        fr.ctx.putImageData(img, 0, 0);
+      }
+      dst.save();
+      if (applyClips(dst, [...clips, fr.clip])) {
+        dst.setTransform(1, 0, 0, 1, 0, 0);
+        dst.globalAlpha = clamp01(fr.alpha);
+        dst.globalCompositeOperation = BLENDS[fr.blend] ?? `source-over`;
+        dst.drawImage(fr.canvas, 0, 0);
+      }
+      dst.restore();
+      pool.give(fr.canvas);
+    } else if (op === 4 || op === 5) {
+      const t = mat();
+      let rule = `nonzero`;
+      let width_ = 0, cap = 0, join = 0, miter = 4, dashOffset = 0;
+      let dashes = [];
+      if (op === 4)
+        rule = f() === 1 ? `evenodd` : `nonzero`;
+      else {
+        width_ = f();
+        cap = f();
+        join = f();
+        miter = f();
+        dashOffset = f();
+        const dn = f();
+        for (let k = 0;k < dn; k++)
+          dashes.push(f());
+      }
+      const brush = readBrush();
+      const path = readPath();
+      if (!path)
+        continue;
+      const c = top();
+      c.save();
+      if (applyClips(c, clips)) {
+        const m = motionConcat2(base, t);
+        c.setTransform(m[0], m[1], m[2], m[3], m[4], m[5]);
+        setStyle(c, brush, op === 5);
+        if (op === 4)
+          c.fill(path, rule);
+        else if (width_ > 0) {
+          c.lineWidth = width_;
+          c.lineCap = CAPS[cap] ?? `butt`;
+          c.lineJoin = JOINS[join] ?? `miter`;
+          c.miterLimit = miter > 0 ? miter : 4;
+          if (dashes.length && dashes.every((d) => d >= 0 && Number.isFinite(d)) && dashes.some((d) => d > 0)) {
+            c.setLineDash(dashes);
+            c.lineDashOffset = dashOffset;
+          }
+          c.stroke(path);
+        }
+      }
+      c.restore();
+    } else if (op === 6) {
+      const t = mat();
+      const asset = f();
+      const alpha = f();
+      const w = f();
+      const h = f();
+      const img = images[asset];
+      if (!img || !img.width || !img.height)
+        continue;
+      const c = top();
+      c.save();
+      if (applyClips(c, clips)) {
+        const m = motionConcat2(base, t);
+        c.setTransform(m[0], m[1], m[2], m[3], m[4], m[5]);
+        c.globalAlpha = clamp01(alpha);
+        c.imageSmoothingQuality = `low`;
+        c.drawImage(img, 0, 0, w > 0 ? w : img.width, h > 0 ? h : img.height);
+      }
+      c.restore();
+    } else
+      return false;
+  }
+  return true;
+}
+function clamp01(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function css(c) {
+  return `rgb(${clamp01(c[0]) * 255} ${clamp01(c[1]) * 255} ${clamp01(c[2]) * 255} / ${clamp01(c[3])})`;
+}
+function premultiply(src) {
+  const out = new Uint8Array(src.length);
+  for (let k = 0;k < src.length; k += 4) {
+    const a = src[k + 3];
+    out[k + 3] = a;
+    if (a === 255) {
+      out[k] = src[k];
+      out[k + 1] = src[k + 1];
+      out[k + 2] = src[k + 2];
+    } else if (a > 0) {
+      out[k] = Math.round(src[k] * a / 255);
+      out[k + 1] = Math.round(src[k + 1] * a / 255);
+      out[k + 2] = Math.round(src[k + 2] * a / 255);
+    }
+  }
+  return out;
+}
+function unpremultiply(src, out) {
+  for (let k = 0;k < src.length; k += 4) {
+    const a = src[k + 3];
+    out[k + 3] = a;
+    if (a === 0) {
+      out[k] = out[k + 1] = out[k + 2] = 0;
+    } else {
+      out[k] = Math.round(src[k] * 255 / a);
+      out[k + 1] = Math.round(src[k + 1] * 255 / a);
+      out[k + 2] = Math.round(src[k + 2] * 255 / a);
+    }
+  }
+}
+function lumaMask(p) {
+  for (let k = 0;k < p.length; k += 4) {
+    const l = Math.max(0, Math.min(255, Math.round(0.2125 * p[k] + 0.7154 * p[k + 1] + 0.0721 * p[k + 2])));
+    p[k] = p[k + 1] = p[k + 2] = p[k + 3] = l;
+  }
+}
+function applyFilters(p, w, h, filters, base, scale) {
+  for (const fl of filters) {
+    if (fl.kind === 0)
+      blur(p, w, h, 4, fl.sx * scale, fl.sy * scale);
+    else if (fl.kind === 1)
+      colorMatrix(p, fl.m);
+    else if (fl.kind === 2)
+      gradientMap(p, fl.stops, fl.amount);
+    else {
+      const ddx = base[0] * fl.dx + base[2] * fl.dy;
+      const ddy = base[1] * fl.dx + base[3] * fl.dy;
+      dropShadow(p, w, h, fl.color, ddx, ddy, fl.sigma * scale);
+    }
+  }
+}
+var BOX_SIGMA = 2;
+var div255 = (x) => {
+  const v = x + 128;
+  return v + (v >> 8) >> 8;
+};
+function boxSize(sigma) {
+  return Math.max(0, Math.floor(sigma * 3 * Math.sqrt(2 * Math.PI) / 4 + 0.5));
+}
+function passes(sigma) {
+  if (sigma < BOX_SIGMA) {
+    const r = Math.ceil(3 * sigma);
+    const ws = [];
+    for (let k = 0;k <= 2 * r; k++) {
+      const x = k - r;
+      ws.push(Math.exp(-x * x / (2 * sigma * sigma)));
+    }
+    const sum = ws.reduce((a, b) => a + b, 0);
+    const kernel = new Uint32Array(ws.map((v) => Math.round(v / sum * 65536)));
+    const total = kernel.reduce((a, b) => a + b, 0);
+    kernel[r] = Math.max(0, kernel[r] + 65536 - total);
+    return [{ kernel }];
+  }
+  const d = boxSize(sigma);
+  if (d <= 1)
+    return [];
+  const r = Math.floor(d / 2);
+  return d % 2 === 1 ? [{ box: [r, r] }, { box: [r, r] }, { box: [r, r] }] : [{ box: [r, r - 1] }, { box: [r - 1, r] }, { box: [r, r] }];
+}
+function blur(buf, w, h, ch, sx, sy) {
+  if (!w || !h)
+    return;
+  if (sx > 0 && Number.isFinite(sx))
+    for (const p of passes(sx))
+      runPass(buf, w, h, ch, p, true);
+  if (sy > 0 && Number.isFinite(sy))
+    for (const p of passes(sy))
+      runPass(buf, w, h, ch, p, false);
+}
+function runPass(buf, w, h, ch, pass, horizontal) {
+  const len = horizontal ? w : h;
+  const lines = horizontal ? h : w;
+  const step = horizontal ? ch : w * ch;
+  const lineStep = horizontal ? w * ch : ch;
+  const tmp = new Uint32Array(len);
+  for (let line = 0;line < lines; line++) {
+    for (let c = 0;c < ch; c++) {
+      const o = line * lineStep + c;
+      for (let x = 0;x < len; x++)
+        tmp[x] = buf[o + x * step];
+      if (`box` in pass) {
+        const [l, r] = pass.box;
+        const d = l + r + 1;
+        const half = d >> 1;
+        let sum = 0;
+        for (let k = 0;k <= Math.min(r, len - 1); k++)
+          sum += tmp[k];
+        for (let x = 0;x < len; x++) {
+          buf[o + x * step] = Math.floor((sum + half) / d);
+          const add = x + r + 1;
+          if (add < len)
+            sum += tmp[add];
+          if (x >= l)
+            sum -= tmp[x - l];
+        }
+      } else {
+        const k = pass.kernel;
+        const r = k.length >> 1;
+        for (let x = 0;x < len; x++) {
+          const lo = Math.max(0, x - r);
+          const hi = Math.min(len - 1, x + r);
+          let acc = 0;
+          for (let s = lo;s <= hi; s++)
+            acc += k[s + r - x] * tmp[s];
+          buf[o + x * step] = Math.min(255, Math.floor((acc + 32768) / 65536));
+        }
+      }
+    }
+  }
+}
+var IDENTITY_MATRIX = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
+function colorMatrix(p, m) {
+  if (m.every((v, k) => Math.fround(v) === Math.fround(IDENTITY_MATRIX[k])))
+    return;
+  const clearAlpha = Math.max(0, Math.min(255, Math.round(m[19] * 255)));
+  for (let k = 0;k < p.length; k += 4) {
+    const a = p[k + 3];
+    if (a === 0 && clearAlpha === 0)
+      continue;
+    const [r, g, b, af] = a === 0 ? [0, 0, 0, 0] : [p[k] / a, p[k + 1] / a, p[k + 2] / a, a / 255];
+    const row = (j) => clamp01(m[j] * r + m[j + 1] * g + m[j + 2] * b + m[j + 3] * af + m[j + 4]);
+    const a8 = Math.round(row(15) * 255);
+    p[k] = Math.min(a8, Math.round(row(0) * a8));
+    p[k + 1] = Math.min(a8, Math.round(row(5) * a8));
+    p[k + 2] = Math.min(a8, Math.round(row(10) * a8));
+    p[k + 3] = a8;
+  }
+}
+function gradientMap(p, stops, amountRaw) {
+  const amount = clamp01(amountRaw);
+  if (amount <= 0 || !stops.length)
+    return;
+  const sorted = [...stops].sort((a, b) => a.offset - b.offset);
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  const lut = [];
+  for (let k = 0;k < 256; k++) {
+    const t = k / 255;
+    let c = last.color;
+    if (t <= first.offset)
+      c = first.color;
+    else if (t < last.offset) {
+      for (let j = 0;j + 1 < sorted.length; j++) {
+        const a = sorted[j], b = sorted[j + 1];
+        if (t <= b.offset) {
+          const span = b.offset - a.offset;
+          const fr = span > 0 ? (t - a.offset) / span : 1;
+          c = a.color.map((v, q) => v + (b.color[q] - v) * fr);
+          break;
+        }
+      }
+    }
+    lut.push([...c]);
+  }
+  const mix = (o, nv) => clamp01(o + (clamp01(nv) - o) * amount);
+  for (let k = 0;k < p.length; k += 4) {
+    const a = p[k + 3];
+    if (a === 0)
+      continue;
+    const r = p[k] / a, g = p[k + 1] / a, b = p[k + 2] / a;
+    const l = clamp01(0.2126 * r + 0.7152 * g + 0.0722 * b);
+    const c = lut[Math.round(l * 255)];
+    const a8 = Math.round(clamp01(a / 255 * (1 + (clamp01(c[3]) - 1) * amount)) * 255);
+    p[k] = Math.min(a8, Math.round(mix(r, c[0]) * a8));
+    p[k + 1] = Math.min(a8, Math.round(mix(g, c[1]) * a8));
+    p[k + 2] = Math.min(a8, Math.round(mix(b, c[2]) * a8));
+    p[k + 3] = a8;
+  }
+}
+function dropShadow(p, w, h, color, dxRaw, dyRaw, sigma) {
+  const ok = Number.isFinite(dxRaw) && Number.isFinite(dyRaw);
+  const dx = ok ? dxRaw : 0;
+  const dy = ok ? dyRaw : 0;
+  const ix = Math.floor(dx), iy = Math.floor(dy);
+  const wx1 = Math.round((dx - ix) * 256), wy1 = Math.round((dy - iy) * 256);
+  const wx0 = 256 - wx1, wy0 = 256 - wy1;
+  const at = (x, y) => x < 0 || y < 0 || x >= w || y >= h ? 0 : p[(y * w + x) * 4 + 3];
+  const shifted = new Uint8Array(w * h);
+  for (let y = 0;y < h; y++) {
+    for (let x = 0;x < w; x++) {
+      const sx = x - ix, sy = y - iy;
+      const v = (at(sx, sy) * wx0 + at(sx - 1, sy) * wx1) * wy0 + (at(sx, sy - 1) * wx0 + at(sx - 1, sy - 1) * wx1) * wy1;
+      shifted[y * w + x] = Math.min(255, Math.floor((v + 32768) / 65536));
+    }
+  }
+  blur(shifted, w, h, 1, sigma, sigma);
+  const ca = clamp01(color[3]);
+  const rgb = [clamp01(color[0]), clamp01(color[1]), clamp01(color[2])];
+  for (let k = 0;k < w * h; k++) {
+    const o = k * 4;
+    const sa = p[o + 3];
+    const a = shifted[k];
+    let sr = 0, sg = 0, sb = 0, s8 = 0;
+    if (a) {
+      s8 = Math.min(255, Math.round(a * ca));
+      sr = Math.round(rgb[0] * s8);
+      sg = Math.round(rgb[1] * s8);
+      sb = Math.round(rgb[2] * s8);
+    }
+    const inv = 255 - sa;
+    p[o] = Math.min(255, p[o] + div255(sr * inv));
+    p[o + 1] = Math.min(255, p[o + 1] + div255(sg * inv));
+    p[o + 2] = Math.min(255, p[o + 2] + div255(sb * inv));
+    p[o + 3] = Math.min(255, sa + div255(s8 * inv));
+  }
+}
+
+// packages/exponential-ui/src/web/primitives/motion.ts
+var MOTION_MAX_PLAYING2 = 8;
+var MOTION_MAX_FPS2 = 60;
+var DIALECT_KEYS = [`size`, `fps`, `duration`, `start`, `time`, `name`, `layers`, `assets`, `markers`];
+var PLAYBACK_KEYS = [`autoplay`, `loop`, `plays`, `direction`, `speed`, `segment`, `marker`, `poster`];
+var isObj = (v) => typeof v === `object` && v !== null && !Array.isArray(v);
+function motionDeclaredSize2(props) {
+  if (Array.isArray(props.layers)) {
+    const s = props.size;
+    if (Array.isArray(s) && typeof s[0] === `number` && typeof s[1] === `number` && s[0] > 0 && s[1] > 0)
+      return [s[0], s[1]];
+    return null;
+  }
+  if (isObj(props.lottie)) {
+    const { w, h } = props.lottie;
+    if (typeof w === `number` && typeof h === `number` && w > 0 && h > 0)
+      return [w, h];
+  }
+  return null;
+}
+function motionBoxStyle2(size, nodeStyle) {
+  const style = isObj(nodeStyle) ? nodeStyle : {};
+  const hasW = style.width !== undefined;
+  const hasH = style.height !== undefined;
+  const out = {};
+  if (!size)
+    return out;
+  if (!hasW && !hasH) {
+    out.width = `${size[0]}px`;
+    out.maxWidth = `100%`;
+  }
+  if (!(hasW && hasH))
+    out.aspectRatio = `${size[0]} / ${size[1]}`;
+  return out;
+}
+function motionFit2(value) {
+  return value === `cover` || value === `fill` ? value : `contain`;
+}
+function motionA11y2(label, pressable = false) {
+  const named = typeof label === `string` && label;
+  if (pressable)
+    return named ? { role: `button`, tabIndex: 0, "aria-label": label } : { role: `button`, tabIndex: 0 };
+  return named ? { role: `img`, "aria-label": label } : { "aria-hidden": `true` };
+}
+function motionThemeSlots2(slotIds, theme, mode, own) {
+  const out = {};
+  for (const id of slotIds) {
+    if (!id.startsWith(`$color.`))
+      continue;
+    const c = parseColor(resolveToken(theme, id, mode));
+    if (c)
+      out[id] = { p: { a: 0, k: [c.r / 255, c.g / 255, c.b / 255, c.a] } };
+  }
+  if (mode === `dark`)
+    out.$mode = `dark`;
+  if (isObj(own))
+    Object.assign(out, own);
+  return out;
+}
+var surfaces = new Map;
+var hiddenListeners = 0;
+var hiddenWatchers = new Set;
+var onVisibility = () => hiddenWatchers.forEach((v) => v.schedule());
+function surfaceOf(el) {
+  return el.closest(`[data-xui-surface]`) ?? el.ownerDocument;
+}
+function granted(view, surface) {
+  const set = surfaces.get(surface);
+  if (!set)
+    return false;
+  const live = [...set].filter((v) => v.root.isConnected);
+  if (live.length <= MOTION_MAX_PLAYING2)
+    return set.has(view);
+  live.sort((a, b) => a.root.compareDocumentPosition(b.root) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1);
+  return live.indexOf(view) < MOTION_MAX_PLAYING2;
+}
+function motionCanPaint2() {
+  return typeof IntersectionObserver === `function` && typeof requestAnimationFrame === `function` && typeof Path2D === `function`;
+}
+async function inflate(data, method) {
+  if (method === 0)
+    return data;
+  if (method !== 8 || typeof DecompressionStream !== `function`)
+    throw new Error(`unsupported .lottie compression`);
+  const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream(`deflate-raw`));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+async function unzip(bytes) {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let eocd = -1;
+  for (let k = bytes.length - 22;k >= Math.max(0, bytes.length - 65557); k--) {
+    if (dv.getUint32(k, true) === 101010256) {
+      eocd = k;
+      break;
+    }
+  }
+  if (eocd < 0)
+    throw new Error(`not a .lottie archive`);
+  const count = dv.getUint16(eocd + 10, true);
+  let p = dv.getUint32(eocd + 16, true);
+  const out = new Map;
+  const dec = new TextDecoder;
+  for (let k = 0;k < count; k++) {
+    if (dv.getUint32(p, true) !== 33639248)
+      break;
+    const method = dv.getUint16(p + 10, true);
+    const size = dv.getUint32(p + 20, true);
+    const nameLen = dv.getUint16(p + 28, true);
+    const extraLen = dv.getUint16(p + 30, true);
+    const commentLen = dv.getUint16(p + 32, true);
+    const local = dv.getUint32(p + 42, true);
+    const name = dec.decode(bytes.subarray(p + 46, p + 46 + nameLen));
+    const start = local + 30 + dv.getUint16(local + 26, true) + dv.getUint16(local + 28, true);
+    if (!name.endsWith(`/`))
+      out.set(name, await inflate(bytes.subarray(start, start + size), method));
+    p += 46 + nameLen + extraLen + commentLen;
+  }
+  return out;
+}
+function base64(bytes) {
+  let s = ``;
+  for (let k = 0;k < bytes.length; k += 32768)
+    s += String.fromCharCode(...bytes.subarray(k, k + 32768));
+  return btoa(s);
+}
+async function motionFromDotLottie2(bytes) {
+  return (await motionDotLottie2(bytes)).lottie;
+}
+async function motionDotLottie2(bytes) {
+  const files = await unzip(bytes);
+  const dec = new TextDecoder;
+  const manifest = files.get(`manifest.json`) ? JSON.parse(dec.decode(files.get(`manifest.json`))) : {};
+  const id = manifest.animations?.[0]?.id;
+  const anims = [...files.keys()].filter((n) => /^(animations|a)\/[^/]+\.json$/.test(n));
+  const name = id && anims.find((n) => n.endsWith(`/${id}.json`)) || anims[0];
+  if (!name)
+    throw new Error(`the .lottie archive has no animation`);
+  const lottie = JSON.parse(dec.decode(files.get(name)));
+  for (const a of lottie.assets ?? []) {
+    const p = a.p;
+    if (typeof p !== `string` || p.startsWith(`data:`) || a.layers)
+      continue;
+    const file = files.get(`images/${p}`) ?? files.get(`i/${p}`);
+    if (!file)
+      continue;
+    const ext = p.split(`.`).pop()?.toLowerCase();
+    const mime = ext === `jpg` || ext === `jpeg` ? `image/jpeg` : ext === `webp` ? `image/webp` : ext === `svg` ? `image/svg+xml` : `image/png`;
+    a.p = `data:${mime};base64,${base64(file)}`;
+    a.u = ``;
+    a.e = 1;
+  }
+  const first = manifest.stateMachines?.[0]?.id ?? manifest.states?.map((s) => typeof s === `string` ? s : s.id)[0];
+  const machines = [...files.keys()].filter((n) => /^(s|states)\/[^/]+\.json$/.test(n));
+  const smName = first && machines.find((n) => n.endsWith(`/${first}.json`)) || machines[0];
+  let stateMachine = null;
+  if (smName) {
+    try {
+      const v = JSON.parse(dec.decode(files.get(smName)));
+      if (isObj(v))
+        stateMachine = v;
+    } catch {}
+  }
+  return { lottie: JSON.stringify(lottie), stateMachine };
+}
+
+class MotionStateDriver2 {
+  player;
+  emit;
+  restart;
+  machineKey = ``;
+  inputsKey = ``;
+  completeSent = false;
+  running = false;
+  constructor(player, emit, restart) {
+    this.player = player;
+    this.emit = emit;
+    this.restart = restart;
+  }
+  setMachine(machine) {
+    const key = isObj(machine) ? JSON.stringify(machine) : ``;
+    if (key === this.machineKey)
+      return this.running;
+    this.machineKey = key;
+    this.inputsKey = ``;
+    this.running = this.player.setStateMachine(key || `{}`);
+    if (this.running)
+      this.changed();
+    this.drain();
+    return this.running;
+  }
+  setInputs(inputs) {
+    if (!this.running || !isObj(inputs))
+      return;
+    const key = JSON.stringify(inputs);
+    if (key === this.inputsKey)
+      return;
+    this.inputsKey = key;
+    if (this.player.smSetInputs(key))
+      this.changed();
+    this.drain();
+  }
+  post(kind, layer = ``) {
+    if (!this.running)
+      return;
+    if (this.player.smPost(kind, layer))
+      this.changed();
+    this.drain();
+  }
+  done() {
+    if (!this.completeSent) {
+      this.completeSent = true;
+      this.emit(`complete`);
+    }
+    this.post(`complete`);
+  }
+  replay() {
+    if (!this.running)
+      this.completeSent = false;
+  }
+  changed() {
+    this.completeSent = false;
+    this.restart();
+  }
+  drain() {
+    if (!this.running)
+      return;
+    const status = JSON.parse(this.player.smStatus());
+    for (const state of status?.entered ?? [])
+      this.emit(`state`, { state });
+    if (status?.final && !this.completeSent) {
+      this.completeSent = true;
+      this.emit(`complete`);
+    }
+  }
+}
+var themeIds = new WeakMap;
+var nextThemeId = 1;
+var themeId = (t) => {
+  let id = themeIds.get(t);
+  if (!id)
+    themeIds.set(t, id = nextThemeId++);
+  return id;
+};
+
+class MotionView2 {
+  root;
+  canvas;
+  props = {};
+  nodeStyle = undefined;
+  env = null;
+  sourceKey = ``;
+  slotsKey = ``;
+  playbackKey = ``;
+  generation = 0;
+  lottie = null;
+  fileMachine = null;
+  driver = null;
+  halfSeen = false;
+  visibleSent = false;
+  slotIds = [];
+  player = null;
+  images = [];
+  pool = new MotionCanvasPool2;
+  io = null;
+  ro = null;
+  visible = false;
+  surface = null;
+  raf = 0;
+  last = 0;
+  lastPaint = -Infinity;
+  elapsed = 0;
+  finished = false;
+  restarts = 0;
+  inTick = false;
+  painted = ``;
+  destroyed = false;
+  constructor(root, canvas) {
+    this.root = root;
+    this.canvas = canvas;
+    root.addEventListener(`click`, this.onClick);
+    root.addEventListener(`keydown`, this.onKey);
+    root.addEventListener(`pointerdown`, this.onPointer);
+    root.addEventListener(`pointerup`, this.onPointer);
+    root.addEventListener(`pointerenter`, this.onPointer);
+    root.addEventListener(`pointerleave`, this.onPointer);
+    if (!motionCanPaint2())
+      return;
+    this.io = new IntersectionObserver((entries) => {
+      const e = entries[entries.length - 1];
+      this.visible = Boolean(e?.isIntersecting);
+      if (e && e.isIntersecting && e.intersectionRatio >= 0.5)
+        this.halfSeen = true;
+      this.flushVisible();
+      this.schedule();
+    }, { threshold: [0, 0.5] });
+    this.io.observe(root);
+    if (typeof ResizeObserver === `function`) {
+      this.ro = new ResizeObserver(() => this.repaint());
+      this.ro.observe(root);
+    }
+    hiddenWatchers.add(this);
+    if (hiddenListeners++ === 0)
+      document.addEventListener(`visibilitychange`, onVisibility);
+  }
+  update(props, env, nodeStyle) {
+    if (this.destroyed)
+      return;
+    this.props = props;
+    this.nodeStyle = nodeStyle;
+    this.env = env;
+    if (!this.io)
+      return;
+    this.flushVisible();
+    const sourceKey = Array.isArray(props.layers) ? `d:${JSON.stringify(Object.fromEntries(DIALECT_KEYS.map((k) => [k, props[k]])))}` : isObj(props.lottie) ? `l:${JSON.stringify(props.lottie)}` : typeof props.src === `string` && props.src ? `s:${props.src}` : ``;
+    const slotsKey = `${themeId(env.theme)}:${env.mode}:${JSON.stringify(props.slots ?? null)}`;
+    if (sourceKey !== this.sourceKey) {
+      this.sourceKey = sourceKey;
+      this.slotsKey = slotsKey;
+      this.load();
+      return;
+    }
+    if (slotsKey !== this.slotsKey) {
+      this.slotsKey = slotsKey;
+      this.instantiate();
+      return;
+    }
+    this.applyMachine();
+    this.applyPlayback();
+    this.schedule();
+  }
+  emit(event, payload) {
+    if (!this.destroyed)
+      this.env?.emit?.(event, payload);
+  }
+  flushVisible() {
+    if (!this.halfSeen || this.visibleSent || !this.env)
+      return;
+    this.visibleSent = true;
+    this.emit(`visible`);
+  }
+  onClick = () => {
+    this.driver?.post(`click`);
+    this.emit(`press`);
+  };
+  onKey = (e) => {
+    if (!this.env?.pressable || e.key !== `Enter` && e.key !== ` ` || e.target !== this.root)
+      return;
+    e.preventDefault();
+    this.onClick();
+  };
+  onPointer = (e) => {
+    const kind = e.type === `pointerdown` ? `pointerDown` : e.type === `pointerup` ? `pointerUp` : e.type === `pointerenter` ? `pointerEnter` : `pointerExit`;
+    this.driver?.post(kind);
+    if (kind === `pointerEnter`)
+      this.emit(`hover`);
+  };
+  applyMachine() {
+    const d = this.driver;
+    if (!d)
+      return;
+    const was = d.running;
+    const running = d.setMachine(isObj(this.props.stateMachine) ? this.props.stateMachine : this.fileMachine);
+    if (was && !running)
+      this.playbackKey = ``;
+    d.setInputs(this.props.inputs);
+  }
+  restartClock = () => {
+    this.elapsed = 0;
+    this.finished = false;
+    this.restarts++;
+    this.painted = ``;
+    if (!this.inTick)
+      this.schedule();
+  };
+  destroy() {
+    this.destroyed = true;
+    for (const t of [`click`, `keydown`, `pointerdown`, `pointerup`, `pointerenter`, `pointerleave`])
+      this.root.removeEventListener(t, t === `click` ? this.onClick : t === `keydown` ? this.onKey : this.onPointer);
+    this.generation++;
+    this.stop();
+    this.leaveSurface();
+    this.io?.disconnect();
+    this.ro?.disconnect();
+    if (this.io) {
+      hiddenWatchers.delete(this);
+      if (--hiddenListeners === 0)
+        document.removeEventListener(`visibilitychange`, onVisibility);
+    }
+    this.player?.free();
+    this.player = null;
+  }
+  fail(message) {
+    this.root.dataset.state = `error`;
+    this.env?.onError?.(message);
+  }
+  async load() {
+    const gen = ++this.generation;
+    this.free();
+    this.lottie = null;
+    this.fileMachine = null;
+    this.root.dataset.state = `loading`;
+    const props = this.props;
+    const env = this.env;
+    try {
+      const wasm = await (await (__preload("ctcc3cma"), import("./wasm-ctcc3cma.js"))).loadMotionWasm();
+      let lottie;
+      if (Array.isArray(props.layers)) {
+        const doc = Object.fromEntries(DIALECT_KEYS.filter((k) => props[k] !== undefined).map((k) => [k, props[k]]));
+        const out = JSON.parse(wasm.compile(JSON.stringify(doc)));
+        if (!out.lottie)
+          throw new Error(`Motion: ${(out.errors ?? []).map((e) => `${e.path ?? ``} ${e.message ?? ``}`.trim()).join(`; `) || `invalid layers`}`);
+        lottie = JSON.stringify(out.lottie);
+      } else if (isObj(props.lottie))
+        lottie = JSON.stringify(props.lottie);
+      else if (typeof props.src === `string` && props.src) {
+        const req = mediaRequestOf2(env.host, props.src);
+        if (!req)
+          throw new Error(`Motion: src denied by the media policy`);
+        const blob = await fetchLimited2(req.url, req.headers ?? {}, MEDIA_LIMITS2, false, (u) => mediaUrlAllowed2(env.host, u));
+        const bytes = new Uint8Array(await blob.arrayBuffer());
+        if (bytes[0] === 80 && bytes[1] === 75) {
+          const dot = await motionDotLottie2(bytes);
+          lottie = dot.lottie;
+          this.fileMachine = dot.stateMachine;
+        } else
+          lottie = new TextDecoder().decode(bytes);
+      } else
+        throw new Error(`Motion: no source (layers, lottie or src)`);
+      if (gen !== this.generation)
+        return;
+      this.lottie = lottie;
+      const slots = JSON.parse(lottie).slots;
+      this.slotIds = isObj(slots) ? Object.keys(slots) : [];
+      this.instantiate();
+    } catch (e) {
+      if (gen !== this.generation)
+        return;
+      this.fail(e instanceof Error ? e.message : String(e));
+    }
+  }
+  free() {
+    this.stop();
+    this.driver = null;
+    this.player?.free();
+    this.player = null;
+    this.images = [];
+    this.painted = ``;
+  }
+  instantiate() {
+    if (!this.lottie || !this.env)
+      return;
+    (__preload("ctcc3cma"), import("./wasm-ctcc3cma.js")).then(async (m) => {
+      const wasm = await m.loadMotionWasm();
+      if (this.destroyed || !this.lottie || !this.env)
+        return;
+      this.free();
+      const slots = motionThemeSlots2(this.slotIds, this.env.theme, this.env.mode, this.props.slots);
+      try {
+        this.player = new wasm.MotionPlayer(this.lottie, JSON.stringify(slots));
+      } catch (e) {
+        this.fail(`Motion: ${e instanceof Error ? e.message : String(e)}`);
+        return;
+      }
+      this.root.dataset.state = `ready`;
+      if (!motionDeclaredSize2(this.props)) {
+        const w = this.player.width(), h = this.player.height();
+        if (w > 0 && h > 0)
+          Object.assign(this.root.style, motionBoxStyle2([w, h], this.nodeStyle));
+      }
+      this.loadImages();
+      this.playbackKey = ``;
+      this.applyPlayback();
+      this.driver = new MotionStateDriver2(this.player, (event, payload) => this.emit(event, payload), this.restartClock);
+      this.applyMachine();
+      this.schedule();
+    });
+  }
+  loadImages() {
+    const player = this.player;
+    if (!player || !this.env)
+      return;
+    const env = this.env;
+    player.images().forEach((loc, k) => {
+      this.images[k] = null;
+      let url = loc;
+      if (!loc.startsWith(`data:`))
+        url = mediaRequestOf2(env.host, loc)?.url ?? null;
+      if (!url)
+        return;
+      const img = new Image;
+      img.decoding = `async`;
+      img.onload = () => {
+        if (this.player !== player)
+          return;
+        this.images[k] = img;
+        this.repaint();
+      };
+      img.src = url;
+    });
+  }
+  applyPlayback() {
+    if (!this.player || this.driver?.running)
+      return;
+    const key = JSON.stringify(Object.fromEntries(PLAYBACK_KEYS.map((k) => [k, this.props[k]])));
+    if (key === this.playbackKey)
+      return;
+    this.playbackKey = key;
+    this.player.setPlayback(key);
+    this.elapsed = 0;
+    this.finished = false;
+    this.driver?.replay();
+  }
+  wantsToAnimate() {
+    const p = this.props;
+    const autoplay = this.driver?.running || p.autoplay !== false;
+    return Boolean(this.player) && typeof p.progress !== `number` && autoplay && p.play !== false && !this.env?.reducedMotion && !this.finished && this.visible && !document.hidden;
+  }
+  leaveSurface() {
+    if (!this.surface)
+      return;
+    const set = surfaces.get(this.surface);
+    set?.delete(this);
+    if (set && set.size === 0)
+      surfaces.delete(this.surface);
+    set?.forEach((v) => v.schedule());
+    this.surface = null;
+  }
+  schedule() {
+    if (this.destroyed || !this.io)
+      return;
+    if (this.wantsToAnimate()) {
+      if (!this.surface) {
+        this.surface = surfaceOf(this.root);
+        let set = surfaces.get(this.surface);
+        if (!set)
+          surfaces.set(this.surface, set = new Set);
+        set.add(this);
+        set.forEach((v) => v !== this && v.schedule());
+      }
+      if (granted(this, this.surface)) {
+        if (!this.raf) {
+          this.last = -1;
+          this.raf = requestAnimationFrame(this.tick);
+        }
+        return;
+      }
+    } else
+      this.leaveSurface();
+    this.stop();
+    this.repaint();
+  }
+  stop() {
+    if (this.raf)
+      cancelAnimationFrame(this.raf);
+    this.raf = 0;
+  }
+  tick = (now) => {
+    this.raf = 0;
+    if (!this.player || this.destroyed)
+      return;
+    if (this.last >= 0)
+      this.elapsed += now - this.last;
+    this.last = now;
+    if (this.player.done(this.elapsed)) {
+      const before = this.restarts;
+      this.inTick = true;
+      this.driver?.done();
+      if (!this.driver)
+        this.emit(`complete`);
+      this.inTick = false;
+      if (this.restarts === before || !this.player) {
+        this.finished = true;
+        this.schedule();
+        return;
+      }
+    }
+    if (now - this.lastPaint >= 1000 / MOTION_MAX_FPS2 - 1) {
+      this.lastPaint = now;
+      this.paint(this.player.tick(this.elapsed));
+    }
+    if (!this.raf)
+      this.raf = requestAnimationFrame(this.tick);
+  };
+  stillFrame() {
+    const p = this.player;
+    const progress = this.props.progress;
+    if (typeof progress === `number`)
+      return p.progressFrame(Math.max(0, Math.min(1, progress)));
+    if (this.finished || this.elapsed > 0 && !this.env?.reducedMotion && (this.driver?.running || this.props.autoplay !== false))
+      return p.tick(this.elapsed);
+    return p.posterFrame();
+  }
+  repaint() {
+    if (!this.player || this.raf) {
+      if (this.raf)
+        this.painted = ``;
+      return;
+    }
+    this.painted = ``;
+    this.paint(this.stillFrame());
+  }
+  paint(frame) {
+    const player = this.player;
+    if (!player)
+      return;
+    const rect = this.root.getBoundingClientRect();
+    const dpr = typeof window !== `undefined` && window.devicePixelRatio || 1;
+    const w = Math.max(1, Math.round(rect.width * dpr));
+    const h = Math.max(1, Math.round(rect.height * dpr));
+    const fit = motionFit2(this.props.fit);
+    const key = `${frame}|${w}|${h}|${fit}`;
+    if (key === this.painted)
+      return;
+    this.painted = key;
+    if (this.canvas.width !== w || this.canvas.height !== h) {
+      this.canvas.width = w;
+      this.canvas.height = h;
+    }
+    const ctx = this.canvas.getContext(`2d`);
+    if (!ctx)
+      return;
+    const base = motionConcat2([dpr, 0, 0, dpr, 0, 0], motionFitMatrix2(player.width(), player.height(), w / dpr, h / dpr, fit));
+    paintMotionFrame2(ctx, w, h, player.sample(frame), base, this.images, this.pool);
+  }
+}
+function resetMotionThemeIds2() {
+  themeIds = new WeakMap;
+  nextThemeId = 1;
+}
+
+export { __export, __chunks, ownPrivateHosts2, urlPolicyOf2, linkHref2, mediaRequestOf2, mediaUrlAllowed2, openAllowed2, MEDIA_CACHE_IDLE_MAX2, mediaCacheKey2, acquireMedia2, releaseMedia2, mediaCacheStats2, clearMediaCache2, openMediaSource2, streamEntry2, fetchStream2, fetchLimited2, layoutSize2, visualScale2, elementScale2, VOICE_WAVE_SIZES2, VOICE_WAVE_SIZE_PX2, voiceWaveAnimates2, voiceWaveQuiet2, voiceWaveName2, voiceWaveClock2, voiceWaveFitChild2, VOICE_WAVE_CLASSES2, motionFitMatrix2, motionConcat2, motionFrameSize2, MotionCanvasPool2, paintMotionFrame2, MOTION_MAX_PLAYING2, MOTION_MAX_FPS2, motionDeclaredSize2, motionBoxStyle2, motionFit2, motionA11y2, motionThemeSlots2, motionCanPaint2, motionFromDotLottie2, motionDotLottie2, MotionStateDriver2, MotionView2, resetMotionThemeIds2 };
+
+//# debugId=4B679732CF837C4A64756E2164756E21
+//# sourceMappingURL=index-t2mwfbb6.js.map