@energy8platform/golem 0.3.0 → 0.6.0

package/dist/lib/interactive-editor.js

@@ -0,0 +1,744 @@
+// src/interactive-editor.ts
+import { Matrix } from "pixi.js";
+
+// src/rig-anim.ts
+var DEG = Math.PI / 180;
+var pk = (target, id, prop) => `${target}:${id}:${prop}`;
+
+// src/interactive-bones.ts
+var neutral = () => ({
+  x: 0,
+  y: 0,
+  rotation: 0,
+  scaleX: 1,
+  scaleY: 1
+});
+var clone = (v) => Object.assign(/* @__PURE__ */ Object.create(null), JSON.parse(JSON.stringify(v)));
+function createInteractiveBoneEditor(options) {
+  if (!options.documentId) throw Error("documentId is required");
+  const limit = options.historyLimit ?? 100;
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1e4)
+    throw Error("historyLimit must be an integer from 1 to 10000");
+  const { player } = options, bones = new Map(player.doc.bones.map((b) => [b.id, b]));
+  let transforms = /* @__PURE__ */ Object.create(null), past = [], future = [], visible = true, disposed = false;
+  const ensure = () => {
+    if (disposed) throw Error("Bone editor is disposed");
+  };
+  const known = (id) => {
+    if (!bones.has(id)) throw Error("Unknown bone: " + id);
+  };
+  const getTransform = (id) => {
+    ensure();
+    known(id);
+    return { ...neutral(), ...transforms[id] };
+  };
+  const exportPatch = () => ({
+    format: "golem.bone-edits",
+    version: 1,
+    documentId: options.documentId,
+    transforms: clone(transforms)
+  });
+  const refresh = () => {
+    player.refreshPose();
+    options.onRender?.();
+  };
+  const notify = () => {
+    refresh();
+    options.onChange?.(exportPatch());
+  };
+  const remember = () => {
+    past.push(clone(transforms));
+    if (past.length > limit) past.shift();
+    future = [];
+  };
+  const normalize = () => {
+    for (const [id, t] of Object.entries(transforms))
+      if (Object.entries(t).every(
+        ([k, v]) => v === neutral()[k]
+      ))
+        delete transforms[id];
+  };
+  function validateTransform(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw Error("Invalid bone transform");
+    const out = neutral();
+    for (const [k, v] of Object.entries(value)) {
+      if (!Object.hasOwn(out, k) || typeof v !== "number" || !Number.isFinite(v) || Math.abs(v) > 1e4 || k.startsWith("scale") && (v < 0.1 || v > 4))
+        throw Error("Invalid bone parameter: " + k);
+      out[k] = v;
+    }
+    return out;
+  }
+  function validatePatch(value) {
+    const v = value;
+    if (!v || v.format !== "golem.bone-edits" || v.version !== 1 || v.documentId !== options.documentId)
+      throw Error("Bone patch format/version/document mismatch");
+    if (!v.transforms || typeof v.transforms !== "object" || Array.isArray(v.transforms))
+      throw Error("Invalid bone transforms");
+    const next = /* @__PURE__ */ Object.create(null);
+    for (const [id, t] of Object.entries(v.transforms)) {
+      known(id);
+      next[id] = validateTransform(t);
+    }
+    return { ...v, transforms: next };
+  }
+  function editPose(input) {
+    if (!visible || !Object.keys(transforms).length) return input;
+    const out = new Map(input);
+    for (const [id, t] of Object.entries(transforms)) {
+      const bone = bones.get(id);
+      for (const [prop, offset] of Object.entries(t)) {
+        const k = pk("bone", id, prop), rest = bone.transform[prop] ?? (prop.startsWith("scale") ? 1 : 0), value = out.get(k) ?? rest;
+        if (typeof value === "number")
+          out.set(
+            k,
+            prop.startsWith("scale") ? value * offset : value + offset
+          );
+      }
+      for (const ik of player.doc.ik ?? []) {
+        const affected = ik.bones.some((bid) => {
+          let b = bones.get(bid);
+          while (b) {
+            if (b.id === id) return true;
+            b = b.parent ? bones.get(b.parent) : void 0;
+          }
+          return false;
+        });
+        let target = bones.get(ik.target);
+        let sharedAncestor = false;
+        while (target) {
+          if (target.id === id) {
+            sharedAncestor = true;
+            break;
+          }
+          target = target.parent ? bones.get(target.parent) : void 0;
+        }
+        if (affected && !sharedAncestor) out.set(pk("ik", ik.id, "mix"), 0);
+      }
+    }
+    return out;
+  }
+  const unsubscribe = player.onBeforePose(editPose);
+  return {
+    getTransform,
+    exportPatch,
+    validatePatch,
+    get canUndo() {
+      return past.length > 0;
+    },
+    get canRedo() {
+      return future.length > 0;
+    },
+    setTransform(id, value) {
+      ensure();
+      known(id);
+      const next = validateTransform({ ...getTransform(id), ...value });
+      if (JSON.stringify(next) === JSON.stringify(getTransform(id))) return;
+      remember();
+      transforms[id] = next;
+      normalize();
+      notify();
+    },
+    importPatch(value) {
+      ensure();
+      const next = validatePatch(value);
+      remember();
+      transforms = next.transforms;
+      normalize();
+      notify();
+    },
+    reset(id) {
+      ensure();
+      if (id !== void 0) known(id);
+      if (id !== void 0 ? !transforms[id] : !Object.keys(transforms).length)
+        return;
+      remember();
+      if (id !== void 0) delete transforms[id];
+      else transforms = /* @__PURE__ */ Object.create(null);
+      notify();
+    },
+    setVisible(value) {
+      ensure();
+      visible = value;
+      refresh();
+    },
+    undo() {
+      ensure();
+      if (!past.length) return;
+      future.push(clone(transforms));
+      transforms = past.pop();
+      notify();
+    },
+    redo() {
+      ensure();
+      if (!future.length) return;
+      past.push(clone(transforms));
+      transforms = future.pop();
+      notify();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      unsubscribe();
+      refresh();
+    }
+  };
+}
+
+// src/interactive-editor.ts
+var neutral2 = () => ({
+  x: 0,
+  y: 0,
+  rotation: 0,
+  scaleX: 1,
+  scaleY: 1
+});
+var copy = (v) => {
+  const out = JSON.parse(JSON.stringify(v));
+  if (out && typeof out === "object" && !Array.isArray(out))
+    Object.setPrototypeOf(out, null);
+  return out;
+};
+var mat = (w) => new Matrix(w.a, w.b, w.c, w.d, w.tx, w.ty);
+var rotate = (p, r) => ({
+  x: p.x * Math.cos(r) - p.y * Math.sin(r),
+  y: p.x * Math.sin(r) + p.y * Math.cos(r)
+});
+var pointIn = (p, v) => {
+  let inside = false;
+  for (let i = 0, j = v.length - 2; i < v.length; j = i, i += 2) {
+    const x = v[i], y = v[i + 1], xx = v[j], yy = v[j + 1];
+    if (y > p.y !== yy > p.y && p.x < (xx - x) * (p.y - y) / (yy - y) + x)
+      inside = !inside;
+  }
+  return inside;
+};
+function createInteractiveEditor(options) {
+  const { player, overlay } = options, ctx = overlay.getContext("2d");
+  if (!ctx) throw Error("A 2D overlay context is required.");
+  if (!options.documentId) throw Error("documentId is required.");
+  if (options.historyLimit !== void 0 && (!Number.isInteger(options.historyLimit) || options.historyLimit < 1 || options.historyLimit > 1e4))
+    throw Error("historyLimit must be an integer from 1 to 10000");
+  const members = /* @__PURE__ */ new Map(), groups = /* @__PURE__ */ new Map(), attachments = new Set(
+    player.doc.attachments.filter((a) => a.type !== "path").map((a) => a.id)
+  );
+  for (const g of options.groups ?? []) {
+    if (!g.id || groups.has(g.id) || !g.members.length)
+      throw Error("Invalid or duplicate editor group");
+    for (const id of g.members) {
+      if (!attachments.has(id) || members.has(id))
+        throw Error("Unknown or multiply grouped attachment: " + id);
+      members.set(id, g.id);
+    }
+    if (g.pivotBone && !player.doc.bones.some((b) => b.id === g.pivotBone))
+      throw Error("Unknown group pivot bone");
+    groups.set(g.id, { ...g, members: [...g.members] });
+  }
+  for (const id of attachments)
+    if (!members.has(id)) {
+      if (groups.has(id))
+        throw Error("Group id collides with an ungrouped attachment");
+      groups.set(id, { id, members: [id] });
+      members.set(id, id);
+    }
+  let transforms = /* @__PURE__ */ Object.create(null), past = [], future = [], selected = null, hovered = null, enabled = true, visible = true, disposed = false;
+  let drag = null;
+  const abort = new AbortController(), prior = {
+    pointerEvents: overlay.style.pointerEvents,
+    touchAction: overlay.style.touchAction,
+    cursor: overlay.style.cursor
+  };
+  overlay.style.pointerEvents = "auto";
+  overlay.style.touchAction = "none";
+  const alphaCache = /* @__PURE__ */ new WeakMap();
+  const project = (p) => options.documentToOverlay?.(p) ?? player.view.worldTransform.apply(p);
+  const unproject = (p) => {
+    if (options.screenToDocument) return options.screenToDocument(p);
+    const r = overlay.getBoundingClientRect();
+    return player.view.worldTransform.clone().invert().apply({
+      x: (p.x - r.left) * overlay.width / r.width,
+      y: (p.y - r.top) * overlay.height / r.height
+    });
+  };
+  const screen = (p) => {
+    const v = project(p), r = overlay.getBoundingClientRect();
+    return {
+      x: r.left + v.x * r.width / overlay.width,
+      y: r.top + v.y * r.height / overlay.height
+    };
+  };
+  const transformOf = (id) => ({ ...neutral2(), ...transforms[id] });
+  function ensure() {
+    if (disposed) throw Error("Interactive editor is disposed");
+  }
+  function known(id) {
+    if (!groups.has(id)) throw Error("Unknown editor part: " + id);
+  }
+  function shapes() {
+    return player.renderItems.filter(
+      (i) => i.node.visible && i.node.alpha > 0 && i.att.type !== "path"
+    ).map((it, order) => {
+      const n = it.node;
+      n.updateLocalTransform();
+      let p, uv, ind;
+      if ("geometry" in n) {
+        p = Array.from(n.geometry.getBuffer("aPosition").data);
+        uv = Array.from(n.geometry.getBuffer("aUV").data);
+        ind = Array.from(n.geometry.indexBuffer.data);
+      } else {
+        const t = n.texture, u = t.uvs, a = n.anchor, trim = t.trim, x = (trim?.x ?? 0) - a.x * t.orig.width, y = (trim?.y ?? 0) - a.y * t.orig.height, w = trim?.width ?? t.orig.width, h = trim?.height ?? t.orig.height;
+        p = [x, y, x + w, y, x + w, y + h, x, y + h];
+        uv = [u.x0, u.y0, u.x1, u.y1, u.x2, u.y2, u.x3, u.y3];
+        ind = [0, 1, 2, 0, 2, 3];
+      }
+      const points = [];
+      for (let i = 0; i < p.length; i += 2)
+        points.push(n.localTransform.apply({ x: p[i], y: p[i + 1] }));
+      return {
+        id: members.get(it.att.id),
+        points,
+        uvs: uv,
+        indices: ind,
+        node: it.node,
+        slot: it.slot,
+        z: n.zIndex,
+        order
+      };
+    }).sort((a, b) => a.z - b.z || a.order - b.order);
+  }
+  function alpha(n, u, v) {
+    const source = n.texture.source;
+    if (!alphaCache.has(source)) {
+      try {
+        const resource = source.resource;
+        if (!resource) throw Error("Texture has no readable image resource");
+        const c = document.createElement("canvas");
+        c.width = source.pixelWidth ?? source.width;
+        c.height = source.pixelHeight ?? source.height;
+        const cx = c.getContext("2d");
+        cx.drawImage(resource, 0, 0, c.width, c.height);
+        alphaCache.set(source, {
+          width: c.width,
+          height: c.height,
+          data: cx.getImageData(0, 0, c.width, c.height).data
+        });
+      } catch (e) {
+        alphaCache.set(source, null);
+        options.onError?.(
+          new Error(
+            "Texture alpha cannot be read (CORS or unsupported source): " + String(e)
+          )
+        );
+      }
+    }
+    const a = alphaCache.get(source);
+    if (!a) return options.alphaFallback === "geometry";
+    if (u < 0 || v < 0 || u > 1 || v > 1) return false;
+    const x = u * a.width - 0.5, y = v * a.height - 0.5, x0 = Math.floor(x), y0 = Math.floor(y), fx = x - x0, fy = y - y0;
+    let value = 0;
+    for (let dy = 0; dy < 2; dy++)
+      for (let dx = 0; dx < 2; dx++) {
+        const xx = Math.max(0, Math.min(a.width - 1, x0 + dx)), yy = Math.max(0, Math.min(a.height - 1, y0 + dy));
+        value += a.data[(yy * a.width + xx) * 4 + 3] * (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy);
+      }
+    return value >= 24;
+  }
+  function hitTest(p) {
+    ensure();
+    const all = shapes();
+    for (let s = all.length - 1; s >= 0; s--) {
+      const a = all[s], clip = a.slot.clip && player.clipPolygons.get(a.slot.clip);
+      if (clip && !pointIn(p, clip)) continue;
+      for (let i = 0; i < a.indices.length; i += 3) {
+        const ia = a.indices[i], ib = a.indices[i + 1], ic = a.indices[i + 2], A = a.points[ia], B = a.points[ib], C = a.points[ic], den = (B.y - C.y) * (A.x - C.x) + (C.x - B.x) * (A.y - C.y);
+        if (Math.abs(den) < 1e-10) continue;
+        const wa = ((B.y - C.y) * (p.x - C.x) + (C.x - B.x) * (p.y - C.y)) / den, wb = ((C.y - A.y) * (p.x - C.x) + (A.x - C.x) * (p.y - C.y)) / den, wc = 1 - wa - wb;
+        if (Math.min(wa, wb, wc) < -1e-7) continue;
+        if (alpha(
+          a.node,
+          wa * a.uvs[ia * 2] + wb * a.uvs[ib * 2] + wc * a.uvs[ic * 2],
+          wa * a.uvs[ia * 2 + 1] + wb * a.uvs[ib * 2 + 1] + wc * a.uvs[ic * 2 + 1]
+        ))
+          return a.id;
+      }
+    }
+    return null;
+  }
+  function pivot(id) {
+    const g = groups.get(id);
+    const a = player.doc.attachments.find((a2) => a2.id === g.members[0]), slot = player.doc.slots.find((s) => s.id === a.slot);
+    const w = player.world.get(g.pivotBone ?? slot.bone);
+    if (!w || !Number.isFinite(w.a * w.d - w.b * w.c) || Math.abs(w.a * w.d - w.b * w.c) < 1e-10)
+      return null;
+    return mat(w);
+  }
+  function frame(id) {
+    const viewport = overlay.getBoundingClientRect();
+    if (!viewport.width || !viewport.height) return null;
+    const points = shapes().filter((s) => s.id === id).flatMap((s) => s.points);
+    if (!points.length) return null;
+    const W = pivot(id);
+    if (!W) return null;
+    const inv = W.clone().invert(), o = transformOf(id), r = o.rotation * Math.PI / 180, q = points.map((p) => {
+      const p0 = inv.apply(p);
+      return rotate({ x: p0.x - o.x, y: p0.y - o.y }, -r);
+    }), x0 = Math.min(...q.map((p) => p.x)), x1 = Math.max(...q.map((p) => p.x)), y0 = Math.min(...q.map((p) => p.y)), y1 = Math.max(...q.map((p) => p.y)), cx = (x0 + x1) / 2, cy = (y0 + y1) / 2, toWorld = (p) => {
+      const v = rotate(p, r);
+      return W.apply({ x: v.x + o.x, y: v.y + o.y });
+    };
+    const handles = [
+      ["nw", x0, y0],
+      ["n", cx, y0],
+      ["ne", x1, y0],
+      ["e", x1, cy],
+      ["se", x1, y1],
+      ["s", cx, y1],
+      ["sw", x0, y1],
+      ["w", x0, cy]
+    ].map(([name, x, y]) => ({
+      name: String(name),
+      p: toWorld({ x: Number(x), y: Number(y) })
+    })), center = toWorld({ x: cx, y: cy }), top = handles[1].p, st = screen(top), sc = screen(center), d = Math.hypot(st.x - sc.x, st.y - sc.y) || 1;
+    handles.push({
+      name: "rotate",
+      p: unproject({
+        x: st.x + (st.x - sc.x) / d * 28,
+        y: st.y + (st.y - sc.y) / d * 28
+      })
+    });
+    return {
+      id,
+      W,
+      inv,
+      o,
+      r,
+      x0,
+      x1,
+      y0,
+      y1,
+      cx,
+      cy,
+      center,
+      top,
+      handles,
+      corners: [handles[0].p, handles[2].p, handles[4].p, handles[6].p]
+    };
+  }
+  function draw() {
+    ctx.clearRect(0, 0, overlay.width, overlay.height);
+    if (!enabled || !visible) return;
+    const box = overlay.getBoundingClientRect(), sx = overlay.width / (box.width || overlay.width), sy = overlay.height / (box.height || overlay.height);
+    const outline = (id, color, controls) => {
+      const f = frame(id);
+      if (!f) return;
+      ctx.strokeStyle = color;
+      ctx.lineWidth = 1.5 * Math.min(sx, sy);
+      ctx.beginPath();
+      f.corners.map(project).forEach((p, i) => i ? ctx.lineTo(p.x, p.y) : ctx.moveTo(p.x, p.y));
+      ctx.closePath();
+      ctx.stroke();
+      if (controls) {
+        const top = project(f.top), rot = project(f.handles[8].p);
+        ctx.beginPath();
+        ctx.moveTo(top.x, top.y);
+        ctx.lineTo(rot.x, rot.y);
+        ctx.stroke();
+        for (const h of f.handles) {
+          const p = project(h.p);
+          ctx.beginPath();
+          h.name === "rotate" ? ctx.ellipse(p.x, p.y, 5 * sx, 5 * sy, 0, 0, Math.PI * 2) : ctx.rect(p.x - 4 * sx, p.y - 4 * sy, 8 * sx, 8 * sy);
+          ctx.fillStyle = "#17212c";
+          ctx.fill();
+          ctx.stroke();
+        }
+      }
+    };
+    if (hovered && hovered !== selected) outline(hovered, "#68d5fa", false);
+    if (selected) outline(selected, "#ffda81", true);
+  }
+  function apply() {
+    if (!visible) {
+      draw();
+      return;
+    }
+    for (const it of player.renderItems) {
+      if (!it.node.visible) continue;
+      const id = members.get(it.att.id), o = transforms[id];
+      if (!o) continue;
+      const W = pivot(id);
+      if (!W) continue;
+      const r = o.rotation * Math.PI / 180, D = W.clone().append(
+        new Matrix(
+          Math.cos(r) * o.scaleX,
+          Math.sin(r) * o.scaleX,
+          -Math.sin(r) * o.scaleY,
+          Math.cos(r) * o.scaleY,
+          o.x,
+          o.y
+        )
+      ).append(W.clone().invert());
+      it.node.updateLocalTransform();
+      it.node.setFromMatrix(D.append(it.node.localTransform.clone()));
+    }
+    if (enabled && hovered) {
+      for (const it of player.renderItems)
+        if (members.get(it.att.id) === hovered && it.node.visible)
+          it.node.tint = 12185087;
+    }
+    draw();
+  }
+  const unsubscribe = player.onAfterPose(apply);
+  const exportPatch = () => ({
+    format: "golem.interactive-edits",
+    version: 1,
+    documentId: options.documentId,
+    transforms: copy(transforms)
+  });
+  function refresh() {
+    player.refreshPose();
+    draw();
+    options.onRender?.();
+  }
+  function notify() {
+    refresh();
+    options.onChange?.(exportPatch());
+  }
+  function normalize() {
+    for (const [id, t] of Object.entries(transforms))
+      if (Object.entries(t).every(
+        ([k, v]) => v === neutral2()[k]
+      ))
+        delete transforms[id];
+  }
+  function remember() {
+    past.push(copy(transforms));
+    if (past.length > (options.historyLimit ?? 100)) past.shift();
+    future = [];
+  }
+  function validateTransform(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw Error("Invalid transform");
+    const out = neutral2();
+    for (const [k, v] of Object.entries(value)) {
+      if (!Object.hasOwn(out, k) || typeof v !== "number" || !Number.isFinite(v) || Math.abs(v) > 1e4 || k.startsWith("scale") && (v < 0.1 || v > 4))
+        throw Error("Invalid transform parameter: " + k);
+      out[k] = v;
+    }
+    return out;
+  }
+  function select(id) {
+    ensure();
+    if (id !== null) known(id);
+    selected = id;
+    options.onSelection?.(id);
+    draw();
+  }
+  function handleAt(p, f) {
+    return f?.handles.find((h) => {
+      const s = screen(h.p);
+      return Math.hypot(p.x - s.x, p.y - s.y) < 9;
+    });
+  }
+  const down = (e) => {
+    if (!enabled || !visible || e.button !== 0 || drag) return;
+    const client = { x: e.clientX, y: e.clientY }, q = unproject(client);
+    let f = selected ? frame(selected) : null, h = handleAt(client, f);
+    if (!h) {
+      select(hitTest(q));
+      if (!selected) return;
+      f = frame(selected);
+    }
+    if (!f) return;
+    options.onGestureStart?.();
+    drag = {
+      id: selected,
+      mode: h?.name ?? "move",
+      f,
+      start: f.inv.apply(q),
+      client,
+      initial: transformOf(selected),
+      recorded: false,
+      pointerId: e.pointerId
+    };
+    overlay.setPointerCapture(e.pointerId);
+    e.preventDefault();
+  };
+  const move = (e) => {
+    if (!enabled || !visible || drag && drag.pointerId !== e.pointerId)
+      return;
+    const client = { x: e.clientX, y: e.clientY }, q = unproject(client);
+    if (!drag) {
+      const f2 = selected ? frame(selected) : null, h = handleAt(client, f2), next = h ? null : hitTest(q);
+      if (hovered !== next) {
+        hovered = next;
+        options.onHover?.(next);
+      }
+      if (h && f2) {
+        const a = screen(h.p), c = screen(f2.center), angle = (Math.atan2(a.y - c.y, a.x - c.x) * 180 / Math.PI + 180) % 180;
+        overlay.style.cursor = h.name === "rotate" ? "crosshair" : ["ew-resize", "nwse-resize", "ns-resize", "nesw-resize"][Math.round(angle / 45) % 4];
+      } else overlay.style.cursor = hovered ? "move" : "default";
+      refresh();
+      return;
+    }
+    const { f, initial: o } = drag;
+    if (!drag.recorded) {
+      if (Math.hypot(e.clientX - drag.client.x, e.clientY - drag.client.y) < 0.35)
+        return;
+      remember();
+      drag.recorded = true;
+    }
+    const p = f.inv.apply(q);
+    let n = { ...o };
+    if (drag.mode === "move") {
+      n.x += p.x - drag.start.x;
+      n.y += p.y - drag.start.y;
+    } else if (drag.mode === "rotate") {
+      const c = f.inv.apply(f.center), a0 = Math.atan2(drag.start.y - c.y, drag.start.x - c.x), a1 = Math.atan2(p.y - c.y, p.x - c.x);
+      n.rotation = o.rotation + Math.atan2(Math.sin(a1 - a0), Math.cos(a1 - a0)) * 180 / Math.PI;
+      const v = rotate({ x: f.cx, y: f.cy }, n.rotation * Math.PI / 180);
+      n.x = c.x - v.x;
+      n.y = c.y - v.y;
+    } else {
+      const mode = drag.mode, p0 = rotate({ x: p.x - o.x, y: p.y - o.y }, -f.r), s0 = rotate({ x: drag.start.x - o.x, y: drag.start.y - o.y }, -f.r), ax = mode.includes("e") ? f.x0 : mode.includes("w") ? f.x1 : f.cx, ay = mode.includes("s") ? f.y0 : mode.includes("n") ? f.y1 : f.cy;
+      let fx = /[ew]/.test(mode) ? (p0.x - ax) / (s0.x - ax || 1) : 1, fy = /[ns]/.test(mode) ? (p0.y - ay) / (s0.y - ay || 1) : 1;
+      n.scaleX = Math.max(0.1, Math.min(4, o.scaleX * fx));
+      n.scaleY = Math.max(0.1, Math.min(4, o.scaleY * fy));
+      fx = n.scaleX / o.scaleX;
+      fy = n.scaleY / o.scaleY;
+      const a = rotate({ x: ax, y: ay }, f.r), b = rotate({ x: ax * fx, y: ay * fy }, f.r);
+      n.x = o.x + a.x - b.x;
+      n.y = o.y + a.y - b.y;
+    }
+    for (const k of ["x", "y", "rotation"])
+      n[k] = Number.isFinite(n[k]) ? Math.max(-1e4, Math.min(1e4, n[k])) : o[k];
+    transforms[drag.id] = validateTransform(n);
+    normalize();
+    notify();
+  };
+  const end = (event) => {
+    if (!drag || event && event.pointerId !== drag.pointerId) return;
+    const id = drag.pointerId;
+    drag = null;
+    if (overlay.hasPointerCapture(id)) overlay.releasePointerCapture(id);
+  };
+  const listen = (name, fn) => overlay.addEventListener(name, fn, { signal: abort.signal });
+  listen("pointerdown", down);
+  listen("pointermove", move);
+  listen("pointerup", end);
+  listen("pointercancel", end);
+  listen("lostpointercapture", end);
+  listen("pointerleave", () => {
+    if (!drag) {
+      hovered = null;
+      options.onHover?.(null);
+      refresh();
+    }
+  });
+  refresh();
+  return {
+    select,
+    hitTest,
+    getFrame: (id) => {
+      ensure();
+      known(id);
+      return frame(id);
+    },
+    getTransform: (id) => {
+      ensure();
+      known(id);
+      return transformOf(id);
+    },
+    get selection() {
+      return selected;
+    },
+    get canUndo() {
+      return past.length > 0;
+    },
+    get canRedo() {
+      return future.length > 0;
+    },
+    exportPatch,
+    setEnabled(value) {
+      ensure();
+      end();
+      enabled = value;
+      hovered = null;
+      overlay.style.pointerEvents = value ? "auto" : "none";
+      refresh();
+    },
+    setVisible(value) {
+      ensure();
+      end();
+      visible = value;
+      refresh();
+    },
+    setTransform(id, value) {
+      ensure();
+      known(id);
+      const t = validateTransform({ ...transformOf(id), ...value });
+      if (JSON.stringify(t) === JSON.stringify(transformOf(id))) return;
+      remember();
+      transforms[id] = t;
+      normalize();
+      notify();
+    },
+    reset(id) {
+      ensure();
+      if (id !== void 0) known(id);
+      if (id !== void 0 ? !transforms[id] : !Object.keys(transforms).length)
+        return;
+      remember();
+      if (id !== void 0) delete transforms[id];
+      else transforms = /* @__PURE__ */ Object.create(null);
+      notify();
+    },
+    undo() {
+      ensure();
+      if (!past.length) return;
+      future.push(copy(transforms));
+      transforms = past.pop();
+      notify();
+    },
+    redo() {
+      ensure();
+      if (!future.length) return;
+      past.push(copy(transforms));
+      transforms = future.pop();
+      notify();
+    },
+    importPatch(value) {
+      ensure();
+      if (!value || typeof value !== "object") throw Error("Invalid patch");
+      const v = value;
+      if (v.format !== "golem.interactive-edits" || v.version !== 1 || v.documentId !== options.documentId)
+        throw Error("Patch format/version/document mismatch");
+      if (!v.transforms || typeof v.transforms !== "object" || Array.isArray(v.transforms))
+        throw Error("Invalid transforms");
+      const next = /* @__PURE__ */ Object.create(null);
+      for (const [id, t] of Object.entries(v.transforms)) {
+        known(id);
+        next[id] = validateTransform(t);
+      }
+      remember();
+      transforms = next;
+      normalize();
+      notify();
+    },
+    dispose() {
+      if (disposed) return;
+      end();
+      disposed = true;
+      abort.abort();
+      unsubscribe();
+      player.refreshPose();
+      ctx.clearRect(0, 0, overlay.width, overlay.height);
+      Object.assign(overlay.style, prior);
+      options.onRender?.();
+    }
+  };
+}
+export {
+  createInteractiveBoneEditor,
+  createInteractiveEditor
+};
+//# sourceMappingURL=interactive-editor.js.map