1681-engine 0.5.10 → 0.6.1

package/dist/ai/behaviorTree.js

@@ -0,0 +1,198 @@
+class k {
+  constructor(t) {
+    this.root = t;
+  }
+  root;
+  /** A new agent on this tree, with memory of its own. */
+  agent() {
+    return new p(this.root);
+  }
+}
+class p {
+  constructor(t) {
+    this.root = t;
+  }
+  root;
+  now = 0;
+  memory = /* @__PURE__ */ new Map();
+  kept = /* @__PURE__ */ new Map();
+  /** Nodes that answered 'running' last time they ticked: the ones a halt must reach. */
+  open = /* @__PURE__ */ new Set();
+  last = /* @__PURE__ */ new Map();
+  seen = /* @__PURE__ */ new Map();
+  /** Ticks the tree once at time `now` (ms) and returns the root's answer. */
+  update(t, e) {
+    this.now = e, this.seen = /* @__PURE__ */ new Map();
+    const n = this.tick(this.root, t);
+    return this.last = this.seen, n;
+  }
+  /** Halts whatever is running and forgets all memory: the agent starts the tree afresh (it died, it was stunned). */
+  reset(t) {
+    this.halt(this.root, t), this.memory.clear(), this.kept.clear(), this.open.clear(), this.last.clear();
+  }
+  /** Whether a node is running for this agent now. */
+  isRunning(t) {
+    return this.open.has(t);
+  }
+  state(t, e) {
+    return this.memory.has(t) || this.memory.set(t, e()), this.memory.get(t);
+  }
+  lasting(t, e) {
+    return this.kept.has(t) || this.kept.set(t, e()), this.kept.get(t);
+  }
+  tick(t, e) {
+    const n = t.tick(e, this);
+    return this.seen.set(t, n), n === "running" ? this.open.add(t) : (this.open.delete(t), this.memory.delete(t)), n;
+  }
+  halt(t, e) {
+    if (this.open.has(t)) {
+      for (const n of t.children) this.halt(n, e);
+      t.halt?.(e, this), this.open.delete(t), this.memory.delete(t);
+    }
+  }
+  /** The tree as it ran on the last tick, depth first: for a debug overlay. */
+  trace() {
+    const t = [], e = (n, r) => {
+      t.push({ depth: r, kind: n.kind, name: n.name, status: this.last.get(n) ?? null });
+      for (const o of n.children) e(o, r + 1);
+    };
+    return e(this.root, 0), t;
+  }
+}
+function m(s) {
+  return s.map((t) => `${"  ".repeat(t.depth)}${t.name ?? t.kind} ${t.status ?? "·"}`).join(`
+`);
+}
+const u = (s, t, e, n = {}) => ({
+  kind: s,
+  children: t,
+  tick: e,
+  ...n
+});
+function w(...s) {
+  const t = u("sequence", s, (e, n) => {
+    const r = n.state(t, () => ({ i: 0 }));
+    for (; r.i < s.length; r.i++) {
+      const o = n.tick(s[r.i], e);
+      if (o !== "success") return o;
+    }
+    return "success";
+  });
+  return t;
+}
+function y(...s) {
+  const t = u("selector", s, (e, n) => {
+    const r = n.state(t, () => ({ i: 0 }));
+    for (; r.i < s.length; r.i++) {
+      const o = n.tick(s[r.i], e);
+      if (o !== "failure") return o;
+    }
+    return "failure";
+  });
+  return t;
+}
+function v(...s) {
+  return g("reactive-sequence", s, "success");
+}
+function M(...s) {
+  return g("reactive-selector", s, "failure");
+}
+function g(s, t, e) {
+  return u(s, t, (n, r) => {
+    for (let o = 0; o < t.length; o++) {
+      const i = r.tick(t[o], n);
+      if (i !== e) {
+        for (let c = o + 1; c < t.length; c++) r.halt(t[c], n);
+        return i;
+      }
+    }
+    return e;
+  });
+}
+function b(s, ...t) {
+  const e = Math.min(t.length, s.succeed ?? t.length), n = Math.min(t.length, s.fail ?? 1), r = u("parallel", t, (o, i) => {
+    const c = i.state(r, () => /* @__PURE__ */ new Map());
+    for (let a = 0; a < t.length; a++) {
+      if (c.has(a)) continue;
+      const h = i.tick(t[a], o);
+      h !== "running" && c.set(a, h);
+    }
+    let f = 0, l = 0;
+    for (const a of c.values()) a === "success" ? f++ : l++;
+    if (f < e && l < n) return "running";
+    for (const a of t) i.halt(a, o);
+    return f >= e ? "success" : "failure";
+  });
+  return r;
+}
+function q(s) {
+  return u("invert", [s], (t, e) => {
+    const n = e.tick(s, t);
+    return n === "success" ? "failure" : n === "failure" ? "success" : "running";
+  });
+}
+function A(s) {
+  return u("succeed", [s], (t, e) => e.tick(s, t) === "running" ? "running" : "success");
+}
+function S(s, t) {
+  const e = u("repeat", [t], (n, r) => {
+    const o = r.state(e, () => ({ n: 0 })), i = r.tick(t, n);
+    return i !== "success" ? i : (o.n++, o.n >= s ? "success" : "running");
+  });
+  return e;
+}
+function $(s, t) {
+  const e = u("retry", [t], (n, r) => {
+    const o = r.state(e, () => ({ n: 0 })), i = r.tick(t, n);
+    return i !== "failure" ? i : (o.n++, o.n >= s ? "failure" : "running");
+  });
+  return e;
+}
+function j(s, t) {
+  const e = u("cooldown", [t], (n, r) => {
+    const o = r.lasting(e, () => ({ readyAt: -1 / 0 }));
+    if (r.now < o.readyAt) return "failure";
+    const i = r.tick(t, n);
+    return i !== "running" && (o.readyAt = r.now + s), i;
+  });
+  return e;
+}
+function B(s, t) {
+  const e = u("timeout", [t], (n, r) => {
+    const o = r.state(e, () => ({ began: r.now }));
+    return r.now - o.began >= s ? (r.halt(t, n), "failure") : r.tick(t, n);
+  });
+  return e;
+}
+function H(s) {
+  const t = u("wait", [], (e, n) => {
+    const r = n.state(t, () => ({ began: n.now }));
+    return n.now - r.began >= s ? "success" : "running";
+  });
+  return t;
+}
+function T(s, t) {
+  return u("condition", [], (e) => t(e) ? "success" : "failure", { name: s });
+}
+function F(s, t, e = {}) {
+  return u("action", [], (n, r) => t(n, r.now), { name: s, halt: e.onHalt ? (n) => e.onHalt(n) : void 0 });
+}
+export {
+  k as BehaviorTree,
+  p as BtAgent,
+  F as action,
+  T as condition,
+  j as cooldown,
+  m as formatTrace,
+  q as invert,
+  b as parallel,
+  M as reactiveSelector,
+  v as reactiveSequence,
+  S as repeat,
+  $ as retry,
+  y as selector,
+  w as sequence,
+  A as succeed,
+  B as timeout,
+  H as wait
+};

