@core-ease/telegram-kit 3.0.1

package/dist/chunk-BQEUEAVK.mjs

@@ -0,0 +1,2262 @@
+"use client";
+import { __spreadValues } from './chunk-PXO36YTU.mjs';
+import * as React from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/_internal/animation/lottie/bezierEasing.ts
+function A(a1, a2) {
+  return 1 - 3 * a2 + 3 * a1;
+}
+function B(a1, a2) {
+  return 3 * a2 - 6 * a1;
+}
+function C(a1) {
+  return 3 * a1;
+}
+function calcBezier(t, a1, a2) {
+  return ((A(a1, a2) * t + B(a1, a2)) * t + C(a1)) * t;
+}
+function getSlope(t, a1, a2) {
+  return 3 * A(a1, a2) * t * t + 2 * B(a1, a2) * t + C(a1);
+}
+function makeBezierEasing(x1, y1, x2, y2) {
+  if (x1 === y1 && x2 === y2) {
+    return (x) => x;
+  }
+  const clampedX1 = Math.min(Math.max(x1, 0), 1);
+  const clampedX2 = Math.min(Math.max(x2, 0), 1);
+  function getTForX(x) {
+    let t = x;
+    for (let i = 0; i < 8; i++) {
+      const currentSlope = getSlope(t, clampedX1, clampedX2);
+      if (currentSlope === 0) break;
+      const currentX = calcBezier(t, clampedX1, clampedX2) - x;
+      t -= currentX / currentSlope;
+    }
+    let lower = 0;
+    let upper = 1;
+    let candidate = t;
+    if (candidate < 0 || candidate > 1 || isNaN(candidate)) {
+      candidate = x;
+      for (let i = 0; i < 20; i++) {
+        const currentX = calcBezier(candidate, clampedX1, clampedX2);
+        if (Math.abs(currentX - x) < 1e-6) break;
+        if (currentX < x) {
+          lower = candidate;
+        } else {
+          upper = candidate;
+        }
+        candidate = (lower + upper) / 2;
+      }
+    }
+    return candidate;
+  }
+  return (x) => {
+    if (x <= 0) return 0;
+    if (x >= 1) return 1;
+    const t = getTForX(x);
+    return calcBezier(t, y1, y2);
+  };
+}
+
+// src/_internal/animation/lottie/interpolate.ts
+var easingCache = /* @__PURE__ */ new Map();
+function getEasing(ox, oy, ix, iy) {
+  const key = `${ox}|${oy}|${ix}|${iy}`;
+  let fn = easingCache.get(key);
+  if (!fn) {
+    fn = makeBezierEasing(ox, oy, ix, iy);
+    easingCache.set(key, fn);
+  }
+  return fn;
+}
+function componentAt(v, idx) {
+  var _a, _b;
+  if (v == null) return 0.5;
+  if (Array.isArray(v)) return (_b = (_a = v[idx]) != null ? _a : v[0]) != null ? _b : 0.5;
+  return v;
+}
+function getAnimatedValue(prop, frame) {
+  if (!prop) return [0];
+  if (prop.a === 0 || !Array.isArray(prop.k) || typeof prop.k[0] === "number") {
+    const k = prop.k;
+    return Array.isArray(k) ? k : [k];
+  }
+  const keyframes = prop.k;
+  return sampleKeyframes(keyframes, frame);
+}
+function sampleKeyframes(keyframes, frame) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  if (keyframes.length === 0) return [0];
+  if (frame <= keyframes[0].t) {
+    return (_a = keyframes[0].s) != null ? _a : [0];
+  }
+  const last = keyframes[keyframes.length - 1];
+  if (frame >= last.t) {
+    return (_d = (_c = last.s) != null ? _c : (_b = keyframes[keyframes.length - 2]) == null ? void 0 : _b.e) != null ? _d : [0];
+  }
+  for (let idx = 0; idx < keyframes.length - 1; idx++) {
+    const kf = keyframes[idx];
+    const next = keyframes[idx + 1];
+    if (frame >= kf.t && frame < next.t) {
+      const startVal = (_e = kf.s) != null ? _e : [0];
+      const endVal = (_g = (_f = kf.e) != null ? _f : next.s) != null ? _g : startVal;
+      if (kf.h === 1) {
+        return startVal;
+      }
+      const span = next.t - kf.t;
+      const linearT = span > 0 ? (frame - kf.t) / span : 0;
+      const dims = Math.max(startVal.length, endVal.length);
+      const out = new Array(dims);
+      for (let d = 0; d < dims; d++) {
+        const ox = componentAt((_h = kf.o) == null ? void 0 : _h.x, d);
+        const oy = componentAt((_i = kf.o) == null ? void 0 : _i.y, d);
+        const ix = componentAt((_j = kf.i) == null ? void 0 : _j.x, d);
+        const iy = componentAt((_k = kf.i) == null ? void 0 : _k.y, d);
+        const ease = getEasing(ox, oy, ix, iy);
+        const easedT = ease(linearT);
+        const s = (_m = (_l = startVal[d]) != null ? _l : startVal[0]) != null ? _m : 0;
+        const e = (_o = (_n = endVal[d]) != null ? _n : endVal[0]) != null ? _o : s;
+        out[d] = s + (e - s) * easedT;
+      }
+      return out;
+    }
+  }
+  return (_p = last.s) != null ? _p : [0];
+}
+function getAnimatedPosition(prop, frame) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  if (!prop) return [0, 0, 0];
+  if (prop.a === 0 || !Array.isArray(prop.k) || typeof prop.k[0] === "number") {
+    const k = prop.k;
+    return Array.isArray(k) ? k : [k, 0, 0];
+  }
+  const keyframes = prop.k;
+  if (keyframes.length === 0) return [0, 0, 0];
+  if (frame <= keyframes[0].t) return (_a = keyframes[0].s) != null ? _a : [0, 0, 0];
+  const last = keyframes[keyframes.length - 1];
+  if (frame >= last.t) return (_b = last.s) != null ? _b : [0, 0, 0];
+  for (let idx = 0; idx < keyframes.length - 1; idx++) {
+    const kf = keyframes[idx];
+    const next = keyframes[idx + 1];
+    if (frame >= kf.t && frame < next.t) {
+      const startVal = (_c = kf.s) != null ? _c : [0, 0, 0];
+      const endVal = (_e = (_d = kf.e) != null ? _d : next.s) != null ? _e : startVal;
+      if (kf.h === 1) return startVal;
+      const span = next.t - kf.t;
+      const linearT = span > 0 ? (frame - kf.t) / span : 0;
+      const ox = componentAt((_f = kf.o) == null ? void 0 : _f.x, 0);
+      const oy = componentAt((_g = kf.o) == null ? void 0 : _g.y, 0);
+      const ix = componentAt((_h = kf.i) == null ? void 0 : _h.x, 0);
+      const iy = componentAt((_i = kf.i) == null ? void 0 : _i.y, 0);
+      const easedT = getEasing(ox, oy, ix, iy)(linearT);
+      if (kf.to && kf.ti) {
+        const p0 = startVal;
+        const p3 = endVal;
+        const p1 = [p0[0] + kf.to[0], p0[1] + kf.to[1], ((_j = p0[2]) != null ? _j : 0) + ((_k = kf.to[2]) != null ? _k : 0)];
+        const p2 = [p3[0] + kf.ti[0], p3[1] + kf.ti[1], ((_l = p3[2]) != null ? _l : 0) + ((_m = kf.ti[2]) != null ? _m : 0)];
+        return cubicBezierPoint(p0, p1, p2, p3, easedT);
+      }
+      const dims = Math.max(startVal.length, endVal.length);
+      const out = new Array(dims);
+      for (let d = 0; d < dims; d++) {
+        const s = (_n = startVal[d]) != null ? _n : 0;
+        const e = (_o = endVal[d]) != null ? _o : s;
+        out[d] = s + (e - s) * easedT;
+      }
+      return out;
+    }
+  }
+  return (_p = last.s) != null ? _p : [0, 0, 0];
+}
+function cubicBezierPoint(p0, p1, p2, p3, t) {
+  var _a, _b, _c, _d;
+  const mt = 1 - t;
+  const a = mt * mt * mt;
+  const b = 3 * mt * mt * t;
+  const c = 3 * mt * t * t;
+  const d = t * t * t;
+  const dims = Math.max(p0.length, p1.length, p2.length, p3.length);
+  const out = new Array(dims);
+  for (let i = 0; i < dims; i++) {
+    out[i] = a * ((_a = p0[i]) != null ? _a : 0) + b * ((_b = p1[i]) != null ? _b : 0) + c * ((_c = p2[i]) != null ? _c : 0) + d * ((_d = p3[i]) != null ? _d : 0);
+  }
+  return out;
+}
+function lerpShapeValue(a, b, t) {
+  var _a, _b, _c, _d, _e, _f;
+  const count = Math.min(a.v.length, b.v.length);
+  const v = new Array(count);
+  const i = new Array(count);
+  const o = new Array(count);
+  for (let idx = 0; idx < count; idx++) {
+    const av = (_a = a.v[idx]) != null ? _a : [0, 0];
+    const bv = (_b = b.v[idx]) != null ? _b : av;
+    const ai = (_c = a.i[idx]) != null ? _c : [0, 0];
+    const bi = (_d = b.i[idx]) != null ? _d : ai;
+    const ao = (_e = a.o[idx]) != null ? _e : [0, 0];
+    const bo = (_f = b.o[idx]) != null ? _f : ao;
+    v[idx] = [av[0] + (bv[0] - av[0]) * t, av[1] + (bv[1] - av[1]) * t];
+    i[idx] = [ai[0] + (bi[0] - ai[0]) * t, ai[1] + (bi[1] - ai[1]) * t];
+    o[idx] = [ao[0] + (bo[0] - ao[0]) * t, ao[1] + (bo[1] - ao[1]) * t];
+  }
+  return { c: a.c, v, i, o };
+}
+function getAnimatedShape(prop, frame) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+  const empty = { c: false, v: [], i: [], o: [] };
+  if (!prop) return empty;
+  if (prop.a === 0) {
+    return (_a = prop.k) != null ? _a : empty;
+  }
+  const keyframes = prop.k;
+  if (!keyframes || keyframes.length === 0) return empty;
+  if (frame <= keyframes[0].t) return (_c = (_b = keyframes[0].s) == null ? void 0 : _b[0]) != null ? _c : empty;
+  const last = keyframes[keyframes.length - 1];
+  if (frame >= last.t) return (_e = (_d = last.s) == null ? void 0 : _d[0]) != null ? _e : empty;
+  for (let idx = 0; idx < keyframes.length - 1; idx++) {
+    const kf = keyframes[idx];
+    const next = keyframes[idx + 1];
+    if (frame >= kf.t && frame < next.t) {
+      const startVal = (_g = (_f = kf.s) == null ? void 0 : _f[0]) != null ? _g : empty;
+      const endVal = (_k = (_j = (_h = kf.e) == null ? void 0 : _h[0]) != null ? _j : (_i = next.s) == null ? void 0 : _i[0]) != null ? _k : startVal;
+      if (kf.h === 1) return startVal;
+      const span = next.t - kf.t;
+      const linearT = span > 0 ? (frame - kf.t) / span : 0;
+      const ox = componentAt((_l = kf.o) == null ? void 0 : _l.x, 0);
+      const oy = componentAt((_m = kf.o) == null ? void 0 : _m.y, 0);
+      const ix = componentAt((_n = kf.i) == null ? void 0 : _n.x, 0);
+      const iy = componentAt((_o = kf.i) == null ? void 0 : _o.y, 0);
+      const easedT = getEasing(ox, oy, ix, iy)(linearT);
+      return lerpShapeValue(startVal, endVal, easedT);
+    }
+  }
+  return (_q = (_p = last.s) == null ? void 0 : _p[0]) != null ? _q : empty;
+}
+
+// src/_internal/animation/lottie/matrix.ts
+function identity() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function multiply(m1, m2) {
+  return [
+    m1[0] * m2[0] + m1[2] * m2[1],
+    m1[1] * m2[0] + m1[3] * m2[1],
+    m1[0] * m2[2] + m1[2] * m2[3],
+    m1[1] * m2[2] + m1[3] * m2[3],
+    m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+    m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+  ];
+}
+function translate(m, x, y) {
+  return multiply(m, [1, 0, 0, 1, x, y]);
+}
+function rotate(m, radians) {
+  const c = Math.cos(radians);
+  const s = Math.sin(radians);
+  return multiply(m, [c, s, -s, c, 0, 0]);
+}
+function scale(m, sx, sy) {
+  return multiply(m, [sx, 0, 0, sy, 0, 0]);
+}
+function skew(m, skewDeg, skewAxisDeg) {
+  if (!skewDeg) return m;
+  const axis = skewAxisDeg * Math.PI / 180;
+  const angle = -skewDeg * Math.PI / 180;
+  const sMat = multiply(
+    [Math.cos(axis), Math.sin(axis), -Math.sin(axis), Math.cos(axis), 0, 0],
+    [1, 0, Math.tan(angle), 1, 0, 0]
+  );
+  const back = [
+    Math.cos(-axis),
+    Math.sin(-axis),
+    -Math.sin(-axis),
+    Math.cos(-axis),
+    0,
+    0
+  ];
+  return multiply(m, multiply(sMat, back));
+}
+function applyToPoint(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+
+// src/_internal/animation/lottie/path.ts
+var CIRCLE_K = 0.5522847498307936;
+function shapeValueToBezierPath(sv) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const vertices = [];
+  const count = (_b = (_a = sv.v) == null ? void 0 : _a.length) != null ? _b : 0;
+  for (let idx = 0; idx < count; idx++) {
+    const v = (_c = sv.v[idx]) != null ? _c : [0, 0];
+    const i = (_e = (_d = sv.i) == null ? void 0 : _d[idx]) != null ? _e : [0, 0];
+    const o = (_g = (_f = sv.o) == null ? void 0 : _f[idx]) != null ? _g : [0, 0];
+    vertices.push({ v: [v[0], v[1]], i: [i[0], i[1]], o: [o[0], o[1]] });
+  }
+  return { closed: !!sv.c, vertices };
+}
+function rectToBezierPath(cx, cy, width, height, radius) {
+  const w = width / 2;
+  const h = height / 2;
+  const r = Math.max(0, Math.min(radius, w, h));
+  const k = r * CIRCLE_K;
+  if (r <= 0.01) {
+    return {
+      closed: true,
+      vertices: [
+        { v: [cx + w, cy - h], i: [0, 0], o: [0, 0] },
+        { v: [cx + w, cy + h], i: [0, 0], o: [0, 0] },
+        { v: [cx - w, cy + h], i: [0, 0], o: [0, 0] },
+        { v: [cx - w, cy - h], i: [0, 0], o: [0, 0] }
+      ]
+    };
+  }
+  return {
+    closed: true,
+    vertices: [
+      { v: [cx + w, cy - h + r], i: [0, -k], o: [0, 0] },
+      { v: [cx + w, cy + h - r], i: [0, 0], o: [0, k] },
+      { v: [cx + w - r, cy + h], i: [k, 0], o: [0, 0] },
+      { v: [cx - w + r, cy + h], i: [0, 0], o: [-k, 0] },
+      { v: [cx - w, cy + h - r], i: [0, k], o: [0, 0] },
+      { v: [cx - w, cy - h + r], i: [0, 0], o: [0, -k] },
+      { v: [cx - w + r, cy - h], i: [-k, 0], o: [0, 0] },
+      { v: [cx + w - r, cy - h], i: [0, 0], o: [k, 0] }
+    ]
+  };
+}
+function ellipseToBezierPath(cx, cy, width, height) {
+  const rx = width / 2;
+  const ry = height / 2;
+  const kx = rx * CIRCLE_K;
+  const ky = ry * CIRCLE_K;
+  return {
+    closed: true,
+    vertices: [
+      { v: [cx, cy - ry], i: [-kx, 0], o: [kx, 0] },
+      { v: [cx + rx, cy], i: [0, -ky], o: [0, ky] },
+      { v: [cx, cy + ry], i: [kx, 0], o: [-kx, 0] },
+      { v: [cx - rx, cy], i: [0, ky], o: [0, -ky] }
+    ]
+  };
+}
+function starToBezierPath(cx, cy, points, outerRadius, innerRadius, outerRoundness, innerRoundness, rotationDeg, isPolygon) {
+  const vertices = [];
+  const numPoints = Math.max(3, Math.round(points));
+  const angleStep = Math.PI / numPoints;
+  const startAngle = (rotationDeg - 90) * (Math.PI / 180);
+  const totalPoints = isPolygon ? numPoints : numPoints * 2;
+  for (let idx = 0; idx < totalPoints; idx++) {
+    const isOuter = isPolygon ? true : idx % 2 === 0;
+    const radius = isOuter ? outerRadius : innerRadius;
+    const angle = startAngle + idx * (isPolygon ? angleStep * 2 : angleStep);
+    const x = cx + radius * Math.cos(angle);
+    const y = cy + radius * Math.sin(angle);
+    const roundness = (isOuter ? outerRoundness : innerRoundness) / 100;
+    const tangentLen = radius * (Math.PI / (isPolygon ? numPoints : numPoints)) * roundness / 2;
+    const perpAngle = angle + Math.PI / 2;
+    const tx = Math.cos(perpAngle) * tangentLen;
+    const ty = Math.sin(perpAngle) * tangentLen;
+    vertices.push({ v: [x, y], i: [-tx, -ty], o: [tx, ty] });
+  }
+  return { closed: true, vertices };
+}
+function tracePathOnContext(ctx, path, m) {
+  const verts = path.vertices;
+  if (verts.length === 0) return;
+  const p0 = applyToPoint(m, verts[0].v[0], verts[0].v[1]);
+  ctx.moveTo(p0[0], p0[1]);
+  for (let idx = 0; idx < verts.length - 1; idx++) {
+    drawSegment(ctx, verts[idx], verts[idx + 1], m);
+  }
+  if (path.closed && verts.length > 1) {
+    drawSegment(ctx, verts[verts.length - 1], verts[0], m);
+    ctx.closePath();
+  }
+}
+function drawSegment(ctx, from, to, m) {
+  const c1 = applyToPoint(m, from.v[0] + from.o[0], from.v[1] + from.o[1]);
+  const c2 = applyToPoint(m, to.v[0] + to.i[0], to.v[1] + to.i[1]);
+  const end = applyToPoint(m, to.v[0], to.v[1]);
+  ctx.bezierCurveTo(c1[0], c1[1], c2[0], c2[1], end[0], end[1]);
+}
+function flattenSegment(from, to, samples) {
+  const pts = [];
+  const p0 = from.v;
+  const p1 = [from.v[0] + from.o[0], from.v[1] + from.o[1]];
+  const p2 = [to.v[0] + to.i[0], to.v[1] + to.i[1]];
+  const p3 = to.v;
+  for (let s = 1; s <= samples; s++) {
+    const t = s / samples;
+    const mt = 1 - t;
+    const a = mt * mt * mt;
+    const b = 3 * mt * mt * t;
+    const c = 3 * mt * t * t;
+    const d = t * t * t;
+    pts.push([
+      a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0],
+      a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]
+    ]);
+  }
+  return pts;
+}
+function flattenPath(path, samplesPerSegment = 16) {
+  const verts = path.vertices;
+  const points = [];
+  if (verts.length === 0) return { points, closed: path.closed };
+  points.push(verts[0].v);
+  for (let idx = 0; idx < verts.length - 1; idx++) {
+    points.push(...flattenSegment(verts[idx], verts[idx + 1], samplesPerSegment));
+  }
+  if (path.closed && verts.length > 1) {
+    points.push(...flattenSegment(verts[verts.length - 1], verts[0], samplesPerSegment));
+  }
+  return { points, closed: path.closed };
+}
+function polylineLength(points) {
+  let len = 0;
+  for (let i = 1; i < points.length; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    len += Math.hypot(dx, dy);
+  }
+  return len;
+}
+function trimPaths(paths, startPct, endPct, offsetPct, mode = 1) {
+  if (paths.length === 0) return paths;
+  if (mode === 2) {
+    const out = [];
+    for (const p of paths) {
+      out.push(...trimPaths([p], startPct, endPct, offsetPct, 1));
+    }
+    return out;
+  }
+  const flattened = paths.map((p) => flattenPath(p, 20));
+  const combined = flattened.map((f, idx) => ({ pathIdx: idx, points: f.points }));
+  const lengths = combined.map((c) => polylineLength(c.points));
+  const totalLength = lengths.reduce((a, b) => a + b, 0);
+  if (totalLength <= 0) return paths;
+  let s = (Math.min(startPct, endPct) / 100 + offsetPct / 360) % 1;
+  let e = (Math.max(startPct, endPct) / 100 + offsetPct / 360) % 1;
+  if (s < 0) s += 1;
+  if (e < 0) e += 1;
+  const startDist = s * totalLength;
+  const endDist = e * totalLength;
+  const wraps = endDist < startDist;
+  const resultVertices = [];
+  let cursor = 0;
+  const pushRange = (lo, hi) => {
+    for (const seg of combined) {
+      const segLen = polylineLength(seg.points);
+      const segStart = cursor;
+      const segEnd = cursor + segLen;
+      cursor = segEnd;
+      if (segEnd < lo || segStart > hi) continue;
+      let acc = segStart;
+      for (let i = 1; i < seg.points.length; i++) {
+        const p0 = seg.points[i - 1];
+        const p1 = seg.points[i];
+        const segPieceLen = Math.hypot(p1[0] - p0[0], p1[1] - p0[1]);
+        const pieceStart = acc;
+        const pieceEnd = acc + segPieceLen;
+        acc = pieceEnd;
+        if (pieceEnd < lo || pieceStart > hi) continue;
+        const clipLo = Math.max(lo, pieceStart);
+        const clipHi = Math.min(hi, pieceEnd);
+        const t0 = segPieceLen > 0 ? (clipLo - pieceStart) / segPieceLen : 0;
+        const t1 = segPieceLen > 0 ? (clipHi - pieceStart) / segPieceLen : 0;
+        const pt0 = [
+          p0[0] + (p1[0] - p0[0]) * t0,
+          p0[1] + (p1[1] - p0[1]) * t0
+        ];
+        const pt1 = [
+          p0[0] + (p1[0] - p0[0]) * t1,
+          p0[1] + (p1[1] - p0[1]) * t1
+        ];
+        if (resultVertices.length === 0 || resultVertices[resultVertices.length - 1].v[0] !== pt0[0] || resultVertices[resultVertices.length - 1].v[1] !== pt0[1]) {
+          resultVertices.push({ v: pt0, i: [0, 0], o: [0, 0] });
+        }
+        resultVertices.push({ v: pt1, i: [0, 0], o: [0, 0] });
+      }
+    }
+    cursor = 0;
+  };
+  if (!wraps) {
+    pushRange(startDist, endDist);
+  } else {
+    pushRange(startDist, totalLength);
+    pushRange(0, endDist);
+  }
+  return [{ closed: false, vertices: resultVertices }];
+}
+
+// src/_internal/animation/lottie/paint.ts
+function colorToCss(rgb, opacity01) {
+  var _a, _b, _c;
+  const r = Math.round(((_a = rgb[0]) != null ? _a : 0) * (rgb[0] <= 1 ? 255 : 1));
+  const g = Math.round(((_b = rgb[1]) != null ? _b : 0) * (rgb[1] <= 1 ? 255 : 1));
+  const b = Math.round(((_c = rgb[2]) != null ? _c : 0) * (rgb[2] <= 1 ? 255 : 1));
+  const a = (rgb[3] !== void 0 ? rgb[3] : 1) * opacity01;
+  return `rgba(${clamp255(r)}, ${clamp255(g)}, ${clamp255(b)}, ${clampAlpha(a)})`;
+}
+function clamp255(v) {
+  return Math.max(0, Math.min(255, v));
+}
+function clampAlpha(v) {
+  return Math.max(0, Math.min(1, v));
+}
+function parseGradientStops(g, frame) {
+  var _a, _b, _c, _d;
+  const flat = getAnimatedValue(g.k, frame);
+  const stopCount = g.p;
+  const stops = [];
+  for (let i = 0; i < stopCount; i++) {
+    const base = i * 4;
+    stops.push({
+      offset: (_a = flat[base]) != null ? _a : i / Math.max(1, stopCount - 1),
+      r: ((_b = flat[base + 1]) != null ? _b : 0) * 255,
+      g: ((_c = flat[base + 2]) != null ? _c : 0) * 255,
+      b: ((_d = flat[base + 3]) != null ? _d : 0) * 255,
+      a: 1
+    });
+  }
+  const alphaStart = stopCount * 4;
+  if (flat.length > alphaStart) {
+    const alphaCount = (flat.length - alphaStart) / 2;
+    for (let i = 0; i < alphaCount; i++) {
+      const base = alphaStart + i * 2;
+      const offset = flat[base];
+      const alpha = flat[base + 1];
+      let nearest = stops[0];
+      let nearestDist = Infinity;
+      for (const s of stops) {
+        const dist = Math.abs(s.offset - offset);
+        if (dist < nearestDist) {
+          nearestDist = dist;
+          nearest = s;
+        }
+      }
+      if (nearest) nearest.a = alpha;
+    }
+  }
+  return stops;
+}
+function buildGradient(ctx, item, frame, m, opacity01) {
+  var _a, _b, _c, _d, _e, _f;
+  const start = getAnimatedValue(item.s, frame);
+  const end = getAnimatedValue(item.e, frame);
+  const [sx, sy] = applyToPoint(m, (_a = start[0]) != null ? _a : 0, (_b = start[1]) != null ? _b : 0);
+  const [ex, ey] = applyToPoint(m, (_c = end[0]) != null ? _c : 0, (_d = end[1]) != null ? _d : 0);
+  let gradient;
+  if (item.t === 2) {
+    const radius = Math.hypot(ex - sx, ey - sy) || 1;
+    const hRaw = item.h ? (_e = getAnimatedValue(item.h, frame)[0]) != null ? _e : 0 : 0;
+    const h = Math.max(-0.99, Math.min(0.99, Math.abs(hRaw) > 1 ? hRaw / 100 : hRaw));
+    const aDeg = item.a ? (_f = getAnimatedValue(item.a, frame)[0]) != null ? _f : 0 : 0;
+    if (h !== 0) {
+      const baseAngle = Math.atan2(ey - sy, ex - sx);
+      const angle = baseAngle + aDeg * Math.PI / 180;
+      const hx = sx + Math.cos(angle) * h * radius;
+      const hy = sy + Math.sin(angle) * h * radius;
+      gradient = ctx.createRadialGradient(hx, hy, 0, sx, sy, radius);
+    } else {
+      gradient = ctx.createRadialGradient(sx, sy, 0, sx, sy, radius);
+    }
+  } else {
+    gradient = ctx.createLinearGradient(sx, sy, ex, ey);
+  }
+  const stops = parseGradientStops(item.g, frame);
+  for (const stop of stops) {
+    gradient.addColorStop(
+      Math.max(0, Math.min(1, stop.offset)),
+      `rgba(${clamp255(stop.r)}, ${clamp255(stop.g)}, ${clamp255(stop.b)}, ${clampAlpha(
+        stop.a * opacity01
+      )})`
+    );
+  }
+  return gradient;
+}
+var LINE_CAP = ["butt", "round", "square"];
+var LINE_JOIN = ["miter", "round", "bevel"];
+function applyStrokeStyle(ctx, item, frame, m) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const widthArr = getAnimatedValue(item.w, frame);
+  const scaleFactor = Math.hypot(m[0], m[1]);
+  ctx.lineWidth = Math.max(0, ((_a = widthArr[0]) != null ? _a : 1) * scaleFactor);
+  ctx.lineCap = (_c = LINE_CAP[((_b = item.lc) != null ? _b : 2) - 1]) != null ? _c : "round";
+  ctx.lineJoin = (_e = LINE_JOIN[((_d = item.lj) != null ? _d : 2) - 1]) != null ? _e : "round";
+  ctx.miterLimit = (_f = item.ml) != null ? _f : 4;
+  if (item.d && item.d.length > 0) {
+    const dashArr = [];
+    let dashOffset = 0;
+    for (const d of item.d) {
+      const val = (_g = getAnimatedValue(d.v, frame)[0]) != null ? _g : 0;
+      if (d.n === "o") {
+        dashOffset = val * scaleFactor;
+      } else {
+        dashArr.push(val * scaleFactor);
+      }
+    }
+    ctx.setLineDash(dashArr.length > 0 ? dashArr : []);
+    ctx.lineDashOffset = dashOffset;
+  } else {
+    ctx.setLineDash([]);
+  }
+}
+
+// src/_internal/animation/lottie/shapeGroup.ts
+function computeLocalTransform(t, frame) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  if (!t) return { matrix: identity(), opacity: 1 };
+  let anchor = [0, 0];
+  let position = [0, 0];
+  let scaleVal = [100, 100];
+  let rotationDeg = 0;
+  let skewDeg = 0;
+  let skewAxisDeg = 0;
+  let opacityPct = 100;
+  if (t.a) anchor = getAnimatedValue(t.a, frame);
+  if (t.p) {
+    if (t.p.s && t.p.x && t.p.y) {
+      const px = (_a = getAnimatedValue(t.p.x, frame)[0]) != null ? _a : 0;
+      const py = (_b = getAnimatedValue(t.p.y, frame)[0]) != null ? _b : 0;
+      position = [px, py];
+    } else {
+      position = getAnimatedPosition(t.p, frame);
+    }
+  }
+  if (t.s) scaleVal = getAnimatedValue(t.s, frame);
+  if (t.r) rotationDeg = (_c = getAnimatedValue(t.r, frame)[0]) != null ? _c : 0;
+  if (t.sk) skewDeg = (_d = getAnimatedValue(t.sk, frame)[0]) != null ? _d : 0;
+  if (t.sa) skewAxisDeg = (_e = getAnimatedValue(t.sa, frame)[0]) != null ? _e : 0;
+  if (t.o) opacityPct = (_f = getAnimatedValue(t.o, frame)[0]) != null ? _f : 100;
+  let m = identity();
+  m = translate(m, (_g = position[0]) != null ? _g : 0, (_h = position[1]) != null ? _h : 0);
+  m = rotate(m, (rotationDeg != null ? rotationDeg : 0) * Math.PI / 180);
+  if (skewDeg) m = skew(m, skewDeg, skewAxisDeg);
+  m = scale(m, ((_i = scaleVal[0]) != null ? _i : 100) / 100, ((_j = scaleVal[1]) != null ? _j : 100) / 100);
+  m = translate(m, -((_k = anchor[0]) != null ? _k : 0), -((_l = anchor[1]) != null ? _l : 0));
+  return { matrix: m, opacity: Math.max(0, Math.min(1, opacityPct / 100)) };
+}
+function buildShapePath(item, frame) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+  switch (item.ty) {
+    case "sh": {
+      const sv = getAnimatedShape(item.ks, frame);
+      return shapeValueToBezierPath(sv);
+    }
+    case "rc": {
+      const rc = item;
+      const pos = getAnimatedValue(rc.p, frame);
+      const size = getAnimatedValue(rc.s, frame);
+      const radius = (_a = getAnimatedValue(rc.r, frame)[0]) != null ? _a : 0;
+      return rectToBezierPath((_b = pos[0]) != null ? _b : 0, (_c = pos[1]) != null ? _c : 0, (_d = size[0]) != null ? _d : 0, (_e = size[1]) != null ? _e : 0, radius);
+    }
+    case "el": {
+      const el = item;
+      const pos = getAnimatedValue(el.p, frame);
+      const size = getAnimatedValue(el.s, frame);
+      return ellipseToBezierPath((_f = pos[0]) != null ? _f : 0, (_g = pos[1]) != null ? _g : 0, (_h = size[0]) != null ? _h : 0, (_i = size[1]) != null ? _i : 0);
+    }
+    case "sr": {
+      const sr = item;
+      const pos = getAnimatedValue(sr.p, frame);
+      const outerRadius = (_j = getAnimatedValue(sr.or, frame)[0]) != null ? _j : 0;
+      const innerRadius = sr.ir ? (_k = getAnimatedValue(sr.ir, frame)[0]) != null ? _k : 0 : outerRadius * 0.5;
+      const outerRoundness = (_l = getAnimatedValue(sr.os, frame)[0]) != null ? _l : 0;
+      const innerRoundness = sr.is ? (_m = getAnimatedValue(sr.is, frame)[0]) != null ? _m : 0 : 0;
+      const rotationDeg = (_n = getAnimatedValue(sr.r, frame)[0]) != null ? _n : 0;
+      const points = (_o = getAnimatedValue(sr.pt, frame)[0]) != null ? _o : 5;
+      return starToBezierPath(
+        (_p = pos[0]) != null ? _p : 0,
+        (_q = pos[1]) != null ? _q : 0,
+        points,
+        outerRadius,
+        innerRadius,
+        outerRoundness,
+        innerRoundness,
+        rotationDeg,
+        sr.sy === 2
+      );
+    }
+    default:
+      return null;
+  }
+}
+function tracePathsAsOne(ctx, paths, m) {
+  ctx.beginPath();
+  for (const p of paths) tracePathOnContext(ctx, p, m);
+}
+function paintFill(rc, paths, m, fillStyle, mergeMode, fillRule = "nonzero") {
+  var _a;
+  if (paths.length === 0) return;
+  const rule = mergeMode === 5 ? "evenodd" : fillRule;
+  if (mergeMode === 3 || mergeMode === 4) {
+    const sctx = rc.scratchCtx;
+    sctx.save();
+    sctx.setTransform(1, 0, 0, 1, 0, 0);
+    sctx.clearRect(0, 0, rc.canvasWidth, rc.canvasHeight);
+    sctx.beginPath();
+    tracePathOnContext(sctx, paths[0], m);
+    sctx.fillStyle = fillStyle;
+    sctx.fill(rule);
+    for (let i = 1; i < paths.length; i++) {
+      sctx.globalCompositeOperation = mergeMode === 3 ? "destination-out" : "destination-in";
+      sctx.beginPath();
+      tracePathOnContext(sctx, paths[i], m);
+      sctx.fillStyle = fillStyle;
+      sctx.fill(rule);
+    }
+    sctx.restore();
+    rc.ctx.drawImage(rc.scratchCanvas, 0, 0);
+    return;
+  }
+  const hasPerPathOpacity = paths.some((p) => p.opacity !== void 0 && p.opacity !== 1);
+  if (hasPerPathOpacity) {
+    const baseAlpha = rc.ctx.globalAlpha;
+    rc.ctx.fillStyle = fillStyle;
+    for (const p of paths) {
+      rc.ctx.beginPath();
+      tracePathOnContext(rc.ctx, p, m);
+      rc.ctx.globalAlpha = baseAlpha * ((_a = p.opacity) != null ? _a : 1);
+      rc.ctx.fill(rule);
+    }
+    rc.ctx.globalAlpha = baseAlpha;
+    return;
+  }
+  tracePathsAsOne(rc.ctx, paths, m);
+  rc.ctx.fillStyle = fillStyle;
+  rc.ctx.fill(rule);
+}
+function paintStroke(rc, paths, m, strokeStyle) {
+  var _a;
+  if (paths.length === 0) return;
+  const hasPerPathOpacity = paths.some((p) => p.opacity !== void 0 && p.opacity !== 1);
+  if (hasPerPathOpacity) {
+    const baseAlpha = rc.ctx.globalAlpha;
+    rc.ctx.strokeStyle = strokeStyle;
+    for (const p of paths) {
+      rc.ctx.beginPath();
+      tracePathOnContext(rc.ctx, p, m);
+      rc.ctx.globalAlpha = baseAlpha * ((_a = p.opacity) != null ? _a : 1);
+      rc.ctx.stroke();
+    }
+    rc.ctx.globalAlpha = baseAlpha;
+    return;
+  }
+  tracePathsAsOne(rc.ctx, paths, m);
+  rc.ctx.strokeStyle = strokeStyle;
+  rc.ctx.stroke();
+}
+function renderShapeItems(rc, items, parentMatrix, parentOpacity) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  const trItem = items.find((i) => i.ty === "tr");
+  const { matrix: groupMatrix, opacity: groupOpacity } = computeLocalTransform(
+    trItem,
+    rc.frame
+  );
+  const localMatrix = multiply(parentMatrix, groupMatrix);
+  const localOpacity = parentOpacity * groupOpacity;
+  let currentPaths = [];
+  let mergeMode = null;
+  const drawOps = [];
+  for (let idx = 0; idx < items.length; idx++) {
+    const item = items[idx];
+    if (item.hd) continue;
+    switch (item.ty) {
+      case "tr":
+        continue;
+      case "gr": {
+        const group = item;
+        drawOps.push(() => renderShapeItems(rc, group.it, localMatrix, localOpacity));
+        break;
+      }
+      case "sh":
+      case "rc":
+      case "el":
+      case "sr": {
+        const path = buildShapePath(item, rc.frame);
+        if (path) currentPaths = [...currentPaths, path];
+        break;
+      }
+      case "tm": {
+        const tm = item;
+        const s = (_a = getAnimatedValue(tm.s, rc.frame)[0]) != null ? _a : 0;
+        const e = (_b = getAnimatedValue(tm.e, rc.frame)[0]) != null ? _b : 100;
+        const o = (_c = getAnimatedValue(tm.o, rc.frame)[0]) != null ? _c : 0;
+        currentPaths = trimPaths(currentPaths, s, e, o, (_d = tm.m) != null ? _d : 1);
+        break;
+      }
+      case "rp": {
+        const rp = item;
+        const copies = Math.max(0, Math.round((_e = getAnimatedValue(rp.c, rc.frame)[0]) != null ? _e : 0));
+        const offset = (_f = getAnimatedValue(rp.o, rc.frame)[0]) != null ? _f : 0;
+        const rTr = rp.tr;
+        const repPos = getAnimatedValue(rTr.p, rc.frame);
+        getAnimatedValue(rTr.a, rc.frame);
+        const repScale = getAnimatedValue(rTr.s, rc.frame);
+        const repRotation = (_g = getAnimatedValue(rTr.r, rc.frame)[0]) != null ? _g : 0;
+        const startOpacityPct = rTr.so ? (_h = getAnimatedValue(rTr.so, rc.frame)[0]) != null ? _h : 100 : 100;
+        const endOpacityPct = rTr.eo ? (_i = getAnimatedValue(rTr.eo, rc.frame)[0]) != null ? _i : 100 : 100;
+        const basePaths = currentPaths;
+        const repeated = [];
+        for (let c = 0; c < copies; c++) {
+          const n = c + offset;
+          const copyOpacity = copies > 1 ? (startOpacityPct + (endOpacityPct - startOpacityPct) * c / (copies - 1)) / 100 : startOpacityPct / 100;
+          let compound = identity();
+          for (let k = 0; k < Math.abs(n); k++) {
+            compound = translate(compound, (_j = repPos[0]) != null ? _j : 0, (_k = repPos[1]) != null ? _k : 0);
+            compound = rotate(compound, (repRotation != null ? repRotation : 0) * Math.PI / 180);
+            compound = scale(compound, ((_l = repScale[0]) != null ? _l : 100) / 100, ((_m = repScale[1]) != null ? _m : 100) / 100);
+          }
+          for (const p of basePaths) {
+            repeated.push({
+              closed: p.closed,
+              opacity: copyOpacity,
+              vertices: p.vertices.map((v) => {
+                const [vx, vy] = applyMat(compound, v.v[0], v.v[1]);
+                const [ix, iy] = applyMatDelta(compound, v.i[0], v.i[1]);
+                const [ox, oy] = applyMatDelta(compound, v.o[0], v.o[1]);
+                return { v: [vx, vy], i: [ix, iy], o: [ox, oy] };
+              })
+            });
+          }
+        }
+        currentPaths = repeated;
+        break;
+      }
+      case "mm": {
+        mergeMode = (_n = item.mm) != null ? _n : 1;
+        break;
+      }
+      case "fl": {
+        const fl = item;
+        const paths = currentPaths;
+        const mm = mergeMode;
+        const fillRule = fl.r === 2 ? "evenodd" : "nonzero";
+        drawOps.push(() => {
+          var _a2;
+          const color = getAnimatedValue(fl.c, rc.frame);
+          const opacity = ((_a2 = getAnimatedValue(fl.o, rc.frame)[0]) != null ? _a2 : 100) / 100;
+          const css = colorToCss(color, opacity * localOpacity);
+          paintFill(rc, paths, localMatrix, css, mm, fillRule);
+        });
+        break;
+      }
+      case "gf": {
+        const gf = item;
+        const paths = currentPaths;
+        const mm = mergeMode;
+        const fillRule = gf.r === 2 ? "evenodd" : "nonzero";
+        drawOps.push(() => {
+          var _a2;
+          const opacity = ((_a2 = getAnimatedValue(gf.o, rc.frame)[0]) != null ? _a2 : 100) / 100;
+          const gradient = buildGradient(rc.ctx, gf, rc.frame, localMatrix, opacity * localOpacity);
+          paintFill(rc, paths, localMatrix, gradient, mm, fillRule);
+        });
+        break;
+      }
+      case "st": {
+        const st = item;
+        const paths = currentPaths;
+        drawOps.push(() => {
+          var _a2;
+          const color = getAnimatedValue(st.c, rc.frame);
+          const opacity = ((_a2 = getAnimatedValue(st.o, rc.frame)[0]) != null ? _a2 : 100) / 100;
+          const css = colorToCss(color, opacity * localOpacity);
+          applyStrokeStyle(rc.ctx, st, rc.frame, localMatrix);
+          paintStroke(rc, paths, localMatrix, css);
+        });
+        break;
+      }
+      case "gs": {
+        const gs = item;
+        const paths = currentPaths;
+        drawOps.push(() => {
+          var _a2;
+          const opacity = ((_a2 = getAnimatedValue(gs.o, rc.frame)[0]) != null ? _a2 : 100) / 100;
+          const gradient = buildGradient(rc.ctx, gs, rc.frame, localMatrix, opacity * localOpacity);
+          applyStrokeStyle(rc.ctx, gs, rc.frame, localMatrix);
+          paintStroke(rc, paths, localMatrix, gradient);
+        });
+        break;
+      }
+    }
+  }
+  for (let i = drawOps.length - 1; i >= 0; i--) {
+    drawOps[i]();
+  }
+}
+function applyMat(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function applyMatDelta(m, x, y) {
+  return [m[0] * x + m[2] * y, m[1] * x + m[3] * y];
+}
+
+// src/_internal/animation/lottie/engine.ts
+var BLEND_MODES = {
+  0: "source-over",
+  1: "multiply",
+  2: "screen",
+  3: "overlay",
+  4: "darken",
+  5: "lighten",
+  6: "color-dodge",
+  7: "color-burn",
+  8: "hard-light",
+  9: "soft-light",
+  10: "difference",
+  11: "exclusion",
+  12: "hue",
+  13: "saturation",
+  14: "color",
+  15: "luminosity"
+};
+function makeCanvas(w, h) {
+  let canvas;
+  if (typeof OffscreenCanvas !== "undefined") {
+    canvas = new OffscreenCanvas(Math.max(1, w), Math.max(1, h));
+  } else {
+    canvas = document.createElement("canvas");
+    canvas.width = Math.max(1, w);
+    canvas.height = Math.max(1, h);
+  }
+  const ctx = canvas.getContext("2d");
+  return { canvas, ctx };
+}
+function lumaToAlphaMask(source, w, h) {
+  const { canvas, ctx } = makeCanvas(w, h);
+  ctx.drawImage(source, 0, 0);
+  const img = ctx.getImageData(0, 0, Math.max(1, w), Math.max(1, h));
+  const d = img.data;
+  for (let i = 0; i < d.length; i += 4) {
+    const luma = 0.2126 * d[i] + 0.7152 * d[i + 1] + 0.0722 * d[i + 2];
+    d[i + 3] = Math.round(luma / 255 * d[i + 3]);
+  }
+  ctx.putImageData(img, 0, 0);
+  return canvas;
+}
+function getLayerMatrix(layer, layersByInd, frame, cache) {
+  var _a;
+  const ind = (_a = layer.ind) != null ? _a : -1;
+  const cached = cache.get(ind);
+  if (cached) return cached;
+  const { matrix: own } = computeLocalTransform(layer.ks, frame);
+  let result = own;
+  if (layer.parent != null) {
+    const parent = layersByInd.get(layer.parent);
+    if (parent && parent !== layer) {
+      const parentMatrix = getLayerMatrix(parent, layersByInd, frame, cache);
+      result = multiply(parentMatrix, own);
+    }
+  }
+  if (ind >= 0) cache.set(ind, result);
+  return result;
+}
+function applyMasks(ctx, layer, matrix, frame, canvasWidth, canvasHeight) {
+  var _a;
+  const masks = layer.masksProperties;
+  if (!masks || masks.length === 0) return false;
+  const active = masks.filter((m) => {
+    var _a2;
+    return ((_a2 = m.mode) != null ? _a2 : "a") !== "n";
+  });
+  if (active.length === 0) return false;
+  let clipped = false;
+  let additiveBatch = [];
+  const flushAdditive = () => {
+    if (additiveBatch.length === 0) return;
+    ctx.beginPath();
+    for (const mask of additiveBatch) {
+      const sv = getAnimatedShape(mask.pt, frame);
+      tracePathOnContext(ctx, shapeValueToBezierPath(sv), matrix);
+    }
+    ctx.clip("nonzero");
+    clipped = true;
+    additiveBatch = [];
+  };
+  for (const mask of active) {
+    const mode = (_a = mask.mode) != null ? _a : "a";
+    const isAdditive = (mode === "a" || mode === "l") && !mask.inv;
+    if (isAdditive) {
+      additiveBatch.push(mask);
+      continue;
+    }
+    flushAdditive();
+    const sv = getAnimatedShape(mask.pt, frame);
+    const path = shapeValueToBezierPath(sv);
+    const keepOutside = mode === "s" || mask.inv;
+    ctx.beginPath();
+    if (keepOutside) {
+      ctx.rect(0, 0, canvasWidth, canvasHeight);
+      tracePathOnContext(ctx, path, matrix);
+      ctx.clip("evenodd");
+    } else {
+      tracePathOnContext(ctx, path, matrix);
+      ctx.clip("nonzero");
+    }
+    clipped = true;
+  }
+  flushAdditive();
+  return clipped;
+}
+function renderSolidLayer(ctx, layer, matrix) {
+  var _a, _b, _c;
+  const w = (_a = layer.sw) != null ? _a : 0;
+  const h = (_b = layer.sh) != null ? _b : 0;
+  ctx.save();
+  ctx.beginPath();
+  const p0 = applyPoint(matrix, 0, 0);
+  const p1 = applyPoint(matrix, w, 0);
+  const p2 = applyPoint(matrix, w, h);
+  const p3 = applyPoint(matrix, 0, h);
+  ctx.moveTo(p0[0], p0[1]);
+  ctx.lineTo(p1[0], p1[1]);
+  ctx.lineTo(p2[0], p2[1]);
+  ctx.lineTo(p3[0], p3[1]);
+  ctx.closePath();
+  ctx.fillStyle = (_c = layer.sc) != null ? _c : "#000000";
+  ctx.fill();
+  ctx.restore();
+}
+function applyPoint(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function resolveImageSrc(asset) {
+  var _a, _b;
+  if (asset.e === 1) {
+    if (!asset.p) return null;
+    if (asset.p.startsWith("data:")) return asset.p;
+    return `data:image/png;base64,${asset.p}`;
+  }
+  if (asset.u) return asset.u + ((_a = asset.p) != null ? _a : "");
+  return (_b = asset.p) != null ? _b : null;
+}
+function renderImageLayer(ctx, asset, matrix, opts) {
+  var _a, _b;
+  const src = resolveImageSrc(asset);
+  if (!src) return;
+  let img = opts.imageCache.get(asset.id);
+  if (!img) {
+    img = new Image();
+    img.src = src;
+    opts.imageCache.set(asset.id, img);
+    img.addEventListener("load", () => {
+      var _a2;
+      return (_a2 = opts.onAssetLoaded) == null ? void 0 : _a2.call(opts);
+    });
+    return;
+  }
+  if (!img.complete || img.naturalWidth === 0) return;
+  const w = (_a = asset.w) != null ? _a : img.naturalWidth;
+  const h = (_b = asset.h) != null ? _b : img.naturalHeight;
+  ctx.save();
+  ctx.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+  ctx.drawImage(img, 0, 0, w, h);
+  ctx.restore();
+}
+function renderLayers(targetCtx, layers, assetsById, parentMatrix, parentOpacity, docFrame, opts) {
+  var _a, _b, _c, _d;
+  const layersByInd = /* @__PURE__ */ new Map();
+  for (const l of layers) {
+    if (l.ind != null) layersByInd.set(l.ind, l);
+  }
+  const matrixCache = /* @__PURE__ */ new Map();
+  const isLayerActive = (layer) => {
+    var _a2, _b2;
+    if (layer.hd) return false;
+    const startFrame = (_a2 = layer.ip) != null ? _a2 : 0;
+    const endFrame = (_b2 = layer.op) != null ? _b2 : Infinity;
+    return docFrame >= startFrame && docFrame < endFrame;
+  };
+  const renderMatteSource = (matteLayer) => {
+    if (!isLayerActive(matteLayer)) return null;
+    const ownMatrix = getLayerMatrix(matteLayer, layersByInd, docFrame, matrixCache);
+    const matrix = multiply(parentMatrix, ownMatrix);
+    const { opacity: ownOpacity } = computeLocalTransform(matteLayer.ks, docFrame);
+    const opacity = parentOpacity * ownOpacity;
+    const scratch = makeCanvas(opts.canvasWidth, opts.canvasHeight);
+    scratch.ctx.save();
+    scratch.ctx.globalAlpha = opacity;
+    applyMasks(scratch.ctx, matteLayer, matrix, docFrame, opts.canvasWidth, opts.canvasHeight);
+    renderSingleLayer(scratch.ctx, matteLayer, assetsById, matrix, 1, docFrame, opts);
+    scratch.ctx.restore();
+    return scratch;
+  };
+  for (let idx = layers.length - 1; idx >= 0; idx--) {
+    const layer = layers[idx];
+    if (layer.hd) continue;
+    if (!isLayerActive(layer)) continue;
+    if (layer.td === 1) continue;
+    const ownMatrix = getLayerMatrix(layer, layersByInd, docFrame, matrixCache);
+    const matrix = multiply(parentMatrix, ownMatrix);
+    const { opacity: ownOpacity } = computeLocalTransform(layer.ks, docFrame);
+    const opacity = parentOpacity * ownOpacity;
+    const matteLayer = layer.tt && idx > 0 ? layers[idx - 1] : null;
+    const pendingMatte = matteLayer && matteLayer.td === 1 ? renderMatteSource(matteLayer) : null;
+    const needsMatte = !!layer.tt && !!pendingMatte;
+    let drawCtx;
+    let scratch = null;
+    if (needsMatte) {
+      scratch = makeCanvas(opts.canvasWidth, opts.canvasHeight);
+      drawCtx = scratch.ctx;
+    } else {
+      drawCtx = targetCtx;
+    }
+    drawCtx.save();
+    if (drawCtx === targetCtx) {
+      drawCtx.globalAlpha = opacity;
+      drawCtx.globalCompositeOperation = (_b = BLEND_MODES[(_a = layer.bm) != null ? _a : 0]) != null ? _b : "source-over";
+    } else {
+      drawCtx.globalAlpha = opacity;
+    }
+    applyMasks(drawCtx, layer, matrix, docFrame, opts.canvasWidth, opts.canvasHeight);
+    renderSingleLayer(drawCtx, layer, assetsById, matrix, 1, docFrame, opts);
+    drawCtx.restore();
+    if (needsMatte && scratch && pendingMatte) {
+      const tt = layer.tt;
+      const isLuma = tt === 3 || tt === 4;
+      const matteSource = isLuma ? lumaToAlphaMask(pendingMatte.canvas, opts.canvasWidth, opts.canvasHeight) : pendingMatte.canvas;
+      scratch.ctx.save();
+      scratch.ctx.globalCompositeOperation = tt === 2 || tt === 4 ? "destination-out" : "destination-in";
+      scratch.ctx.setTransform(1, 0, 0, 1, 0, 0);
+      scratch.ctx.drawImage(matteSource, 0, 0);
+      scratch.ctx.restore();
+      targetCtx.save();
+      targetCtx.globalCompositeOperation = (_d = BLEND_MODES[(_c = layer.bm) != null ? _c : 0]) != null ? _d : "source-over";
+      targetCtx.drawImage(scratch.canvas, 0, 0);
+      targetCtx.restore();
+    }
+  }
+}
+function renderSingleLayer(ctx, layer, assetsById, matrix, opacity, docFrame, opts) {
+  var _a, _b, _c;
+  switch (layer.ty) {
+    case 4: {
+      if (!layer.shapes) return;
+      const scratch = opts.getShapeScratch ? opts.getShapeScratch(opts.canvasWidth, opts.canvasHeight) : makeCanvas(opts.canvasWidth, opts.canvasHeight);
+      const rc = {
+        ctx,
+        frame: docFrame,
+        canvasWidth: opts.canvasWidth,
+        canvasHeight: opts.canvasHeight,
+        scratchCanvas: scratch.canvas,
+        scratchCtx: scratch.ctx
+      };
+      renderShapeItems(rc, layer.shapes, matrix, opacity);
+      break;
+    }
+    case 1: {
+      renderSolidLayer(ctx, layer, matrix);
+      break;
+    }
+    case 0: {
+      const asset = layer.refId ? assetsById.get(layer.refId) : void 0;
+      if (!asset || !asset.layers) return;
+      const stretch = (_a = layer.sr) != null ? _a : 1;
+      const innerFrame = layer.tm ? (_b = getAnimatedValue(layer.tm, docFrame)[0]) != null ? _b : docFrame : (docFrame - ((_c = layer.st) != null ? _c : 0)) / stretch;
+      renderLayers(ctx, asset.layers, assetsById, matrix, opacity, innerFrame, opts);
+      break;
+    }
+    case 2: {
+      const asset = layer.refId ? assetsById.get(layer.refId) : void 0;
+      if (asset) renderImageLayer(ctx, asset, matrix, opts);
+      break;
+    }
+    case 3:
+      break;
+    case 5:
+      opts.warnOnce(
+        "text-layer",
+        "react-tgs-player: text layers are not rendered by this zero-dependency engine (not used by valid .tgs stickers)."
+      );
+      break;
+  }
+}
+function buildAssetsMap(doc) {
+  var _a;
+  const map = /* @__PURE__ */ new Map();
+  for (const asset of (_a = doc.assets) != null ? _a : []) {
+    map.set(asset.id, asset);
+  }
+  return map;
+}
+function renderDocumentFrame(doc, frame, opts) {
+  const assetsById = buildAssetsMap(doc);
+  opts.ctx.save();
+  opts.ctx.clearRect(0, 0, opts.canvasWidth, opts.canvasHeight);
+  const scaleX = opts.canvasWidth / doc.w;
+  const scaleY = opts.canvasHeight / doc.h;
+  const base = [scaleX, 0, 0, scaleY, 0, 0];
+  renderLayers(opts.ctx, doc.layers, assetsById, base, 1, frame, opts);
+  opts.ctx.restore();
+}
+
+// src/_internal/animation/lottie/animation.ts
+var memoryImageCache = /* @__PURE__ */ new Map();
+var imageCache = {
+  get: (k) => memoryImageCache.get(k),
+  set: (k, v) => void memoryImageCache.set(k, v)
+};
+var warnedKeys = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (warnedKeys.has(key)) return;
+  warnedKeys.add(key);
+  console.warn(message);
+}
+var LottieAnimationController = class {
+  constructor(options) {
+    this.doc = null;
+    this.state = "loading";
+    this.currentFrame = 0;
+    this.direction = 1;
+    this.speed = 1;
+    this.loop = false;
+    this.mode = "normal";
+    this.loopsCompleted = 0;
+    this.segment = null;
+    this.rafHandle = null;
+    this.lastTs = null;
+    this.shapeScratch = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    var _a, _b, _c, _d, _e;
+    this.canvas = options.canvas;
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx) throw new Error("react-tgs-player: could not acquire a 2D canvas context");
+    this.ctx = ctx;
+    this.direction = (_a = options.direction) != null ? _a : 1;
+    this.speed = (_b = options.speed) != null ? _b : 1;
+    this.loop = (_c = options.loop) != null ? _c : false;
+    this.mode = (_d = options.mode) != null ? _d : "normal";
+    this.segment = (_e = options.segments) != null ? _e : null;
+  }
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return () => set.delete(fn);
+  }
+  emit(event, detail) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const fn of set) fn(detail);
+  }
+  setDocument(doc) {
+    this.doc = doc;
+    const [inF, outF] = this.getBounds();
+    this.currentFrame = this.direction === -1 ? outF : inF;
+    this.state = "stopped";
+    this.emit("ready");
+    this.renderCurrentFrame();
+  }
+  setError(errors) {
+    this.state = "error";
+    this.emit("error", { errors });
+  }
+  getBounds() {
+    if (!this.doc) return [0, 0];
+    if (this.segment) return this.segment;
+    return [this.doc.ip, this.doc.op];
+  }
+  resize(width, height) {
+    this.canvas.width = width;
+    this.canvas.height = height;
+    this.renderCurrentFrame();
+  }
+  setSegment(segment) {
+    this.segment = segment;
+    const [inF, outF] = this.getBounds();
+    this.currentFrame = Math.min(Math.max(this.currentFrame, inF), outF);
+    this.renderCurrentFrame();
+  }
+  play() {
+    if (!this.doc) return;
+    if (this.state === "destroyed") return;
+    this.state = "playing";
+    this.emit("play");
+    this.startLoop();
+  }
+  pause() {
+    this.state = "paused";
+    this.stopLoop();
+    this.emit("pause");
+  }
+  freeze() {
+    if (this.state !== "playing") return;
+    this.state = "frozen";
+    this.stopLoop();
+  }
+  unfreeze() {
+    if (this.state !== "frozen") return;
+    this.play();
+  }
+  stop() {
+    if (!this.doc) return;
+    this.state = "stopped";
+    this.stopLoop();
+    const [inF, outF] = this.getBounds();
+    this.currentFrame = this.direction === -1 ? outF : inF;
+    this.loopsCompleted = 0;
+    this.renderCurrentFrame();
+    this.emit("stop");
+  }
+  destroy() {
+    this.stopLoop();
+    this.state = "destroyed";
+    this.doc = null;
+    this.shapeScratch = null;
+    this.listeners.clear();
+  }
+  togglePlay() {
+    this.state === "playing" ? this.pause() : this.play();
+  }
+  setSpeed(speed) {
+    this.speed = speed;
+  }
+  setDirection(direction) {
+    this.direction = direction;
+  }
+  setLoop(loop) {
+    this.loop = loop;
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
+  getCurrentFrame() {
+    return this.currentFrame;
+  }
+  getState() {
+    return this.state;
+  }
+  getTotalFrames() {
+    const [inF, outF] = this.getBounds();
+    return outF - inF;
+  }
+  seek(value) {
+    if (!this.doc) return;
+    const [inF, outF] = this.getBounds();
+    let frame;
+    if (typeof value === "string" && value.trim().endsWith("%")) {
+      const pct = parseFloat(value) / 100;
+      frame = inF + (outF - inF) * pct;
+    } else {
+      frame = Number(value);
+    }
+    frame = Math.min(Math.max(frame, inF), outF);
+    this.currentFrame = frame;
+    this.renderCurrentFrame();
+    this.emitFrameEvent();
+    if (this.state !== "playing") ;
+  }
+  startLoop() {
+    if (this.rafHandle != null) return;
+    this.lastTs = null;
+    const tick = (ts) => {
+      if (this.state !== "playing") {
+        this.rafHandle = null;
+        return;
+      }
+      if (this.lastTs == null) this.lastTs = ts;
+      const dtMs = ts - this.lastTs;
+      this.lastTs = ts;
+      this.advance(dtMs);
+      this.rafHandle = requestAnimationFrame(tick);
+    };
+    this.rafHandle = requestAnimationFrame(tick);
+  }
+  stopLoop() {
+    if (this.rafHandle != null) {
+      cancelAnimationFrame(this.rafHandle);
+      this.rafHandle = null;
+    }
+    this.lastTs = null;
+  }
+  advance(dtMs) {
+    if (!this.doc) return;
+    const [inF, outF] = this.getBounds();
+    const fps = this.doc.fr || 30;
+    const framesDelta = dtMs / 1e3 * fps * this.speed * this.direction;
+    let next = this.currentFrame + framesDelta;
+    const span = Math.max(1, outF - inF);
+    const loopLimit = this.loop === true ? Infinity : this.loop === false ? 1 : Math.max(1, this.loop);
+    if (this.mode === "bounce") {
+      if (next >= outF) {
+        if (this.direction === 1 && (this.loop === true || this.loopsCompleted < loopLimit - 0.5)) {
+          this.direction = -1;
+          next = outF - (next - outF);
+          this.loopsCompleted += 0.5;
+          this.emit("loop");
+        } else {
+          next = outF;
+          this.finishPlayback();
+        }
+      } else if (next <= inF) {
+        if (this.direction === -1 && (this.loop === true || this.loopsCompleted < loopLimit - 0.5)) {
+          this.direction = 1;
+          next = inF + (inF - next);
+          this.loopsCompleted += 0.5;
+          this.emit("loop");
+        } else {
+          next = inF;
+          this.finishPlayback();
+        }
+      }
+    } else {
+      if (next >= outF && this.direction === 1) {
+        if (this.loop === true || this.loopsCompleted < loopLimit - 1) {
+          next = inF + (next - outF) % span;
+          this.loopsCompleted += 1;
+          this.emit("loop");
+        } else {
+          next = outF;
+          this.finishPlayback();
+        }
+      } else if (next <= inF && this.direction === -1) {
+        if (this.loop === true || this.loopsCompleted < loopLimit - 1) {
+          next = outF - (inF - next) % span;
+          this.loopsCompleted += 1;
+          this.emit("loop");
+        } else {
+          next = inF;
+          this.finishPlayback();
+        }
+      }
+    }
+    this.currentFrame = next;
+    this.renderCurrentFrame();
+    this.emitFrameEvent();
+  }
+  finishPlayback() {
+    this.state = "paused";
+    this.stopLoop();
+    this.emit("complete");
+  }
+  emitFrameEvent() {
+    const [inF, outF] = this.getBounds();
+    const span = Math.max(1, outF - inF);
+    this.emit("frame", {
+      frame: this.currentFrame,
+      progress: (this.currentFrame - inF) / span
+    });
+  }
+  getShapeScratch(w, h) {
+    const cur = this.shapeScratch;
+    if (cur && cur.canvas.width === Math.max(1, w) && cur.canvas.height === Math.max(1, h)) {
+      return cur;
+    }
+    let canvas;
+    if (typeof OffscreenCanvas !== "undefined") {
+      canvas = new OffscreenCanvas(Math.max(1, w), Math.max(1, h));
+    } else {
+      canvas = document.createElement("canvas");
+      canvas.width = Math.max(1, w);
+      canvas.height = Math.max(1, h);
+    }
+    const ctx = canvas.getContext("2d");
+    this.shapeScratch = { canvas, ctx };
+    return this.shapeScratch;
+  }
+  renderCurrentFrame() {
+    if (!this.doc) return;
+    const opts = {
+      ctx: this.ctx,
+      canvasWidth: this.canvas.width,
+      canvasHeight: this.canvas.height,
+      imageCache,
+      onAssetLoaded: () => this.renderCurrentFrame(),
+      warnOnce,
+      getShapeScratch: (w, h) => this.getShapeScratch(w, h)
+    };
+    try {
+      renderDocumentFrame(this.doc, this.currentFrame, opts);
+    } catch (err) {
+      this.setError([err.message]);
+    }
+  }
+};
+
+// src/_internal/animation/inflate/deflate.ts
+var ByteSink = class {
+  constructor(initialSize = 1 << 16) {
+    this.len = 0;
+    this.buf = new Uint8Array(initialSize);
+  }
+  ensure(extra) {
+    if (this.len + extra <= this.buf.length) return;
+    let newSize = this.buf.length * 2;
+    while (newSize < this.len + extra) newSize *= 2;
+    const next = new Uint8Array(newSize);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+  }
+  pushByte(b) {
+    this.ensure(1);
+    this.buf[this.len++] = b;
+  }
+  pushBytes(src, start, count) {
+    this.ensure(count);
+    this.buf.set(src.subarray(start, start + count), this.len);
+    this.len += count;
+  }
+  copyBack(distance, length) {
+    this.ensure(length);
+    let srcPos = this.len - distance;
+    for (let i = 0; i < length; i++) {
+      this.buf[this.len + i] = this.buf[srcPos + i];
+    }
+    this.len += length;
+  }
+  toUint8Array() {
+    return this.buf.subarray(0, this.len);
+  }
+};
+var BitReader = class {
+  constructor(data) {
+    this.pos = 0;
+    this.bitBuf = 0;
+    this.bitCount = 0;
+    this.data = data;
+  }
+  get bytePos() {
+    return this.pos;
+  }
+  hasMore() {
+    return this.pos < this.data.length || this.bitCount > 0;
+  }
+  readBits(n) {
+    while (this.bitCount < n) {
+      if (this.pos >= this.data.length) {
+        this.bitBuf |= 0 << this.bitCount;
+        this.bitCount += 8;
+        this.pos++;
+        continue;
+      }
+      this.bitBuf |= this.data[this.pos++] << this.bitCount;
+      this.bitCount += 8;
+    }
+    const value = this.bitBuf & (1 << n) - 1;
+    this.bitBuf >>>= n;
+    this.bitCount -= n;
+    return value;
+  }
+  alignToByte() {
+    this.bitBuf = 0;
+    this.bitCount = 0;
+  }
+  readAlignedByte() {
+    return this.data[this.pos++];
+  }
+};
+var HuffmanTree = class {
+  constructor(codeLengths) {
+    this.codesByLength = /* @__PURE__ */ new Map();
+    let maxLen = 0;
+    for (const l of codeLengths) if (l > maxLen) maxLen = l;
+    this.maxLen = maxLen;
+    if (maxLen === 0) return;
+    const blCount = new Array(maxLen + 1).fill(0);
+    for (const l of codeLengths) if (l > 0) blCount[l]++;
+    const nextCode = new Array(maxLen + 1).fill(0);
+    let code = 0;
+    for (let bits = 1; bits <= maxLen; bits++) {
+      code = code + blCount[bits - 1] << 1;
+      nextCode[bits] = code;
+    }
+    for (let sym = 0; sym < codeLengths.length; sym++) {
+      const len = codeLengths[sym];
+      if (len === 0) continue;
+      const c = nextCode[len]++;
+      let map = this.codesByLength.get(len);
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        this.codesByLength.set(len, map);
+      }
+      map.set(c, sym);
+    }
+  }
+  decode(reader) {
+    let code = 0;
+    for (let len = 1; len <= this.maxLen; len++) {
+      code = code << 1 | reader.readBits(1);
+      const map = this.codesByLength.get(len);
+      if (map && map.has(code)) {
+        return map.get(code);
+      }
+    }
+    throw new Error("Invalid Huffman code in DEFLATE stream");
+  }
+};
+var LENGTH_BASE = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+];
+var LENGTH_EXTRA_BITS = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+];
+var DIST_BASE = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+];
+var DIST_EXTRA_BITS = [
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+];
+var CODE_LENGTH_ORDER = [
+  16,
+  17,
+  18,
+  0,
+  8,
+  7,
+  9,
+  6,
+  10,
+  5,
+  11,
+  4,
+  12,
+  3,
+  13,
+  2,
+  14,
+  1,
+  15
+];
+function buildFixedLiteralLengths() {
+  const lengths = new Array(288);
+  for (let i = 0; i <= 143; i++) lengths[i] = 8;
+  for (let i = 144; i <= 255; i++) lengths[i] = 9;
+  for (let i = 256; i <= 279; i++) lengths[i] = 7;
+  for (let i = 280; i <= 287; i++) lengths[i] = 8;
+  return lengths;
+}
+function buildFixedDistLengths() {
+  return new Array(30).fill(5);
+}
+function inflateBlock(reader, sink, litTree, distTree) {
+  for (; ; ) {
+    const sym = litTree.decode(reader);
+    if (sym < 256) {
+      sink.pushByte(sym);
+      continue;
+    }
+    if (sym === 256) {
+      return;
+    }
+    const lengthIndex = sym - 257;
+    if (lengthIndex >= LENGTH_BASE.length) {
+      throw new Error("Invalid length code in DEFLATE stream");
+    }
+    const length = LENGTH_BASE[lengthIndex] + reader.readBits(LENGTH_EXTRA_BITS[lengthIndex]);
+    const distSym = distTree.decode(reader);
+    if (distSym >= DIST_BASE.length) {
+      throw new Error("Invalid distance code in DEFLATE stream");
+    }
+    const distance = DIST_BASE[distSym] + reader.readBits(DIST_EXTRA_BITS[distSym]);
+    sink.copyBack(distance, length);
+  }
+}
+function inflateDynamicBlock(reader, sink) {
+  var _a;
+  const hlit = reader.readBits(5) + 257;
+  const hdist = reader.readBits(5) + 1;
+  const hclen = reader.readBits(4) + 4;
+  const codeLengthLengths = new Array(19).fill(0);
+  for (let i = 0; i < hclen; i++) {
+    codeLengthLengths[CODE_LENGTH_ORDER[i]] = reader.readBits(3);
+  }
+  const codeLengthTree = new HuffmanTree(codeLengthLengths);
+  const allLengths = [];
+  while (allLengths.length < hlit + hdist) {
+    const sym = codeLengthTree.decode(reader);
+    if (sym <= 15) {
+      allLengths.push(sym);
+    } else if (sym === 16) {
+      const repeat = reader.readBits(2) + 3;
+      const prev = (_a = allLengths[allLengths.length - 1]) != null ? _a : 0;
+      for (let i = 0; i < repeat; i++) allLengths.push(prev);
+    } else if (sym === 17) {
+      const repeat = reader.readBits(3) + 3;
+      for (let i = 0; i < repeat; i++) allLengths.push(0);
+    } else if (sym === 18) {
+      const repeat = reader.readBits(7) + 11;
+      for (let i = 0; i < repeat; i++) allLengths.push(0);
+    } else {
+      throw new Error("Invalid code length symbol in DEFLATE stream");
+    }
+  }
+  const litLengths = allLengths.slice(0, hlit);
+  const distLengths = allLengths.slice(hlit, hlit + hdist);
+  const litTree = new HuffmanTree(litLengths);
+  const distTree = new HuffmanTree(distLengths);
+  inflateBlock(reader, sink, litTree, distTree);
+}
+function inflateRaw(data) {
+  const reader = new BitReader(data);
+  const sink = new ByteSink(Math.max(1 << 16, data.length * 4));
+  let fixedLitTree = null;
+  let fixedDistTree = null;
+  for (; ; ) {
+    const bfinal = reader.readBits(1);
+    const btype = reader.readBits(2);
+    if (btype === 0) {
+      reader.alignToByte();
+      const len = reader.readAlignedByte() | reader.readAlignedByte() << 8;
+      reader.readAlignedByte();
+      reader.readAlignedByte();
+      for (let i = 0; i < len; i++) {
+        sink.pushByte(reader.readAlignedByte());
+      }
+    } else if (btype === 1) {
+      if (!fixedLitTree) {
+        fixedLitTree = new HuffmanTree(buildFixedLiteralLengths());
+        fixedDistTree = new HuffmanTree(buildFixedDistLengths());
+      }
+      inflateBlock(reader, sink, fixedLitTree, fixedDistTree);
+    } else if (btype === 2) {
+      inflateDynamicBlock(reader, sink);
+    } else {
+      throw new Error("Invalid DEFLATE block type");
+    }
+    if (bfinal === 1) break;
+    if (!reader.hasMore()) break;
+  }
+  return sink.toUint8Array();
+}
+
+// src/_internal/animation/inflate/gunzip.ts
+var GZIP_MAGIC_0 = 31;
+var GZIP_MAGIC_1 = 139;
+var FLAG_FHCRC = 2;
+var FLAG_FEXTRA = 4;
+var FLAG_FNAME = 8;
+var FLAG_FCOMMENT = 16;
+function isGzip(data) {
+  return data.length > 2 && data[0] === GZIP_MAGIC_0 && data[1] === GZIP_MAGIC_1;
+}
+function gunzip(data) {
+  if (!isGzip(data)) {
+    throw new Error("Not a valid gzip stream (bad magic bytes)");
+  }
+  let pos = 2;
+  const cm = data[pos++];
+  if (cm !== 8) {
+    throw new Error(`Unsupported gzip compression method: ${cm}`);
+  }
+  const flags = data[pos++];
+  pos += 4;
+  pos += 1;
+  pos += 1;
+  if (flags & FLAG_FEXTRA) {
+    const xlen = data[pos] | data[pos + 1] << 8;
+    pos += 2 + xlen;
+  }
+  if (flags & FLAG_FNAME) {
+    while (pos < data.length && data[pos] !== 0) pos++;
+    pos++;
+  }
+  if (flags & FLAG_FCOMMENT) {
+    while (pos < data.length && data[pos] !== 0) pos++;
+    pos++;
+  }
+  if (flags & FLAG_FHCRC) {
+    pos += 2;
+  }
+  const deflateData = data.subarray(pos);
+  return inflateRaw(deflateData);
+}
+function bytesToUtf8(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+  let out = "";
+  let i = 0;
+  while (i < bytes.length) {
+    const b0 = bytes[i++];
+    if (b0 < 128) {
+      out += String.fromCharCode(b0);
+    } else if (b0 >= 192 && b0 < 224) {
+      const b1 = bytes[i++];
+      out += String.fromCharCode((b0 & 31) << 6 | b1 & 63);
+    } else if (b0 >= 224 && b0 < 240) {
+      const b1 = bytes[i++];
+      const b2 = bytes[i++];
+      out += String.fromCharCode(
+        (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63
+      );
+    } else {
+      const b1 = bytes[i++];
+      const b2 = bytes[i++];
+      const b3 = bytes[i++];
+      const codePoint = (b0 & 7) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
+      out += String.fromCodePoint(codePoint);
+    }
+  }
+  return out;
+}
+
+// src/_internal/animation/lottie/loader.ts
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function looksLikeBase64(str) {
+  const trimmed = str.trim();
+  if (trimmed.length < 8) return false;
+  return /^[A-Za-z0-9+/]+={0,2}$/.test(trimmed) && trimmed.length % 4 === 0;
+}
+async function fetchArrayBuffer(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`[@core-ease/telegram-kit] : failed to fetch "${url}" (HTTP ${res.status})`);
+  }
+  return res.arrayBuffer();
+}
+function bytesToJson(bytes) {
+  const data = isGzip(bytes) ? gunzip(bytes) : bytes;
+  const text = bytesToUtf8(data);
+  return JSON.parse(text);
+}
+async function loadTgsSource(src) {
+  if (src instanceof ArrayBuffer) {
+    return bytesToJson(new Uint8Array(src));
+  }
+  if (src instanceof Uint8Array) {
+    return bytesToJson(src);
+  }
+  if (typeof src === "object" && src !== null) {
+    return src;
+  }
+  if (typeof src === "string") {
+    const trimmed = src.trim();
+    if (trimmed.startsWith("{")) {
+      return JSON.parse(trimmed);
+    }
+    if (trimmed.startsWith("data:")) {
+      const comma = trimmed.indexOf(",");
+      const meta = trimmed.slice(5, comma);
+      const payload = trimmed.slice(comma + 1);
+      const bytes = meta.includes("base64") ? base64ToBytes(payload) : new TextEncoder().encode(decodeURIComponent(payload));
+      return bytesToJson(bytes);
+    }
+    if (looksLikeBase64(trimmed)) {
+      try {
+        return bytesToJson(base64ToBytes(trimmed));
+      } catch (e) {
+      }
+    }
+    const url = new URL(trimmed, typeof window !== "undefined" ? window.location.href : void 0);
+    const buffer = await fetchArrayBuffer(url.toString());
+    return bytesToJson(new Uint8Array(buffer));
+  }
+  throw new Error("[@core-ease/telegram-kit] : unsupported `src` type");
+}
+var DEFAULT_SIZE = 512;
+function useResolvedCssSize(width, height) {
+  return {
+    width: width != null ? width : "100%",
+    height: height != null ? height : "100%"
+  };
+}
+function createAnimationPlayerComponent(displayName, defaultAriaLabel) {
+  const Component = React.forwardRef(
+    function AnimationPlayer(props, ref) {
+      const {
+        src,
+        autoplay = false,
+        loop = false,
+        speed = 1,
+        direction = 1,
+        mode = "normal",
+        segments,
+        hover = false,
+        pauseWhenOffscreen = true,
+        width,
+        height,
+        className,
+        style,
+        ariaLabel = defaultAriaLabel,
+        onReady,
+        onPlay,
+        onPause,
+        onStop,
+        onComplete,
+        onLoop,
+        onFrame,
+        onError,
+        validate
+      } = props;
+      const canvasRef = React.useRef(null);
+      const controllerRef = React.useRef(null);
+      const containerRef = React.useRef(null);
+      const docRef = React.useRef(null);
+      const wasPlayingBeforeFreeze = React.useRef(false);
+      const callbacksRef = React.useRef(props);
+      callbacksRef.current = props;
+      React.useImperativeHandle(
+        ref,
+        () => ({
+          play: () => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.play();
+          },
+          pause: () => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.pause();
+          },
+          stop: () => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.stop();
+          },
+          togglePlay: () => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.togglePlay();
+          },
+          seek: (value) => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.seek(value);
+          },
+          setSpeed: (s) => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.setSpeed(s);
+          },
+          setDirection: (d) => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.setDirection(d);
+          },
+          setLoop: (l) => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.setLoop(l);
+          },
+          setMode: (m) => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.setMode(m);
+          },
+          setSegment: (seg) => {
+            var _a;
+            return (_a = controllerRef.current) == null ? void 0 : _a.setSegment(seg);
+          },
+          getCurrentFrame: () => {
+            var _a, _b;
+            return (_b = (_a = controllerRef.current) == null ? void 0 : _a.getCurrentFrame()) != null ? _b : 0;
+          },
+          getTotalFrames: () => {
+            var _a, _b;
+            return (_b = (_a = controllerRef.current) == null ? void 0 : _a.getTotalFrames()) != null ? _b : 0;
+          },
+          getState: () => {
+            var _a, _b;
+            return (_b = (_a = controllerRef.current) == null ? void 0 : _a.getState()) != null ? _b : "loading";
+          },
+          getAnimationData: () => docRef.current,
+          getCanvas: () => canvasRef.current
+        }),
+        []
+      );
+      React.useEffect(() => {
+        const canvas = canvasRef.current;
+        if (!canvas) return;
+        const controller = new LottieAnimationController({
+          canvas,
+          loop,
+          autoplay,
+          speed,
+          direction,
+          mode,
+          segments
+        });
+        controllerRef.current = controller;
+        const offReady = controller.on("ready", () => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onReady) == null ? void 0 : _b.call(_a);
+        });
+        const offPlay = controller.on("play", () => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onPlay) == null ? void 0 : _b.call(_a);
+        });
+        const offPause = controller.on("pause", () => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onPause) == null ? void 0 : _b.call(_a);
+        });
+        const offStop = controller.on("stop", () => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onStop) == null ? void 0 : _b.call(_a);
+        });
+        const offComplete = controller.on("complete", () => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onComplete) == null ? void 0 : _b.call(_a);
+        });
+        const offLoop = controller.on("loop", () => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onLoop) == null ? void 0 : _b.call(_a);
+        });
+        const offFrame = controller.on("frame", (d) => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onFrame) == null ? void 0 : _b.call(_a, d);
+        });
+        const offError = controller.on("error", (d) => {
+          var _a, _b;
+          return (_b = (_a = callbacksRef.current).onError) == null ? void 0 : _b.call(_a, d == null ? void 0 : d.errors);
+        });
+        return () => {
+          offReady();
+          offPlay();
+          offPause();
+          offStop();
+          offComplete();
+          offLoop();
+          offFrame();
+          offError();
+          controller.destroy();
+          controllerRef.current = null;
+        };
+      }, []);
+      React.useEffect(() => {
+        let cancelled = false;
+        const controller = controllerRef.current;
+        if (!controller) return;
+        loadTgsSource(src).then((doc) => {
+          var _a, _b;
+          if (cancelled) return;
+          if (validate) {
+            const errors = validate(doc);
+            if (errors.length > 0) {
+              (_b = (_a = callbacksRef.current).onError) == null ? void 0 : _b.call(_a, errors);
+            }
+          }
+          docRef.current = doc;
+          controller.setDocument(doc);
+          if (autoplay) controller.play();
+        }).catch((err) => {
+          var _a, _b;
+          if (cancelled) return;
+          controller.setError([err.message]);
+          (_b = (_a = callbacksRef.current).onError) == null ? void 0 : _b.call(_a, [err.message]);
+        });
+        return () => {
+          cancelled = true;
+        };
+      }, [src, validate]);
+      React.useEffect(() => {
+        var _a;
+        return (_a = controllerRef.current) == null ? void 0 : _a.setSpeed(speed);
+      }, [speed]);
+      React.useEffect(() => {
+        var _a;
+        return (_a = controllerRef.current) == null ? void 0 : _a.setDirection(direction);
+      }, [direction]);
+      React.useEffect(() => {
+        var _a;
+        return (_a = controllerRef.current) == null ? void 0 : _a.setLoop(loop);
+      }, [loop]);
+      React.useEffect(() => {
+        var _a;
+        return (_a = controllerRef.current) == null ? void 0 : _a.setMode(mode);
+      }, [mode]);
+      React.useEffect(() => {
+        var _a;
+        return (_a = controllerRef.current) == null ? void 0 : _a.setSegment(segments != null ? segments : null);
+      }, [segments]);
+      React.useEffect(() => {
+        const canvas = canvasRef.current;
+        const container = containerRef.current;
+        if (!canvas || !container) return;
+        const applySize = () => {
+          var _a;
+          const rect = container.getBoundingClientRect();
+          const dpr = typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
+          const w = Math.max(1, Math.round((rect.width || DEFAULT_SIZE) * dpr));
+          const h = Math.max(1, Math.round((rect.height || DEFAULT_SIZE) * dpr));
+          if (canvas.width !== w || canvas.height !== h) {
+            (_a = controllerRef.current) == null ? void 0 : _a.resize(w, h);
+          }
+        };
+        applySize();
+        if (typeof ResizeObserver !== "undefined") {
+          const ro = new ResizeObserver(applySize);
+          ro.observe(container);
+          return () => ro.disconnect();
+        }
+        return void 0;
+      }, []);
+      React.useEffect(() => {
+        if (!pauseWhenOffscreen) return;
+        const container = containerRef.current;
+        if (!container || typeof IntersectionObserver === "undefined") return;
+        const io = new IntersectionObserver((entries) => {
+          const entry = entries[0];
+          const controller = controllerRef.current;
+          if (!controller) return;
+          if (entry.isIntersecting) {
+            controller.unfreeze();
+          } else if (controller.getState() === "playing") {
+            controller.freeze();
+          }
+        });
+        io.observe(container);
+        return () => io.disconnect();
+      }, [pauseWhenOffscreen]);
+      React.useEffect(() => {
+        if (typeof document === "undefined") return;
+        const onVisibility = () => {
+          const controller = controllerRef.current;
+          if (!controller) return;
+          if (document.hidden) {
+            if (controller.getState() === "playing") {
+              wasPlayingBeforeFreeze.current = true;
+              controller.freeze();
+            }
+          } else if (wasPlayingBeforeFreeze.current) {
+            wasPlayingBeforeFreeze.current = false;
+            controller.unfreeze();
+          }
+        };
+        document.addEventListener("visibilitychange", onVisibility);
+        return () => document.removeEventListener("visibilitychange", onVisibility);
+      }, []);
+      const handleMouseEnter = React.useCallback(() => {
+        var _a;
+        if (hover) (_a = controllerRef.current) == null ? void 0 : _a.play();
+      }, [hover]);
+      const handleMouseLeave = React.useCallback(() => {
+        var _a;
+        if (hover) (_a = controllerRef.current) == null ? void 0 : _a.stop();
+      }, [hover]);
+      const cssSize = useResolvedCssSize(width, height);
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref: containerRef,
+          className,
+          style: __spreadValues({ width: cssSize.width, height: cssSize.height, lineHeight: 0 }, style),
+          onMouseEnter: handleMouseEnter,
+          onMouseLeave: handleMouseLeave,
+          role: "img",
+          "aria-label": ariaLabel,
+          children: /* @__PURE__ */ jsx("canvas", { ref: canvasRef, style: { width: "100%", height: "100%", display: "block" } })
+        }
+      );
+    }
+  );
+  Component.displayName = displayName;
+  return Component;
+}
+
+export { LottieAnimationController, createAnimationPlayerComponent, gunzip, isGzip, loadTgsSource, renderDocumentFrame };