@bokijonovm/cursorcrew 0.0.0-stage → 0.1.1

package/dist/chunk-HQWPI64P.js

@@ -0,0 +1,815 @@
+"use client";
+
+// src/timeline.ts
+var EASES = {
+  none: (t) => t,
+  "power1.in": (t) => t * t,
+  "power1.out": (t) => 1 - (1 - t) * (1 - t),
+  "power1.inOut": (t) => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2,
+  "power2.in": (t) => t * t * t,
+  "power2.out": (t) => 1 - Math.pow(1 - t, 3),
+  "power2.inOut": (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2
+};
+function getEase(name) {
+  if (typeof name === "function") return name;
+  if (!name) return EASES["power1.out"];
+  if (EASES[name]) return EASES[name];
+  const m = /^back\.out(?:\(([\d.]+)\))?$/.exec(name);
+  if (m) {
+    const c1 = m[1] ? +m[1] : 1.70158;
+    const c3 = c1 + 1;
+    return EASES[name] = (t) => 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+  }
+  return EASES["power1.out"];
+}
+var RESERVED = /* @__PURE__ */ new Set(["duration", "ease", "immediateRender", "onUpdate", "onComplete", "onStart", "overwrite"]);
+var TRANSFORM = /* @__PURE__ */ new Set(["x", "y", "scale"]);
+var transforms = /* @__PURE__ */ new WeakMap();
+function transformOf(el) {
+  let t = transforms.get(el);
+  if (!t) transforms.set(el, t = { x: 0, y: 0, scale: 1 });
+  return t;
+}
+var isElement = (o) => !!o && o.nodeType === 1;
+function read(target, prop) {
+  if (!isElement(target)) return target[prop];
+  if (TRANSFORM.has(prop)) return transformOf(target)[prop];
+  const cs = getComputedStyle(target);
+  if (prop === "autoAlpha") return cs.visibility === "hidden" ? 0 : parseFloat(cs.opacity);
+  const v = String(target.style[prop] || cs[prop] || "");
+  return /^-?[\d.]+(px)?$/.test(v) ? parseFloat(v) : v;
+}
+function set(target, values) {
+  const props = values;
+  if (!isElement(target)) {
+    for (const k in props) if (!RESERVED.has(k)) target[k] = props[k];
+    return;
+  }
+  const s = target.style;
+  let t = null;
+  for (const p in props) {
+    if (RESERVED.has(p)) continue;
+    const v = props[p];
+    if (p === "attr") {
+      for (const [k, val] of Object.entries(v)) target.setAttribute(k, val);
+    } else if (TRANSFORM.has(p)) {
+      (t ?? (t = transformOf(target)))[p] = v;
+    } else if (p === "autoAlpha") {
+      s.opacity = String(v);
+      s.visibility = v <= 0 ? "hidden" : "inherit";
+    } else if (p === "width" || p === "height") {
+      s[p] = typeof v === "number" ? `${v}px` : v;
+    } else {
+      s[p] = typeof v === "number" ? String(v) : v;
+    }
+  }
+  if (t) s.transform = `translate3d(${t.x}px,${t.y}px,0)${t.scale !== 1 ? ` scale(${t.scale})` : ""}`;
+}
+var NUMBER = /-?\d*\.?\d+(?:e[-+]?\d+)?/gi;
+function interpolator(from, to) {
+  if (typeof to === "string" && /^[-+]=/.test(to)) {
+    to = (Number(from) || 0) + (to[0] === "-" ? -1 : 1) * parseFloat(to.slice(2));
+  }
+  if (typeof to === "number") {
+    const a = Number(from) || 0;
+    const b = to;
+    return (e) => a + (b - a) * e;
+  }
+  if (typeof to === "string" && typeof from === "string") {
+    const bn = to.match(NUMBER) ?? [];
+    const an = from.match(NUMBER) ?? [];
+    if (bn.length && an.length === bn.length) {
+      const parts = to.split(NUMBER);
+      return (e) => {
+        let out = parts[0];
+        for (let i = 0; i < bn.length; i++) out += +an[i] + (+bn[i] - +an[i]) * e + parts[i + 1];
+        return out;
+      };
+    }
+  }
+  return () => to;
+}
+var Timeline = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.kids = [];
+    this.t = 0;
+    this.end = 0;
+    this.ts = 1;
+    this.paused = true;
+    this.dead = false;
+    this.started = false;
+    this.completed = false;
+    this.raf = 0;
+    this.last = 0;
+    this.tick = this.tick.bind(this);
+    if (!opts.paused) this.play();
+  }
+  /** Apply `vars` instantly at `position` seconds. */
+  set(target, vars, position) {
+    return this.add(target, null, { ...vars, duration: 0 }, position);
+  }
+  /** Tween from the target's current values (read when the tween starts). */
+  to(target, vars, position) {
+    return this.add(target, null, vars, position);
+  }
+  /** Tween between explicit values. Renders `from` right away unless `immediateRender: false`. */
+  fromTo(target, from, to, position) {
+    if (to.immediateRender !== false) set(target, from);
+    return this.add(target, from, to, position);
+  }
+  play() {
+    if (this.dead || this.completed) return this;
+    this.paused = false;
+    if (!this.raf) {
+      this.last = performance.now();
+      this.raf = requestAnimationFrame(this.tick);
+    }
+    return this;
+  }
+  pause() {
+    this.paused = true;
+    if (this.raf) cancelAnimationFrame(this.raf);
+    this.raf = 0;
+    return this;
+  }
+  kill() {
+    this.pause();
+    this.dead = true;
+    this.kids = [];
+    return this;
+  }
+  /** Total length in seconds, before timeScale. */
+  duration() {
+    return this.end;
+  }
+  /** Current playhead in seconds. */
+  time() {
+    return this.t;
+  }
+  isActive() {
+    return !this.paused && !this.dead && !this.completed;
+  }
+  timeScale(value) {
+    if (value === void 0) return this.ts;
+    this.ts = value > 0 && Number.isFinite(value) ? value : 1;
+    return this;
+  }
+  progress(value) {
+    if (value === void 0) return this.end ? this.t / this.end : 1;
+    this.goto(value * this.end);
+    return this;
+  }
+  add(target, from, to, position) {
+    const tween = {
+      target,
+      from,
+      to,
+      start: position ?? this.end,
+      dur: Math.max(0, to.duration ?? 0.5),
+      ease: getEase(to.ease),
+      fns: null,
+      done: false
+    };
+    let i = this.kids.length;
+    while (i > 0 && this.kids[i - 1].start > tween.start) i--;
+    this.kids.splice(i, 0, tween);
+    this.end = Math.max(this.end, tween.start + tween.dur);
+    return this;
+  }
+  render(time) {
+    for (const c of this.kids) {
+      if (c.start > time) break;
+      if (c.done) continue;
+      if (!c.fns) {
+        c.fns = {};
+        for (const k in c.to) {
+          if (RESERVED.has(k)) continue;
+          if (k === "attr") {
+            const attr = c.to.attr;
+            c.fns.attr = () => attr;
+          } else {
+            c.fns[k] = interpolator(c.from && k in c.from ? c.from[k] : read(c.target, k), c.to[k]);
+          }
+        }
+      }
+      const p = c.dur ? Math.min(1, (time - c.start) / c.dur) : 1;
+      const e = c.ease(p);
+      const props = {};
+      for (const f in c.fns) props[f] = c.fns[f](e);
+      set(c.target, props);
+      c.to.onUpdate?.();
+      if (p >= 1) c.done = true;
+    }
+  }
+  goto(time) {
+    if (this.dead) return;
+    time = Math.max(0, Math.min(time, this.end));
+    if (!this.started) {
+      this.started = true;
+      this.opts.onStart?.();
+    }
+    this.t = time;
+    this.render(time);
+    this.opts.onUpdate?.();
+    if (time >= this.end && !this.completed) {
+      this.completed = true;
+      this.pause();
+      this.opts.onComplete?.();
+    }
+  }
+  tick(now) {
+    this.raf = 0;
+    if (this.paused || this.dead) return;
+    let dt = (now - this.last) / 1e3;
+    this.last = now;
+    if (dt > 0.25) dt = 1 / 60;
+    this.goto(this.t + dt * this.ts);
+    if (!this.paused && !this.dead) this.raf = requestAnimationFrame(this.tick);
+  }
+};
+
+// src/scan.ts
+var SKIP_TAGS = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "TEMPLATE", "NOSCRIPT", "LINK", "META", "HEAD", "TITLE", "BR", "WBR", "SOURCE", "TRACK"]);
+var MEDIA_TAGS = /* @__PURE__ */ new Set(["IMG", "SVG", "svg", "VIDEO", "CANVAS", "PICTURE", "IFRAME", "OBJECT", "EMBED"]);
+var CONTROL_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT", "PROGRESS", "METER"]);
+var isTransparent = (c) => !c || c === "transparent" || /^rgba?\([^,)]+,[^,)]+,[^,)]+,\s*0*\.?0*%?\s*\)$/.test(c) || /\/\s*0*\.?0*%?\s*\)$/.test(c);
+function paintsSurface(cs) {
+  if (!isTransparent(cs.backgroundColor)) return true;
+  if (cs.backgroundImage && cs.backgroundImage !== "none") return true;
+  if (cs.boxShadow && cs.boxShadow !== "none") return true;
+  for (const side of ["Top", "Right", "Bottom", "Left"]) {
+    const width = parseFloat(cs[`border${side}Width`]);
+    const style = cs[`border${side}Style`];
+    if (width > 0 && style !== "none" && style !== "hidden" && !isTransparent(cs[`border${side}Color`])) return true;
+  }
+  return false;
+}
+function hasOwnText(el) {
+  for (const node of Array.from(el.childNodes)) {
+    if (node.nodeType === 3 && node.nodeValue && node.nodeValue.trim()) return true;
+  }
+  return false;
+}
+function onlyInlineDescendants(el) {
+  for (const child of Array.from(el.children)) {
+    if (child.tagName === "BR") continue;
+    if (MEDIA_TAGS.has(child.tagName) || CONTROL_TAGS.has(child.tagName)) return false;
+    if (getComputedStyle(child).display !== "inline" || !onlyInlineDescendants(child)) return false;
+  }
+  return true;
+}
+function isInlineTextBlock(el) {
+  if (!el.textContent || !el.textContent.trim()) return false;
+  for (const child of Array.from(el.children)) {
+    if (SKIP_TAGS.has(child.tagName)) continue;
+    if (MEDIA_TAGS.has(child.tagName) || CONTROL_TAGS.has(child.tagName)) return false;
+    const display = getComputedStyle(child).display;
+    if (display !== "inline" && display !== "contents" || !onlyInlineDescendants(child)) return false;
+  }
+  return true;
+}
+function labelFor(el, kind) {
+  if (kind === "text") {
+    const text = (el.textContent || "").replace(/\s+/g, " ").trim();
+    return `\u201C${text.length > 18 ? text.slice(0, 17) + "\u2026" : text}\u201D`;
+  }
+  const tag = el.tagName.toLowerCase();
+  if (kind === "media") return tag === "img" || tag === "picture" ? "image" : tag;
+  const cls = (el.getAttribute("class") || "").trim().split(/\s+/)[0];
+  return cls ? `${tag}.${cls.slice(0, 16)}` : tag;
+}
+function collectTasks(root, origin, maxTasks) {
+  const tasks = [];
+  const add = (el, kind, hasBox, parent) => {
+    const r = el.getBoundingClientRect();
+    const rect = { x: r.left - origin.left, y: r.top - origin.top, w: r.width, h: r.height };
+    tasks.push({ id: tasks.length, el, kind, hasBox, rect, parent, label: labelFor(el, kind), area: rect.w * rect.h });
+    return tasks.length - 1;
+  };
+  const walk = (el, parent, isRoot) => {
+    if (SKIP_TAGS.has(el.tagName)) return;
+    const mode = el.getAttribute("data-assemble");
+    if (mode === "skip") return;
+    const cs = getComputedStyle(el);
+    if (cs.display === "none") return;
+    const r = el.getBoundingClientRect();
+    const visible = r.width >= 2 && r.height >= 2;
+    const tag = el.tagName;
+    if (visible && !(isRoot && (tag === "BODY" || tag === "HTML"))) {
+      if (mode === "block") return void add(el, "block", false, parent);
+      if (MEDIA_TAGS.has(tag)) return void add(el, "media", false, parent);
+      if (CONTROL_TAGS.has(tag)) return void add(el, "box", true, parent);
+      const box = paintsSurface(cs);
+      if (hasOwnText(el) || isInlineTextBlock(el)) return void add(el, "text", box, parent);
+      if (box) parent = add(el, "box", true, parent);
+    }
+    for (const child of Array.from(el.children)) walk(child, parent, false);
+  };
+  walk(root, -1, true);
+  if (tasks.length <= maxTasks) return tasks;
+  const dropped = /* @__PURE__ */ new Set();
+  for (const t of tasks.filter((t2) => t2.parent !== -1).sort((a, b) => a.area - b.area)) {
+    if (tasks.length - dropped.size <= maxTasks) break;
+    dropped.add(t.id);
+  }
+  const keptAncestor = (p) => {
+    while (p !== -1 && dropped.has(p)) p = tasks[p].parent;
+    return p;
+  };
+  const kept = tasks.filter((t) => !dropped.has(t.id));
+  const newIndex = /* @__PURE__ */ new Map();
+  kept.forEach((t, i) => newIndex.set(t.id, i));
+  for (const t of kept) {
+    const p = keptAncestor(t.parent);
+    t.parent = p === -1 ? -1 : newIndex.get(p);
+  }
+  kept.forEach((t, i) => t.id = i);
+  return kept;
+}
+
+// src/text.ts
+var Segmenter = typeof Intl !== "undefined" ? Intl.Segmenter : void 0;
+var segmenter = Segmenter ? new Segmenter(void 0, { granularity: "grapheme" }) : null;
+var graphemes = (s) => segmenter ? Array.from(segmenter.segment(s), (x) => x.segment) : Array.from(s);
+var WORD_THRESHOLD = 160;
+function splitText(el, mode) {
+  const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT, {
+    acceptNode(node) {
+      const parent = node.parentElement;
+      if (!parent || parent.closest("script,style,svg,textarea")) return NodeFilter.FILTER_REJECT;
+      return node.nodeValue ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+    }
+  });
+  const nodes = [];
+  while (walker.nextNode()) nodes.push(walker.currentNode);
+  const length = nodes.reduce((n, t) => n + (t.nodeValue || "").trim().length, 0);
+  const byWord = mode === "word" || mode === "auto" && length > WORD_THRESHOLD;
+  const chunks = [];
+  const replaced = [];
+  for (const node of nodes) {
+    const value = node.nodeValue || "";
+    if (!value.trim()) continue;
+    const pieces = byWord ? value.match(/\s+|\S+/g) || [] : graphemes(value);
+    const fragment = document.createDocumentFragment();
+    const created = [];
+    for (const piece of pieces) {
+      let out;
+      if (!piece.trim()) {
+        out = document.createTextNode(piece);
+      } else {
+        const span = document.createElement("span");
+        span.textContent = piece;
+        span.style.visibility = "hidden";
+        span.setAttribute("data-cc-chunk", "");
+        chunks.push(span);
+        out = span;
+      }
+      fragment.appendChild(out);
+      created.push(out);
+    }
+    if (/flex|grid/.test(getComputedStyle(node.parentElement).display)) {
+      const item = document.createElement("span");
+      item.appendChild(fragment);
+      fragment.appendChild(item);
+      created.splice(0, created.length, item);
+    }
+    node.parentNode.insertBefore(fragment, node);
+    node.parentNode.removeChild(node);
+    replaced.push({ original: node, created });
+  }
+  let restored = false;
+  return {
+    chunks,
+    restore() {
+      if (restored) return;
+      restored = true;
+      for (const { original, created } of replaced) {
+        const first = created[0];
+        if (first && first.parentNode) first.parentNode.insertBefore(original, first);
+        for (const n of created) n.parentNode?.removeChild(n);
+      }
+    }
+  };
+}
+
+// src/overlay.ts
+var DEFAULT_AGENTS = [
+  { name: "Atlas", color: "#6d5efc" },
+  { name: "Nova", color: "#f2547d" },
+  { name: "Echo", color: "#12a8a0" },
+  { name: "Pixel", color: "#f08a24" },
+  { name: "Orbit", color: "#2f80ed" },
+  { name: "Juno", color: "#9b51e0" },
+  { name: "Sol", color: "#d4a20b" },
+  { name: "Kai", color: "#27ae60" }
+];
+function resolveAgents(agents) {
+  if (Array.isArray(agents) && agents.length) return agents.slice();
+  const count = Math.min(24, Math.max(1, typeof agents === "number" ? Math.round(agents) : 5));
+  return Array.from({ length: count }, (_, i) => {
+    const base = DEFAULT_AGENTS[i % DEFAULT_AGENTS.length];
+    return i < DEFAULT_AGENTS.length ? { ...base } : { name: `${base.name} ${Math.floor(i / DEFAULT_AGENTS.length) + 1}`, color: base.color };
+  });
+}
+var STYLE_ID = "cursorcrew-css";
+var CSS = `
+[data-assemble-pending]{visibility:hidden}
+.cc-layer{position:absolute;left:0;top:0;overflow:hidden;pointer-events:none}
+.cc-layer *{box-sizing:border-box}
+.cc-agent{position:absolute;left:0;top:0;width:0;height:0;will-change:transform;z-index:3}
+.cc-ic{position:absolute;display:none;overflow:visible;filter:drop-shadow(0 1px 2px rgba(0,0,0,.25))}
+.cc-agent[data-mode=arrow] .cc-arrow,.cc-agent[data-mode=cross] .cc-cross,.cc-agent[data-mode=beam] .cc-beam{display:block}
+.cc-arrow{left:-1px;top:-1px;width:18px;height:22px}
+.cc-cross{left:-9px;top:-9px;width:18px;height:18px}
+.cc-beam{left:-5px;top:-10px;width:10px;height:20px}
+.cc-tag{position:absolute;left:14px;top:18px;display:flex;align-items:center;gap:6px;white-space:nowrap;
+  font:600 11px/1 ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif;color:#fff;background:var(--c);
+  padding:4px 7px;border-radius:2px 8px 8px 8px;box-shadow:0 2px 6px rgba(0,0,0,.18);letter-spacing:.01em}
+.cc-tag::after{content:attr(data-action);font-weight:500;opacity:.82;max-width:180px;overflow:hidden;text-overflow:ellipsis}
+.cc-tag[data-action=""]::after{display:none}
+.cc-noactions .cc-tag::after{display:none}
+.cc-nolabels .cc-tag{display:none}
+.cc-draw{position:absolute;left:0;top:0;width:0;height:0;visibility:hidden;opacity:0;z-index:1;
+  border:1.5px solid var(--c);background:color-mix(in srgb,var(--c) 7%,transparent)}
+.cc-draw[data-kind=text]{border-style:dashed;background:none}
+.cc-draw[data-kind=media],.cc-draw[data-kind=block]{background:repeating-linear-gradient(135deg,
+  color-mix(in srgb,var(--c) 14%,transparent) 0 6px,color-mix(in srgb,var(--c) 4%,transparent) 6px 12px)}
+.cc-dim{position:absolute;left:50%;top:100%;transform:translate(-50%,5px);font:600 10px/1 ui-monospace,SFMono-Regular,Menlo,monospace;
+  color:#fff;background:var(--c);padding:3px 5px;border-radius:3px;white-space:nowrap}
+.cc-caret{position:absolute;left:0;top:0;width:2px;visibility:hidden;opacity:0;z-index:2;background:var(--c)}
+`;
+function injectStyles() {
+  if (document.getElementById(STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = STYLE_ID;
+  style.textContent = CSS;
+  document.head.appendChild(style);
+}
+function createLayer(zIndex, labels, actions) {
+  const layer = document.createElement("div");
+  layer.className = "cc-layer" + (labels ? "" : " cc-nolabels") + (actions ? "" : " cc-noactions");
+  layer.setAttribute("aria-hidden", "true");
+  const doc = document.documentElement;
+  layer.style.width = Math.max(doc.scrollWidth, document.body.scrollWidth) + "px";
+  layer.style.height = Math.max(doc.scrollHeight, document.body.scrollHeight) + "px";
+  layer.style.zIndex = String(zIndex);
+  document.body.appendChild(layer);
+  return layer;
+}
+var ICONS = '<svg class="cc-ic cc-arrow" viewBox="0 0 18 22"><path d="M1.5 1.5v16.2l4.3-4.1 2.9 6.6 2.7-1.2-2.9-6.5h6z" fill="var(--c)" stroke="#fff" stroke-width="1.5" stroke-linejoin="round"/></svg><svg class="cc-ic cc-cross" viewBox="0 0 18 18"><path d="M9 1v16M1 9h16" stroke="#fff" stroke-width="3.5" stroke-linecap="round"/><path d="M9 1v16M1 9h16" stroke="var(--c)" stroke-width="1.6" stroke-linecap="round"/></svg><svg class="cc-ic cc-beam" viewBox="0 0 10 20"><path d="M2 1.5h6M5 1.5v17M2 18.5h6" stroke="#fff" stroke-width="3.5" stroke-linecap="round"/><path d="M2 1.5h6M5 1.5v17M2 18.5h6" stroke="var(--c)" stroke-width="1.6" stroke-linecap="round"/></svg>';
+function createAgent(layer, config) {
+  const el = document.createElement("div");
+  el.className = "cc-agent";
+  el.dataset.mode = "arrow";
+  el.style.setProperty("--c", config.color);
+  el.innerHTML = ICONS;
+  const tag = document.createElement("div");
+  tag.className = "cc-tag";
+  tag.textContent = config.name;
+  tag.setAttribute("data-action", "");
+  el.appendChild(tag);
+  const caret = document.createElement("div");
+  caret.className = "cc-caret";
+  caret.style.setProperty("--c", config.color);
+  layer.appendChild(el);
+  layer.appendChild(caret);
+  return { el, tag, caret, config };
+}
+function createDrawBox(layer, kind, color, withSize) {
+  const box = document.createElement("div");
+  box.className = "cc-draw";
+  box.dataset.kind = kind;
+  box.style.setProperty("--c", color);
+  let size = null;
+  if (withSize) {
+    size = document.createElement("div");
+    size.className = "cc-dim";
+    box.appendChild(size);
+  }
+  layer.appendChild(box);
+  return { box, size };
+}
+
+// src/assemble.ts
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var TIMING = {
+  travel: (px) => clamp(0.22 + px / 1700, 0.28, 0.85),
+  draw: (area) => clamp(0.32 + Math.sqrt(area) / 1500, 0.38, 0.95),
+  frame: (area) => clamp(0.18 + Math.sqrt(area) / 2600, 0.2, 0.45),
+  fade: 0.3,
+  sweep: 0.6,
+  perChar: 0.028,
+  perWord: 0.075,
+  typeMax: 1.7,
+  gap: 0.06
+};
+var RESTORED_PROPS = ["visibility", "opacity", "clip-path", "-webkit-clip-path"];
+var MOVE_EASE = "power2.inOut";
+var LATE = { immediateRender: false };
+function build(root, o) {
+  injectStyles();
+  const saved = /* @__PURE__ */ new Map();
+  const remember = (el) => {
+    if (saved.has(el)) return;
+    const props = {};
+    for (const p of RESTORED_PROPS) props[p] = [el.style.getPropertyValue(p), el.style.getPropertyPriority(p)];
+    saved.set(el, { hadStyle: el.hasAttribute("style"), props });
+  };
+  const layer = createLayer(o.zIndex, o.labels, o.actions);
+  const origin = layer.getBoundingClientRect();
+  const tasks = collectTasks(root, origin, o.maxTasks);
+  const finalOpacity = tasks.map((t) => parseFloat(getComputedStyle(t.el).opacity) || 1);
+  remember(root);
+  root.style.visibility = "hidden";
+  root.removeAttribute("data-assemble-pending");
+  const splits = tasks.map((t) => {
+    remember(t.el);
+    t.el.style.visibility = "hidden";
+    return t.kind === "text" ? splitText(t.el, o.typing) : null;
+  });
+  const agents = resolveAgents(o.agents).map((cfg) => createAgent(layer, cfg));
+  const r = root.getBoundingClientRect();
+  const top = clamp(r.top, 0, innerHeight);
+  const bottom = clamp(r.bottom, 0, innerHeight);
+  const left = clamp(r.left, 0, innerWidth);
+  const right = clamp(r.right, 0, innerWidth);
+  const spawn = { x: (left + right) / 2 - origin.left, y: top + Math.min(120, (bottom - top) * 0.25) - origin.top };
+  let resolveFinished;
+  const finished = new Promise((res) => resolveFinished = res);
+  let tornDown = false;
+  const teardown = () => {
+    if (tornDown) return;
+    tornDown = true;
+    tl.kill();
+    for (const s of splits) s?.restore();
+    saved.forEach((entry, el) => {
+      for (const p of RESTORED_PROPS) {
+        const [value, priority] = entry.props[p];
+        if (value) el.style.setProperty(p, value, priority);
+        else el.style.removeProperty(p);
+      }
+      if (!entry.hadStyle && !el.getAttribute("style")) el.removeAttribute("style");
+    });
+    layer.remove();
+    resolveFinished();
+  };
+  const tl = new Timeline({
+    paused: true,
+    onStart: () => o.onStart?.(),
+    onUpdate: () => o.onProgress?.(tl.progress()),
+    onComplete: () => {
+      if (o.cleanup) teardown();
+      else resolveFinished();
+      o.onComplete?.();
+    }
+  });
+  const state = agents.map((a, n) => {
+    const offset = (n - (agents.length - 1) / 2) * 34;
+    const pos = { x: spawn.x + offset, y: spawn.y + n % 2 * 18 };
+    tl.fromTo(a.el, { x: pos.x, y: pos.y, scale: 0, autoAlpha: 0 }, { scale: 1, autoAlpha: 1, duration: 0.42, ease: "back.out(2)" }, n * 0.07);
+    return { pos, free: 0.45 + n * 0.07, last: 0 };
+  });
+  const say = (i, text, at) => tl.set(agents[i].tag, { attr: { "data-action": text } }, at);
+  const cursor = (i, mode, at) => tl.set(agents[i].el, { attr: { "data-mode": mode } }, at);
+  const move = (i, to, at, dur) => {
+    const from = state[i].pos;
+    tl.fromTo(agents[i].el, { x: from.x, y: from.y }, { x: to.x, y: to.y, duration: dur, ease: MOVE_EASE, ...LATE }, at);
+    state[i].pos = { ...to };
+  };
+  const drag = (i, task, kind, at, dur, showSize) => {
+    const { box, size } = createDrawBox(layer, kind, agents[i].config.color, showSize);
+    const { x, y, w, h } = task.rect;
+    set(box, { x, y });
+    tl.set(box, { autoAlpha: 1 }, at);
+    const vars = { width: w, height: h, duration: dur, ease: MOVE_EASE, ...LATE };
+    if (size) {
+      vars.onUpdate = () => {
+        size.textContent = `${Math.round(parseFloat(box.style.width) || 0)} \xD7 ${Math.round(parseFloat(box.style.height) || 0)}`;
+      };
+    }
+    tl.fromTo(box, { width: 0, height: 0 }, vars, at);
+    move(i, { x: x + w, y: y + h }, at, dur);
+    return box;
+  };
+  const fadeIn = (task, at) => {
+    tl.set(task.el, { visibility: "visible" }, at);
+    tl.fromTo(task.el, { opacity: 0 }, { opacity: finalOpacity[task.id], duration: TIMING.fade, ease: "power1.out", ...LATE }, at);
+  };
+  const perform = (i, task, at) => {
+    let t = at;
+    if (task.kind === "media" || task.kind === "block") {
+      say(i, `placing ${task.label}`, t);
+      cursor(i, "cross", t);
+      const dur = TIMING.draw(task.area);
+      const box = drag(i, task, task.kind, t, dur, true);
+      t += dur;
+      tl.set(task.el, { visibility: "visible" }, t);
+      tl.fromTo(task.el, { clipPath: "inset(0% 0% 100% 0%)" }, { clipPath: "inset(0% 0% 0% 0%)", duration: TIMING.sweep, ease: "power2.out", ...LATE }, t);
+      tl.to(box, { autoAlpha: 0, duration: TIMING.sweep, ...LATE }, t);
+      cursor(i, "arrow", t);
+      return t + TIMING.sweep * 0.6;
+    }
+    let frame = null;
+    if (task.hasBox) {
+      say(i, `drawing ${task.kind === "text" ? task.el.tagName.toLowerCase() : task.label}`, t);
+      cursor(i, "cross", t);
+      const dur = TIMING.draw(task.area);
+      frame = drag(i, task, "box", t, dur, true);
+      t += dur;
+      fadeIn(task, t);
+      tl.to(frame, { autoAlpha: 0, duration: TIMING.fade, ...LATE }, t);
+      cursor(i, "arrow", t);
+      if (task.kind === "box") return t + TIMING.fade * 0.5;
+      t += TIMING.fade * 0.6;
+    }
+    const chunks = splits[task.id].chunks;
+    if (!frame) {
+      say(i, "text box", t);
+      cursor(i, "cross", t);
+      const dur = TIMING.frame(task.area);
+      frame = drag(i, task, "text", t, dur, false);
+      t += dur;
+      tl.set(task.el, { visibility: "visible" }, t);
+    }
+    if (!chunks.length) return t;
+    const ends = chunks.map((c) => {
+      const b = c.getBoundingClientRect();
+      return { x: b.right - origin.left, y: b.top - origin.top, h: b.height };
+    });
+    const f = chunks[0].getBoundingClientRect();
+    const start = { x: f.left - origin.left, y: f.top - origin.top, h: f.height };
+    const handle = (p) => ({ x: p.x + 9, y: p.y + p.h * 0.55 });
+    const wordy = chunks.some((c) => /\S\s*\S/.test(c.textContent || ""));
+    const typeDur = clamp(chunks.length * (wordy ? TIMING.perWord : TIMING.perChar), 0.2, TIMING.typeMax);
+    const reach = 0.22;
+    move(i, handle(start), t, reach);
+    cursor(i, "beam", t + reach * 0.5);
+    t += reach;
+    say(i, `typing ${task.label}`, t);
+    const caret = agents[i].caret;
+    tl.set(caret, { x: start.x, y: start.y, height: start.h, autoAlpha: 1 }, t);
+    const counter = { n: 0 };
+    let shown = 0;
+    const total = chunks.length;
+    tl.fromTo(
+      counter,
+      { n: 0 },
+      {
+        n: total,
+        duration: typeDur,
+        ease: "none",
+        ...LATE,
+        onUpdate: () => {
+          const k = Math.min(total, Math.round(counter.n));
+          if (k > shown) for (let j = shown; j < k; j++) chunks[j].style.visibility = "";
+          else for (let j = k; j < shown; j++) chunks[j].style.visibility = "hidden";
+          shown = k;
+          const p = k === 0 ? start : ends[k - 1];
+          set(caret, { x: p.x, y: p.y, height: p.h });
+          set(agents[i].el, handle(p));
+        }
+      },
+      t
+    );
+    t += typeDur;
+    state[i].pos = handle(ends[total - 1]);
+    tl.set(caret, { autoAlpha: 0 }, t + 0.12);
+    tl.to(frame, { autoAlpha: 0, duration: 0.25, ...LATE }, t);
+    cursor(i, "arrow", t + 0.12);
+    return t + 0.08;
+  };
+  const queue = tasks.slice().sort((a, b) => Math.round(a.rect.y / 24) - Math.round(b.rect.y / 24) || a.rect.x - b.rect.x || a.id - b.id);
+  const doneAt = new Array(tasks.length).fill(-1);
+  while (queue.length) {
+    let i = 0;
+    for (let k = 1; k < state.length; k++) if (state[k].free < state[i].free) i = k;
+    const st = state[i];
+    let best = -1;
+    let bestScore = Infinity;
+    let bestStart = 0;
+    let bestTravel = 0;
+    let considered = 0;
+    for (let j = 0; j < queue.length && considered < 10; j++) {
+      const task2 = queue[j];
+      if (task2.parent !== -1 && doneAt[task2.parent] < 0) continue;
+      const travel = TIMING.travel(distance(st.pos, task2.rect));
+      const start = Math.max(st.free + travel, task2.parent === -1 ? 0 : doneAt[task2.parent] + 0.05);
+      const score = start + considered * 0.04;
+      if (score < bestScore) {
+        bestScore = score;
+        best = j;
+        bestStart = start;
+        bestTravel = travel;
+      }
+      considered++;
+    }
+    if (best < 0) {
+      best = 0;
+      bestTravel = TIMING.travel(distance(st.pos, queue[0].rect));
+      bestStart = st.free + bestTravel;
+    }
+    const task = queue.splice(best, 1)[0];
+    say(i, `\u2192 ${task.label}`, bestStart - bestTravel);
+    move(i, { x: task.rect.x, y: task.rect.y }, bestStart - bestTravel, bestTravel);
+    doneAt[task.id] = perform(i, task, bestStart);
+    st.free = doneAt[task.id] + TIMING.gap;
+    st.last = doneAt[task.id];
+  }
+  const end = Math.max(0.5, ...doneAt);
+  agents.forEach((a, n) => {
+    say(n, "done \u2713", state[n].last + 0.05);
+    cursor(n, "arrow", state[n].last + 0.05);
+    tl.to(a.el, { autoAlpha: 0, scale: 0.6, y: "-=14", duration: 0.35, ease: "power2.in", ...LATE }, end + 0.35 + n * 0.05);
+  });
+  if (o.duration && o.duration > 0) tl.timeScale(tl.duration() / o.duration);
+  else tl.timeScale(o.speed || 1);
+  return { tl, finished, teardown };
+}
+var noop = () => {
+};
+function assemble(target, options = {}) {
+  const root = typeof target === "string" ? document.querySelector(target) : target;
+  if (!root) throw new Error(`cursorcrew: target not found (${String(target)})`);
+  const o = {
+    agents: 5,
+    speed: 1,
+    typing: "auto",
+    maxTasks: 250,
+    cleanup: true,
+    zIndex: 2147483e3,
+    labels: true,
+    actions: true,
+    autoplay: true,
+    trigger: "immediate",
+    reducedMotion: "respect",
+    ...options
+  };
+  if (o.reducedMotion === "respect" && typeof matchMedia !== "undefined" && matchMedia("(prefers-reduced-motion: reduce)").matches) {
+    root.removeAttribute("data-assemble-pending");
+    if (o.onComplete) queueMicrotask(o.onComplete);
+    return {
+      timeline: new Timeline({ paused: true }),
+      finished: Promise.resolve(),
+      play: noop,
+      pause: noop,
+      finish: noop,
+      replay: noop,
+      destroy: noop
+    };
+  }
+  let current = build(root, o);
+  let observer = null;
+  const stopWatching = () => {
+    observer?.disconnect();
+    observer = null;
+  };
+  if (o.autoplay) {
+    if (o.trigger === "viewport" && root !== document.body && typeof IntersectionObserver !== "undefined") {
+      observer = new IntersectionObserver(
+        (entries) => {
+          if (entries.some((e) => e.isIntersecting)) {
+            stopWatching();
+            current.tl.play();
+          }
+        },
+        { threshold: 0.15 }
+      );
+      observer.observe(root);
+    } else {
+      current.tl.play();
+    }
+  }
+  return {
+    get timeline() {
+      return current.tl;
+    },
+    get finished() {
+      return current.finished;
+    },
+    play: () => void current.tl.play(),
+    pause: () => void current.tl.pause(),
+    finish() {
+      stopWatching();
+      current.tl.progress(1);
+    },
+    replay() {
+      stopWatching();
+      current.teardown();
+      current = build(root, o);
+      current.tl.play();
+    },
+    destroy() {
+      stopWatching();
+      current.teardown();
+    }
+  };
+}
+
+export {
+  Timeline,
+  DEFAULT_AGENTS,
+  assemble
+};
+//# sourceMappingURL=chunk-HQWPI64P.js.map