1681-engine 0.5.8 → 0.5.10

package/dist/core/Clock.js

@@ -1,30 +1,40 @@
-class o {
+import { runDue as o } from "./runDue.js";
+class i {
+  constructor(e, r) {
+    this.at = e, this.fn = r;
+  }
+  at;
+  fn;
+  removed = !1;
+  /** An arrow, so a handle's `remove` still works when taken off it (`const { remove } = …`). */
+  remove = () => {
+    this.removed = !0;
+  };
+}
+class h {
   now = performance.now();
+  /** Told of every error a timer throws (default: logged). `Stage` routes it into its guarded-step reporting. */
+  onError = (e) => console.error("[timer] failed", e);
   timers = [];
-  delayedCall(r, t) {
-    const e = { at: this.now + r, fn: t, removed: !1 };
-    return this.timers.push(e), { remove: () => {
-      e.removed = !0;
-    } };
+  due = [];
+  /** Made once, so `update` hands `runDue` no fresh closure; reads `onError` late so it may be swapped any time. */
+  report = (e) => this.onError(e);
+  delayedCall(e, r) {
+    const t = new i(this.now + e, r);
+    return this.timers.push(t), t;
+  }
+  /** Timers waiting to run (removed ones not yet swept included). */
+  get pending() {
+    return this.timers.length;
   }
-  update(r) {
-    this.now = r;
-    const t = this.timers.filter((e) => !e.removed && e.at <= r);
-    if (t.length) {
-      this.timers = this.timers.filter((e) => !e.removed && e.at > r);
-      for (const e of t)
-        try {
-          e.fn();
-        } catch (s) {
-          console.error("[timer] failed", s);
-        }
-    }
+  update(e) {
+    this.now = e, o(this.timers, this.due, e, this.report);
   }
   clear() {
-    this.timers = [];
+    for (const e of this.due) e.removed = !0;
+    this.timers.length = 0;
   }
 }
 export {
-  o as Clock
+  h as Clock
 };
-//# sourceMappingURL=Clock.js.map

package/dist/core/Graphics.js

@@ -66,4 +66,3 @@ class u extends o(n) {
 export {
   u as Graphics
 };
-//# sourceMappingURL=Graphics.js.map

package/dist/core/Group.js

@@ -26,4 +26,3 @@ class a extends i(r) {
 export {
   a as Group
 };
-//# sourceMappingURL=Group.js.map

package/dist/core/Image.js

@@ -48,4 +48,3 @@ class o extends a(h) {
 export {
   o as Image
 };
-//# sourceMappingURL=Image.js.map

package/dist/core/ObjectFactory.js

@@ -52,4 +52,3 @@ class L {
 export {
   L as ObjectFactory
 };
-//# sourceMappingURL=ObjectFactory.js.map

package/dist/core/Pointer.js

@@ -1,25 +1,26 @@
-import { isTouchUi as b } from "../platform/touch.js";
-function s(r) {
-  return r === 1 ? 4 : r === 2 ? 2 : r === 0 ? 1 : 0;
+import { isTouchUi as v } from "../platform/touch.js";
+import { isPointerLocked as m, requestPointerLock as d, exitPointerLock as a } from "../platform/pointerLock.js";
+function s(e) {
+  return e === 1 ? 4 : e === 2 ? 2 : e === 0 ? 1 : 0;
 }
-class l {
-  constructor(n) {
-    this.canvas = n;
-    const i = b(), o = (t, e, c) => {
-      const h = (u) => {
-        i && u instanceof PointerEvent && u.pointerType === "touch" || c(u);
+class c {
+  constructor(o) {
+    this.canvas = o;
+    const i = v(), n = (t, u, l) => {
+      const h = (r) => {
+        i && r instanceof PointerEvent && r.pointerType === "touch" || l(r);
       };
-      t.addEventListener(e, h), this.cleanup.push(() => t.removeEventListener(e, h));
+      t.addEventListener(u, h), this.cleanup.push(() => t.removeEventListener(u, h));
     };
-    o(n, "pointerdown", (t) => {
-      this.track(t), !l.ignorePress?.(t) && (this.buttons |= s(t.button));
-    }), o(window, "pointermove", (t) => {
-      this.track(t), t.button >= 0 && (this.buttons = (t.buttons & s(t.button)) !== 0 ? this.buttons | s(t.button) : this.buttons & ~s(t.button));
-    }), o(window, "pointerup", (t) => {
+    n(o, "pointerdown", (t) => {
+      this.track(t), !c.ignorePress?.(t) && (this.buttons |= s(t.button));
+    }), n(window, "pointermove", (t) => {
+      this.locked ? (this.moveX += t.movementX, this.moveY += t.movementY) : this.track(t), t.button >= 0 && (this.buttons = (t.buttons & s(t.button)) !== 0 ? this.buttons | s(t.button) : this.buttons & ~s(t.button));
+    }), n(window, "pointerup", (t) => {
       this.buttons &= ~s(t.button);
-    }), o(window, "blur", () => {
+    }), n(window, "blur", () => {
       this.buttons = 0;
-    }), o(n, "contextmenu", (t) => t.preventDefault());
+    }), n(o, "contextmenu", (t) => t.preventDefault());
   }
   canvas;
   /**
@@ -33,6 +34,9 @@ class l {
   worldX = 0;
   worldY = 0;
   buttons = 0;
+  /** Raw mouse travel (`movementX/Y`) summed since the last `takeMovement`, kept only while the pointer is locked. */
+  moveX = 0;
+  moveY = 0;
   cleanup = [];
   leftButtonDown() {
     return (this.buttons & 1) !== 0;
@@ -40,19 +44,37 @@ class l {
   rightButtonDown() {
     return (this.buttons & 2) !== 0;
   }
-  updateWorldPoint(n) {
-    this.worldX = n.scrollX + this.x / n.zoom, this.worldY = n.scrollY + this.y / n.zoom;
+  /** True while the canvas holds the pointer (`lock`). */
+  get locked() {
+    return m(this.canvas);
+  }
+  /**
+   * Locks the pointer to the canvas for mouse-look: the cursor hides and `takeMovement` returns how far the mouse went.
+   * Call from a press or key handler (browsers allow it only in a gesture); resolves whether the lock holds.
+   */
+  lock(o = {}) {
+    return this.moveX = this.moveY = 0, d(this.canvas, o);
+  }
+  unlock() {
+    this.locked && a();
+  }
+  /** The mouse travel (CSS pixels) since the last call while locked, then zeroed; read it once per step. */
+  takeMovement() {
+    const o = { x: this.moveX, y: this.moveY };
+    return this.moveX = this.moveY = 0, o;
+  }
+  updateWorldPoint(o) {
+    this.worldX = o.scrollX + this.x / o.zoom, this.worldY = o.scrollY + this.y / o.zoom;
   }
   destroy() {
-    for (const n of this.cleanup) n();
+    for (const o of this.cleanup) o();
     this.cleanup.length = 0;
   }
-  track(n) {
+  track(o) {
     const i = this.canvas.getBoundingClientRect();
-    this.x = n.clientX - i.left, this.y = n.clientY - i.top;
+    this.x = o.clientX - i.left, this.y = o.clientY - i.top;
   }
 }
 export {
-  l as Pointer
+  c as Pointer
 };
-//# sourceMappingURL=Pointer.js.map

package/dist/core/Rectangle.js

@@ -48,4 +48,3 @@ class c extends l(e) {
 export {
   c as Rectangle
 };
-//# sourceMappingURL=Rectangle.js.map

package/dist/core/Stage.js

@@ -1,12 +1,12 @@
 import { Container as r } from "pixi.js";
-import { Camera as h } from "./Camera.js";
+import { Camera as n } from "./Camera.js";
 import { Clock as a } from "./Clock.js";
 import { ObjectFactory as o } from "./ObjectFactory.js";
 import { Pointer as c } from "./Pointer.js";
 import { Tweener as d } from "./Tweener.js";
-class n {
+class h {
   constructor(e, t) {
-    this.app = e, this.textures = t, e.stage.addChild(this.world, this.screen), this.cameras = { main: new h(this.world, this.screen) }, this.input = { activePointer: new c(e.canvas) }, this.syncSize();
+    this.app = e, this.textures = t, e.stage.addChild(this.world, this.screen), this.cameras = { main: new n(this.world, this.screen) }, this.input = { activePointer: new c(e.canvas) }, this.time.onError = (i) => this.caught("timers", i), this.syncSize();
   }
   app;
   textures;
@@ -67,7 +67,7 @@ class n {
   /** What a guarded step threw: logged once per distinct error, or a fault repeating every frame floods the log at 60 a second. */
   caught(e, t) {
     const i = `${e}|${t instanceof Error ? t.message : String(t)}`;
-    this.reported.has(i) || (this.reported.add(i), console.error(`[frame] ${e} failed`, t), n.onCaught?.(`[frame] ${e}`, t));
+    this.reported.has(i) || (this.reported.add(i), console.error(`[frame] ${e} failed`, t), h.onCaught?.(`[frame] ${e}`, t));
   }
   destroy() {
     this.tweens.clear(), this.time.clear(), this.input.activePointer.destroy(), this.world.destroy({ children: !0, context: !0 }), this.screen.destroy({ children: !0, context: !0 });
@@ -81,6 +81,5 @@ class n {
   }
 }
 export {
-  n as Stage
+  h as Stage
 };
-//# sourceMappingURL=Stage.js.map

package/dist/core/Text.js

@@ -19,4 +19,3 @@ class d extends f(e) {
 export {
   d as Text
 };
-//# sourceMappingURL=Text.js.map

package/dist/core/TextureRegistry.js

@@ -1,7 +1,7 @@
-import { CanvasSource as m, Texture as d, Rectangle as l } from "pixi.js";
+import { CanvasSource as f, Texture as d, Rectangle as u } from "pixi.js";
 class v {
   constructor(t, s) {
-    this.key = t, this.canvas = s, this.source = new m({ resource: s, scaleMode: "nearest" }), this.whole = new d({ source: this.source });
+    this.key = t, this.canvas = s, this.source = new f({ resource: s, scaleMode: "nearest" }), this.whole = new d({ source: this.source });
   }
   key;
   canvas;
@@ -18,8 +18,24 @@ class v {
     return this.canvas.getContext("2d");
   }
   /** Adds a frame cut from the canvas (`_source` kept for the old call shape). */
-  add(t, s, e, a, o, h) {
-    this.frames.get(t)?.destroy(), this.frames.set(t, new d({ source: this.source, frame: new l(e, a, o, h) }));
+  add(t, s, e, a, n, i) {
+    this.frames.get(t)?.destroy(), this.frames.set(t, new d({ source: this.source, frame: new u(e, a, n, i) }));
+  }
+  /**
+   * Adds a packed frame cut from `page` (this texture's canvas by default): trimmed frames keep their untrimmed size
+   * (`orig`) so they line up when drawn, and frames the packer turned are turned back (Pixi's `rotate: 2`).
+   */
+  addPacked(t, s = this) {
+    this.frames.get(t.name)?.destroy();
+    const e = new d({
+      source: s.source,
+      frame: new u(t.x, t.y, t.w, t.h),
+      orig: new u(0, 0, t.sourceW, t.sourceH),
+      ...t.trim ? { trim: new u(t.trim.x, t.trim.y, t.trim.w, t.trim.h) } : {},
+      rotate: t.rotated ? 2 : 0,
+      ...t.anchor ? { defaultAnchor: t.anchor } : {}
+    });
+    this.frames.set(t.name, e);
   }
   /**
    * Registers under this texture a frame that lives on another one (an atlas page after the first), so the frame is
@@ -37,7 +53,7 @@ class v {
     this.frames.clear(), this.whole.destroy(), this.source.destroy();
   }
 }
-class x {
+class m {
   textures = /* @__PURE__ */ new Map();
   /** Textures repainted or freed while in use (a rig body, its hand): a copy of one must snapshot it first. */
   live = /* @__PURE__ */ new Set();
@@ -51,28 +67,28 @@ class x {
   }
   /** A new texture holding frame `frame` of `key` as it is painted right now; returns its key (one frame, '0'). */
   snapshot(t, s) {
-    const e = this.get(t, s), { x: a, y: o, width: h, height: r } = e.frame, i = document.createElement("canvas");
-    i.width = h, i.height = r;
-    const n = this.textures.get(t)?.canvas;
-    n && i.getContext("2d").drawImage(n, a, o, h, r, 0, 0, h, r);
+    const e = this.get(t, s), { x: a, y: n, width: i, height: r } = e.frame, h = document.createElement("canvas");
+    h.width = i, h.height = r;
+    const o = this.textures.get(t)?.canvas;
+    o && h.getContext("2d").drawImage(o, a, n, i, r, 0, 0, i, r);
     const c = `${t}#still${++this.snapshots}`;
-    return this.addCanvas(c, i).add("0", 0, 0, 0, h, r), c;
+    return this.addCanvas(c, h).add("0", 0, 0, 0, i, r), c;
   }
   /**
    * `snapshot` into a texture kept for reuse (`into`): its canvas is repainted in place and uploaded again, and only
    * made anew when the frame's size changes. Frame '0' is the copy.
    */
   snapshotInto(t, s, e) {
-    const a = this.get(t, s), { x: o, y: h, width: r, height: i } = a.frame;
-    let n = this.textures.get(e);
-    if (!n || n.width !== r || n.height !== i) {
-      const u = document.createElement("canvas");
-      u.width = r, u.height = i, n = this.addCanvas(e, u), n.add("0", 0, 0, 0, r, i);
+    const a = this.get(t, s), { x: n, y: i, width: r, height: h } = a.frame;
+    let o = this.textures.get(e);
+    if (!o || o.width !== r || o.height !== h) {
+      const g = document.createElement("canvas");
+      g.width = r, g.height = h, o = this.addCanvas(e, g), o.add("0", 0, 0, 0, r, h);
     }
-    const c = n.context;
-    c.clearRect(0, 0, r, i);
-    const g = this.textures.get(t)?.canvas;
-    g && c.drawImage(g, o, h, r, i, 0, 0, r, i), n.refresh();
+    const c = o.context;
+    c.clearRect(0, 0, r, h);
+    const w = this.textures.get(t)?.canvas;
+    w && c.drawImage(w, n, i, r, h, 0, 0, r, h), o.refresh();
   }
   exists(t) {
     return this.textures.has(t);
@@ -84,11 +100,26 @@ class x {
   }
   /** A canvas cut into equal frames named 0, 1, 2... left to right, then row by row. */
   addSpriteSheet(t, s, e) {
-    const a = this.addCanvas(t, s), o = Math.floor(s.width / e.frameWidth), h = Math.floor(s.height / e.frameHeight);
-    for (let r = 0; r < o * h; r++)
-      a.add(String(r), 0, r % o * e.frameWidth, Math.floor(r / o) * e.frameHeight, e.frameWidth, e.frameHeight);
+    const a = this.addCanvas(t, s), n = Math.floor(s.width / e.frameWidth), i = Math.floor(s.height / e.frameHeight);
+    for (let r = 0; r < n * i; r++)
+      a.add(String(r), 0, r % n * e.frameWidth, Math.floor(r / n) * e.frameHeight, e.frameWidth, e.frameHeight);
     return a;
   }
+  /**
+   * A packed atlas (TexturePacker JSON, `AssetLoader.atlas`): the first page under `key`, the others as `key~1`,
+   * `key~2`… like `AtlasBuilder`'s pages, and every frame of every page found under `key` by its name.
+   */
+  addAtlas(t, s) {
+    if (s.length === 0) throw new Error(`TextureRegistry: atlas "${t}" has no pages`);
+    for (let a = 1; this.textures.has(`${t}~${a}`); a++)
+      this.remove(`${t}~${a}`);
+    const e = this.addCanvas(t, s[0].canvas);
+    return s.forEach((a, n) => {
+      const i = n === 0 ? e : this.addCanvas(`${t}~${n}`, a.canvas);
+      for (const r of a.frames)
+        i !== e && i.addPacked(r), e.addPacked(r, i);
+    }), e;
+  }
   createCanvas(t, s, e) {
     const a = document.createElement("canvas");
     return a.width = s, a.height = e, this.addCanvas(t, a);
@@ -106,6 +137,5 @@ class x {
 }
 export {
   v as CanvasTexture,
-  x as TextureRegistry
+  m as TextureRegistry
 };
-//# sourceMappingURL=TextureRegistry.js.map

package/dist/core/Timeline.js

@@ -208,4 +208,3 @@ class c extends p {
 export {
   c as Timeline
 };
-//# sourceMappingURL=Timeline.js.map

package/dist/core/TimelineBuilder.js

@@ -70,4 +70,3 @@ class x {
 export {
   x as TimelineBuilder
 };
-//# sourceMappingURL=TimelineBuilder.js.map

package/dist/core/TimelineChild.js

@@ -81,4 +81,3 @@ export {
   m as TimelineChild,
   p as crossed
 };
-//# sourceMappingURL=TimelineChild.js.map

package/dist/core/Tweener.js

@@ -133,4 +133,3 @@ export {
   k as Tween,
   O as Tweener
 };
-//# sourceMappingURL=Tweener.js.map

package/dist/core/atlas.js

@@ -35,4 +35,3 @@ class H {
 export {
   H as AtlasBuilder
 };
-//# sourceMappingURL=atlas.js.map

package/dist/core/atlasPlan.js

@@ -19,4 +19,3 @@ export {
   w as atlasPageLimit,
   D as planAtlas
 };
-//# sourceMappingURL=atlasPlan.js.map

package/dist/core/blendLayer.js

@@ -0,0 +1,11 @@
+const h = /* @__PURE__ */ new WeakMap();
+function r(n, d = {}) {
+  const a = d.blend ?? "add", l = d.name ?? a;
+  let t = h.get(n);
+  t || (t = /* @__PURE__ */ new Map(), h.set(n, t));
+  let e = t.get(l);
+  return !e || e.destroyed ? (e = n.add.container(0, 0).setDepth(d.depth ?? 999e3), e.blendMode = a, t.set(l, e)) : d.depth !== void 0 && e.depth !== d.depth && e.setDepth(d.depth), e;
+}
+export {
+  r as blendLayer
+};

package/dist/core/eases.js

@@ -18,4 +18,3 @@ function o(n) {
 export {
   o as easeByName
 };
-//# sourceMappingURL=eases.js.map

package/dist/core/gameObject.js

@@ -1,15 +1,18 @@
-import { ColorMatrixFilter as n } from "pixi.js";
+import { ColorMatrixFilter as a } from "pixi.js";
 const e = /* @__PURE__ */ new Map();
-function a(i) {
-  let t = e.get(i);
+function o(s) {
+  let t = e.get(s);
   if (t) return t;
-  const s = new n();
-  s.antialias = "off";
-  const l = (i >> 16 & 255) / 255, r = (i >> 8 & 255) / 255, h = (i & 255) / 255;
-  return s.matrix = [0, 0, 0, 0, l, 0, 0, 0, 0, r, 0, 0, 0, 0, h, 0, 0, 0, 1, 0], e.set(i, t = [s]), t;
+  const i = new a();
+  i.antialias = "off";
+  const r = (s >> 16 & 255) / 255, h = (s >> 8 & 255) / 255, n = (s & 255) / 255;
+  return i.matrix = [0, 0, 0, 0, r, 0, 0, 0, 0, h, 0, 0, 0, 0, n, 0, 0, 0, 1, 0], e.set(s, t = [i]), t;
 }
-function u(i) {
-  return class extends i {
+function l(s) {
+  s.filters = null;
+}
+function f(s) {
+  return class extends s {
     scene;
     sx = 1;
     sy = 1;
@@ -54,8 +57,8 @@ function u(i) {
     applyScale() {
       this.destroyed || this.scale.set(this.sx * (this.fx ? -1 : 1), this.sy * (this.fy ? -1 : 1));
     }
-    setScale(t, s = t) {
-      return this.sx = t, this.sy = s, this.applyScale(), this;
+    setScale(t, i = t) {
+      return this.sx = t, this.sy = i, this.applyScale(), this;
     }
     setFlipX(t) {
       return this.flipX = t, this;
@@ -63,8 +66,8 @@ function u(i) {
     setFlipY(t) {
       return this.flipY = t, this;
     }
-    setFlip(t, s) {
-      return this.fx = t, this.fy = s, this.applyScale(), this;
+    setFlip(t, i) {
+      return this.fx = t, this.fy = i, this.applyScale(), this;
     }
     setDepth(t) {
       return this.zIndex = t, this;
@@ -75,8 +78,8 @@ function u(i) {
     setVisible(t) {
       return this.visible = t, this;
     }
-    setPosition(t = 0, s = t) {
-      return this.position.set(t, s), this;
+    setPosition(t = 0, i = t) {
+      return this.position.set(t, i), this;
     }
     setRotation(t = 0) {
       return this.rotation = t, this;
@@ -92,24 +95,23 @@ function u(i) {
     }
     /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */
     setTintFill(t) {
-      return this.tint = 16777215, this.solidFillColor === t ? this : (this.solidFillColor = t, this.filters = a(t), this);
+      return this.tint = 16777215, this.solidFillColor === t ? this : (this.solidFillColor = t, this.filters = o(t), this);
     }
     clearTint() {
       return this.clearFill(), this.tint = 16777215, this;
     }
     clearFill() {
-      this.solidFillColor !== null && (this.filters = null, this.solidFillColor = null);
+      this.solidFillColor !== null && (l(this), this.solidFillColor = null);
     }
     /** 0 pins the object to the screen instead of the world (full-screen flashes). */
     setScrollFactor(t) {
       return t === 0 && this.scene.screen.addChild(this), this;
     }
     destroy() {
-      this.destroyed || (this.solidFillColor !== null && (this.filters = null), this.solidFillColor = null, super.destroy({ children: !0, context: !0 }));
+      this.destroyed || (this.solidFillColor !== null && l(this), this.solidFillColor = null, super.destroy({ children: !0, context: !0 }));
     }
   };
 }
 export {
-  u as GameObject
+  f as GameObject
 };
-//# sourceMappingURL=gameObject.js.map

package/dist/core/pixelZoom.js

@@ -0,0 +1,43 @@
+const h = { pxPerStep: 290, baseMin: 2, baseMax: 5, min: 1, max: 6, halfZoom: 1.5 };
+function u(o) {
+  return o ? { ...h, ...o } : h;
+}
+function M(o, r) {
+  const n = u(r);
+  return Math.max(n.baseMin, Math.min(n.baseMax, Math.round(o / n.pxPerStep)));
+}
+function c(o, r = 0, n) {
+  const e = u(n), t = Math.max(e.min, Math.min(e.max, M(o, e) + Math.round(r * 2) / 2));
+  return Number.isInteger(t) || t === e.halfZoom ? t : Math.round(t);
+}
+function l(o, r = [-2, -1, 0, 1], n = -2.5, e) {
+  const t = u(e), f = [...r];
+  if (t.halfZoom !== null) {
+    const a = t.halfZoom - M(o, t);
+    a < 0 && a >= n && f.push(a);
+  }
+  const m = /* @__PURE__ */ new Map();
+  for (const a of f) {
+    const s = c(o, a, t), i = m.get(s);
+    (i === void 0 || Math.abs(a) < Math.abs(i)) && m.set(s, a);
+  }
+  return [...m].map(([a, s]) => ({ offset: s, zoom: a })).sort((a, s) => a.zoom - s.zoom);
+}
+function b(o, r, n = 1.5, e = 4) {
+  if (Number.isInteger(o) || r < n) return 1;
+  for (let t = 2; t <= e; t++) {
+    const f = o * t;
+    if (Math.abs(f - Math.round(f)) < 1e-9) return t;
+  }
+  return 1;
+}
+function p(o, r, n, e) {
+  return o <= 0 || r <= 0 ? 1 : Math.max(1, Math.floor(Math.min(n / o, e / r)));
+}
+export {
+  M as baseZoom,
+  p as fitScale,
+  c as worldZoom,
+  b as zoomResolution,
+  l as zoomSteps
+};

package/dist/core/pixiPatches.js

@@ -15,4 +15,3 @@ function l() {
 export {
   l as patchPixi
 };
-//# sourceMappingURL=pixiPatches.js.map

package/dist/core/runDue.js

@@ -0,0 +1,28 @@
+function g(t, r, i, l) {
+  let o = 0;
+  for (let e = 0; e < t.length; e++) {
+    const n = t[e];
+    n.removed || (n.at <= i ? r.push(n) : t[o++] = n);
+  }
+  if (t.length = o, !!r.length)
+    try {
+      for (let e = 0; e < r.length; e++) {
+        const n = r[e];
+        if (!n.removed)
+          try {
+            n.fn();
+          } catch (f) {
+            try {
+              l(f);
+            } catch (u) {
+              console.error("[runDue] error handler failed", u);
+            }
+          }
+      }
+    } finally {
+      r.length = 0;
+    }
+}
+export {
+  g as runDue
+};

package/dist/core/silhouette.js

@@ -0,0 +1,49 @@
+import { Texture as h, CanvasSource as g } from "pixi.js";
+let c = /* @__PURE__ */ new WeakMap();
+const l = /* @__PURE__ */ new Set();
+function p(t, o = 16777215) {
+  let e = c.get(t);
+  const n = e?.get(o);
+  if (n && !n.destroyed) return n;
+  const u = t.source.resource, i = t.frame, s = Math.round(i.width), a = Math.round(i.height);
+  if (!u || s <= 0 || a <= 0 || t.rotate || typeof document > "u") return null;
+  const r = document.createElement("canvas");
+  r.width = s, r.height = a;
+  const f = r.getContext("2d");
+  if (!f) return null;
+  try {
+    f.drawImage(u, Math.round(i.x), Math.round(i.y), s, a, 0, 0, s, a);
+  } catch {
+    return null;
+  }
+  m(r, o);
+  const d = new h({
+    source: new g({ resource: r, scaleMode: t.source.scaleMode }),
+    orig: t.orig.clone(),
+    trim: t.trim ? t.trim.clone() : void 0
+  });
+  return e || (e = /* @__PURE__ */ new Map(), c.set(t, e)), e.set(o, d), l.add(d), d;
+}
+function m(t, o = 16777215) {
+  const e = t;
+  if (!e || typeof e.getContext != "function") return;
+  const n = e.getContext("2d");
+  n && (n.save(), n.globalCompositeOperation = "source-in", n.fillStyle = `#${(o & 16777215).toString(16).padStart(6, "0")}`, n.fillRect(0, 0, e.width, e.height), n.restore());
+}
+function y(t) {
+  if (t) {
+    const o = c.get(t);
+    if (!o) return;
+    for (const e of o.values())
+      l.delete(e), e.destroy(!0);
+    c.delete(t);
+    return;
+  }
+  for (const o of l) o.destroy(!0);
+  l.clear(), c = /* @__PURE__ */ new WeakMap();
+}
+export {
+  y as clearSilhouettes,
+  m as fillSolid,
+  p as solidSilhouette
+};

package/dist/core/timelinePlace.js

@@ -21,4 +21,3 @@ function b(s, e) {
 export {
   b as placeAt
 };
-//# sourceMappingURL=timelinePlace.js.map

package/dist/core/tweenProps.js

@@ -9,4 +9,3 @@ export {
   s as readProp,
   o as writeProp
 };
-//# sourceMappingURL=tweenProps.js.map

package/dist/debug/DebugOverlay.js

@@ -91,4 +91,3 @@ function b(l) {
 export {
   F as DebugOverlay
 };
-//# sourceMappingURL=DebugOverlay.js.map