package/dist/ai/buildTree.js

@@ -0,0 +1,54 @@
+import { action as m, condition as s, wait as h, timeout as $, cooldown as y, retry as b, repeat as w, succeed as q, invert as v, parallel as S, reactiveSelector as k, reactiveSequence as A, selector as H, sequence as T } from "./behaviorTree.js";
+function x(e, t) {
+  return l(e, t, "$", []);
+}
+function l(e, t, u, c) {
+  const r = (n) => {
+    throw new Error(`buildTree: ${u}: ${n}`);
+  };
+  if (!e || typeof e != "object") return r("not a node");
+  const a = (n) => !Array.isArray(n) || n.length === 0 ? r("needs children") : n.map((d, f) => l(d, t, `${u}.children[${f}]`, c)), i = (n) => l(n, t, `${u}.child`, c), o = (n, d) => typeof n == "number" && n >= 0 ? n : r(`${d} must be a number of at least 0`);
+  switch (e.type) {
+    case "sequence":
+      return T(...a(e.children));
+    case "selector":
+      return H(...a(e.children));
+    case "reactiveSequence":
+      return A(...a(e.children));
+    case "reactiveSelector":
+      return k(...a(e.children));
+    case "parallel":
+      return S({ succeed: e.succeed, fail: e.fail }, ...a(e.children));
+    case "invert":
+      return v(i(e.child));
+    case "succeed":
+      return q(i(e.child));
+    case "repeat":
+      return w(o(e.times, "times"), i(e.child));
+    case "retry":
+      return b(o(e.times, "times"), i(e.child));
+    case "cooldown":
+      return y(o(e.ms, "ms"), i(e.child));
+    case "timeout":
+      return $(o(e.ms, "ms"), i(e.child));
+    case "wait":
+      return h(o(e.ms, "ms"));
+    case "condition": {
+      const n = t.conditions?.[e.name];
+      return n ? s(e.name, n) : r(`no condition '${e.name}'`);
+    }
+    case "action": {
+      const n = t.actions?.[e.name];
+      return n ? typeof n == "function" ? m(e.name, n) : m(e.name, n.run, { onHalt: n.onHalt }) : r(`no action '${e.name}'`);
+    }
+    case "tree": {
+      const n = t.trees?.[e.name];
+      return n ? c.includes(e.name) ? r(`tree '${e.name}' contains itself`) : l(n, t, `${u}<${e.name}>`, [...c, e.name]) : r(`no tree '${e.name}'`);
+    }
+    default:
+      return r(`unknown type '${e.type}'`);
+  }
+}
+export {
+  x as buildTree
+};

package/dist/audio/spatial.js

@@ -0,0 +1,118 @@
+const l = [18e3, 1800];
+function f(c, t, e = {}) {
+  const i = e.range ?? 480, s = t.x - c.x, n = Math.hypot(s, t.y - c.y), r = e.maxPan ?? 0.8, h = Math.max(-r, Math.min(r, s / (e.panWidth ?? i / 2))), o = e.muffle === void 0 ? l : e.muffle, a = Math.min(1, n / i), u = o ? o[0] * Math.pow(o[1] / o[0], a) : 2e4;
+  return n >= i ? { audible: !1, gain: 0, pan: h, cutoffHz: u } : { audible: !0, gain: Math.pow(1 - a, e.rolloff ?? 1.5), pan: h, cutoffHz: u };
+}
+const m = 0.05;
+class d {
+  constructor(t, e = t.destination) {
+    this.context = t, this.output = t.createGain(), this.output.connect(e);
+  }
+  context;
+  /** Every emitter's gain goes through this: the game's volume setting. */
+  output;
+  emitters = /* @__PURE__ */ new Set();
+  here = { x: 0, y: 0 };
+  /** The listener's place as of the last `update`. */
+  get listener() {
+    return this.here;
+  }
+  /** How many emitters are alive (playing or waiting out of range). */
+  get size() {
+    return this.emitters.size;
+  }
+  /** A sound at (x, y), looping by default. Starts at once when in range of the listener. */
+  emitter(t, e, i, s = {}) {
+    const n = new p(this, t, e, i, s);
+    return this.emitters.add(n), n.refresh(this.here, !1), n;
+  }
+  /** A one-shot at (x, y), dropped when it ends; skipped (and done at once) when out of range. */
+  play(t, e, i, s = {}) {
+    return this.emitter(t, e, i, { ...s, loop: !1 });
+  }
+  /** Moves the listener and re-mixes every emitter. Call once a frame. */
+  update(t = this.here) {
+    this.here = { x: t.x, y: t.y };
+    for (const e of this.emitters) e.refresh(this.here, !0);
+  }
+  /** Stops every emitter. */
+  stopAll(t = 0) {
+    for (const e of [...this.emitters]) e.stop(t);
+  }
+  destroy() {
+    this.stopAll(), this.output.disconnect();
+  }
+  /** @internal */
+  forget(t) {
+    this.emitters.delete(t);
+  }
+}
+class p {
+  constructor(t, e, i, s, n) {
+    this.owner = t, this.buffer = e, this.x = i, this.y = s, this.options = n;
+    const r = t.context;
+    this.volume = n.volume ?? 1, this.rate = n.playbackRate ?? 1, this.origin = r.currentTime, this.filter = r.createBiquadFilter(), this.filter.type = "lowpass", this.gain = r.createGain(), this.panner = r.createStereoPanner(), this.filter.connect(this.gain).connect(this.panner).connect(t.output);
+  }
+  owner;
+  buffer;
+  x;
+  y;
+  options;
+  volume;
+  done = !1;
+  source = null;
+  gain;
+  panner;
+  filter;
+  /** When the loop would have begun, had it never stopped: where a restart picks it up. */
+  origin;
+  rate;
+  get playing() {
+    return this.source !== null;
+  }
+  refresh(t, e) {
+    if (this.done) return;
+    const i = f(t, this, this.options), s = this.options.loop ?? !0;
+    if (!i.audible) {
+      if (!s) return this.stop();
+      this.halt();
+      return;
+    }
+    const n = this.owner.context, r = n.currentTime, h = (o, a) => e && this.source ? o.setTargetAtTime(a, r, m) : o.setValueAtTime(a, r);
+    h(this.gain.gain, i.gain * Math.max(0, Math.min(1, this.volume))), h(this.panner.pan, i.pan), h(this.filter.frequency, Math.min(i.cutoffHz, n.sampleRate / 2)), this.source || this.begin(s);
+  }
+  stop(t = 0) {
+    if (this.done) return;
+    this.done = !0, this.owner.forget(this);
+    const e = this.source, i = this.owner.context;
+    if (e && t > 0) {
+      const s = i.currentTime + t / 1e3;
+      this.gain.gain.setValueAtTime(this.gain.gain.value, i.currentTime), this.gain.gain.linearRampToValueAtTime(0, s), e.stop(s), e.onended = () => this.release();
+    } else
+      this.halt(), this.release();
+  }
+  begin(t) {
+    const e = this.owner.context, i = e.createBufferSource();
+    i.buffer = this.buffer, i.loop = t, i.playbackRate.value = this.rate, i.connect(this.filter);
+    const s = t ? (e.currentTime - this.origin) * this.rate % this.buffer.duration : 0;
+    i.start(e.currentTime, s), t || (i.onended = () => this.stop()), this.source = i;
+  }
+  halt() {
+    const t = this.source;
+    if (t) {
+      this.source = null, t.onended = null;
+      try {
+        t.stop();
+      } catch {
+      }
+      t.disconnect();
+    }
+  }
+  release() {
+    this.filter.disconnect(), this.gain.disconnect(), this.panner.disconnect();
+  }
+}
+export {
+  d as SpatialAudio,
+  f as spatialMix
+};

package/dist/cjs/electron/webPatcher.d.ts

@@ -47,6 +47,7 @@ export declare class WebPatcher {
     private loaded;
     /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
     private tidying;
+    private tidyChain;
     constructor(options: WebPatcherOptions);
     /** This shell's identity. */
     get shell(): string;
@@ -75,6 +76,8 @@ export declare class WebPatcher {
     private promote;
     /** A pointer this shell may load: its own shell, newer than the installed build, its folder whole. */
     private usable;
-    /** Removes every patched web but the active, pending and previous one, and any half-made folder. */
+    /** Removes every patched web but the active, pending and previous one, and any half-made folder. A call made while
+     * one is running waits for it and then runs once more, so two never delete the same folder at once. */
     tidy(): Promise<void>;
+    private tidyOnce;
 }

package/dist/cjs/electron/webPatcher.js

@@ -27,6 +27,7 @@ class WebPatcher {
     loaded = null;
     /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
     tidying = Promise.resolve();
+    tidyChain = Promise.resolve();
     constructor(options) {
         this.options = options;
         this.o = {
@@ -197,8 +198,14 @@ class WebPatcher {
     usable(p) {
         return !!p && p.shell === this.shell && (0, manifest_1.isNewer)(p.version, this.o.appVersion) && (0, node_fs_1.existsSync)((0, node_path_1.join)(this.o.root, p.version, this.o.entry));
     }
-    /** Removes every patched web but the active, pending and previous one, and any half-made folder. */
-    async tidy() {
+    /** Removes every patched web but the active, pending and previous one, and any half-made folder. A call made while
+     * one is running waits for it and then runs once more, so two never delete the same folder at once. */
+    tidy() {
+        const next = this.tidyChain.then(() => this.tidyOnce());
+        this.tidyChain = next;
+        return next;
+    }
+    async tidyOnce() {
         try {
             const names = ['active', 'pending', 'previous'];
             const keep = new Set([...names.map((n) => this.pointers.read(n)?.version), this.loaded?.version].filter((v) => !!v));

package/dist/core/Camera.js

@@ -12,6 +12,8 @@ class g {
   resolution = 1;
   /** Lands the view on whole backing pixels (pixel art); off, the world moves smoothly between them. */
   roundPixels = !1;
+  /** The world is drawn on its own pixel grid (`Stage.pixelPerfect`): `snapRoot` lands on whole world pixels. Set by the stage. */
+  pixelGrid = !1;
   scrollX = 0;
   scrollY = 0;
   width = 0;
@@ -42,6 +44,14 @@ class g {
     const s = this.zoom * this.resolution;
     return Math.round(t * s) / s;
   }
+  /**
+   * Where an object's root lands (a body, and whatever is laid over one): a whole world pixel while the world is drawn
+   * on its own grid (`Stage.pixelPerfect`), else `snap`. One rule for every root, so a body, what it holds and what
+   * points at it fall on the same pixel; children keep whole-pixel offsets from it.
+   */
+  snapRoot(t) {
+    return this.pixelGrid ? Math.round(t) : this.snap(t);
+  }
   setBounds(t, s, h, e) {
     return this.bounds = { x: t, y: s, width: h, height: e }, this;
   }

package/dist/core/ObjectFactory.js

@@ -1,45 +1,47 @@
-import { BitmapLabel as m } from "./BitmapLabel.js";
-import { Graphics as u } from "./Graphics.js";
-import { Group as g } from "./Group.js";
-import { Image as p } from "./Image.js";
-import { Rectangle as l } from "./Rectangle.js";
-import { Text as x } from "./Text.js";
+import { BitmapLabel as g } from "./BitmapLabel.js";
+import { Graphics as p } from "./Graphics.js";
+import { Group as u } from "./Group.js";
+import { Image as l } from "./Image.js";
+import { Rectangle as x } from "./Rectangle.js";
+import { Text as f } from "./Text.js";
 class L {
   constructor(t) {
     this.stage = t;
   }
   stage;
-  image(t, e, r, a) {
-    return this.attach(new p(this.stage.textures, t, e, r, a));
+  image(t, e, r, s) {
+    return this.attach(new l(this.stage.textures, t, e, r, s));
   }
   /**
    * A copy of `src` as it is drawn right now (afterimages, clones). A live texture, repainted every frame, is
    * snapshotted first, and the snapshot is freed with the copy.
    */
   still(t, e, r) {
-    const a = this.stage.textures;
-    if (!a.isLive(r.textureKey)) return this.image(t, e, r.textureKey, r.frameName);
-    const s = a.snapshot(r.textureKey, r.frameName), i = this.image(t, e, s, "0");
-    return i.once("destroyed", () => a.remove(s)), i;
+    const s = this.stage.textures;
+    if (!s.isLive(r.textureKey)) return this.image(t, e, r.textureKey, r.frameName);
+    const a = s.snapshot(r.textureKey, r.frameName), i = this.image(t, e, a, "0");
+    return i.once("destroyed", () => s.remove(a)), i;
   }
   graphics(t) {
-    const e = this.attach(new u());
+    const e = this.attach(new p());
     return e.position.set(t?.x ?? 0, t?.y ?? 0), e;
   }
   container(t = 0, e = 0, r = []) {
-    const a = this.attach(new g());
-    return a.position.set(t, e), a.add(r), a;
+    const s = this.attach(new u());
+    return s.position.set(t, e), s.add(r), s;
   }
-  rectangle(t, e, r, a, s, i = 1) {
-    const n = this.attach(new l(r, a, s, i));
+  rectangle(t, e, r, s, a, i = 1) {
+    const n = this.attach(new x(r, s, a, i));
     return n.position.set(t, e), n;
   }
-  text(t, e, r, a) {
-    return this.attach(new x(t, e, r, a));
+  text(t, e, r, s) {
+    const a = this.attach(new f(t, e, r, s));
+    return this.stage.keepSharp(a), a;
   }
   /** A bitmap-font label (`BitmapLabel`): cheap to change, for text rewritten many times a second. */
-  label(t, e, r, a, s, i, n, o, h, c = "") {
-    return this.attach(new m(t, e, r, a, s, i, n, o, h, c));
+  label(t, e, r, s, a, i, n, h, c, m = "") {
+    const o = this.attach(new g(t, e, r, s, a, i, n, h, c, m));
+    return this.stage.keepSharp(o), o;
   }
   /** Puts an object made elsewhere on the world layer, as the factory's own are (a `PixelLayer`, a custom class). */
   existing(t) {

package/dist/core/PixelGrid.js

@@ -0,0 +1,47 @@
+import { Matrix as n, Sprite as l, RenderTexture as a } from "pixi.js";
+import { gridPlacement as d } from "./gridPlacement.js";
+import { SharpText as x } from "./SharpText.js";
+class m {
+  constructor(e, t) {
+    this.app = e, this.world = t, this.text = new x(t);
+  }
+  app;
+  world;
+  texture = null;
+  sprite = null;
+  text;
+  transform = new n();
+  on = !1;
+  get enabled() {
+    return this.on;
+  }
+  /** Once a frame, after the camera wrote the world's transform and before Pixi draws the screen. */
+  render(e, t) {
+    if (t !== this.on && (t ? this.enable(e) : this.disable(e)), !t) return;
+    const i = e.zoom || 1, s = this.world.position, r = d(s.x, s.y, i, this.app.renderer.resolution, e.width, e.height), o = this.fit(r.width, r.height);
+    this.transform.set(1, 0, 0, 1, -r.tx, -r.ty), this.app.renderer.render({ container: this.world, target: o, clear: !0, clearColor: [0, 0, 0, 0], transform: this.transform });
+    const h = this.sprite;
+    h.scale.set(i), h.position.set(r.x, r.y), this.text.sync(s, i);
+  }
+  destroy(e) {
+    this.disable(e), this.text.destroy();
+  }
+  enable(e) {
+    this.on = !0, e.pixelGrid = !0;
+    const t = this.app.stage, i = Math.max(0, t.children.indexOf(this.world));
+    t.removeChild(this.world), this.sprite = new l(), t.addChildAt(this.sprite, i), t.addChildAt(this.text.layer, i + 1);
+  }
+  disable(e) {
+    if (!this.on) return;
+    this.on = !1, e.pixelGrid = !1, this.text.release();
+    const t = this.app.stage, i = Math.max(0, this.sprite ? t.children.indexOf(this.sprite) : 0);
+    t.removeChild(this.text.layer), this.sprite?.destroy(), this.sprite = null, this.texture?.destroy(!0), this.texture = null, this.world.destroyed || t.addChildAt(this.world, i);
+  }
+  /** The texture at exactly this size, made again only when the screen or the zoom changed. */
+  fit(e, t) {
+    return this.texture && this.texture.width === e && this.texture.height === t ? this.texture : (this.texture?.destroy(!0), this.texture = a.create({ width: e, height: t, resolution: 1, scaleMode: "nearest", antialias: !1 }), this.sprite.texture = this.texture, this.texture);
+  }
+}
+export {
+  m as PixelGrid
+};

package/dist/core/SharpText.js

@@ -0,0 +1,72 @@
+import { Container as n, Matrix as d } from "pixi.js";
+class c {
+  constructor(e) {
+    this.world = e;
+  }
+  world;
+  layer = new n({ sortableChildren: !0 });
+  labels = /* @__PURE__ */ new Set();
+  m = new d();
+  /** Labels tracked since the last sweep for destroyed ones: off, nothing else sweeps them. */
+  sinceSweep = 0;
+  track(e) {
+    this.labels.add({ obj: e, home: null, wrap: null }), ++this.sinceSweep >= 256 && this.prune();
+  }
+  /** Lays the layer over the world (`origin`: where the world's origin lands on screen) and every label on its home. */
+  sync(e, r) {
+    this.layer.position.set(e.x, e.y), this.layer.scale.set(r);
+    for (const t of this.labels) {
+      const s = t.obj;
+      if (s.destroyed) {
+        this.drop(t);
+        continue;
+      }
+      s.parent && s.parent !== t.wrap && (t.home = s.parent, t.wrap ??= this.layer.addChild(new n()), t.wrap.addChild(s));
+      const o = t.home, i = t.wrap;
+      if (!(!o || !i)) {
+        if (o.destroyed) {
+          s.destroy(), this.drop(t);
+          continue;
+        }
+        this.place(o, i, s);
+      }
+    }
+  }
+  /** Every label back in its home (the grid switched off), the stand-ins gone. */
+  release() {
+    for (const e of this.labels) {
+      const { obj: r, home: t, wrap: s } = e;
+      if (r.destroyed) {
+        this.drop(e);
+        continue;
+      }
+      t && s && r.parent === s && (t.destroyed ? r.destroy() : t.addChild(r)), s?.destroy(), e.wrap = null, e.home = null;
+    }
+  }
+  /** Forgets labels the game destroyed while nothing synced (the grid off). */
+  prune() {
+    this.sinceSweep = 0;
+    for (const e of this.labels) e.obj.destroyed && this.drop(e);
+  }
+  destroy() {
+    this.release(), this.labels.clear(), this.layer.destroy({ children: !0 });
+  }
+  place(e, r, t) {
+    const s = this.m.identity();
+    let o = !0, i = 1, a = e;
+    for (let l = e; l !== this.world; l = l.parent) {
+      if (!l) {
+        o = !1;
+        break;
+      }
+      (!l.visible || !l.renderable) && (o = !1), i *= l.alpha, l.updateLocalTransform(), s.prepend(l.localTransform), a = l;
+    }
+    r.visible = o, o && (r.setFromMatrix(s), r.alpha = i, r.zIndex = e === this.world ? t.zIndex : a.zIndex);
+  }
+  drop(e) {
+    e.wrap?.destroy(), this.labels.delete(e);
+  }
+}
+export {
+  c as SharpText
+};