@synnaxlabs/pluto 0.42.4 → 0.43.1

package/dist/{eraser-CK8SwEJa.js → eraser-BJxXs5KS.js}

@@ -1,58 +1,58 @@
-var $ = Object.defineProperty;
-var z = (h, t, e) => t in h ? $(h, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : h[t] = e;
-var n = (h, t, e) => z(h, typeof t != "symbol" ? t + "" : t, e);
-import { $ as c, v as x, J as f, _ as G, D as y, b as K, C as H } from "./css-Cnb9DQMD.js";
-import { z as m } from "zod";
-import { h as _, j as J, Q as Z, L as Q } from "./provider-r5Ly36FI.js";
-import { a as M } from "./dimensions-B6qmnzv3.js";
-const j = m.object({
-  include: m.string().array().optional(),
-  exclude: m.string().array().optional(),
-  level: m.enum(_.LOG_LEVELS).optional().default("info")
-}), A = "alamos-provider";
-class b extends J {
+var z = Object.defineProperty;
+var H = (l, t, e) => t in l ? z(l, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : l[t] = e;
+var a = (l, t, e) => H(l, typeof t != "symbol" ? t + "" : t, e);
+import { P as n, A as C, K as u, q as M, o as y, c as V, C as Z } from "./css-DjQu2Qyf.js";
+import { h as _, j as $, k as J, m as Q, n as j, L as tt } from "./provider-gW90qzEG.js";
+import { o as N, _ as et, b as I, g as st } from "./state-DAFH2z9y.js";
+import { a as X } from "./dimensions-FnMV2fyj.js";
+const it = N({
+  include: I().array().optional(),
+  exclude: I().array().optional(),
+  level: et(_.LOG_LEVELS).optional().default("info")
+}), b = "alamos-provider";
+class O extends $ {
   constructor() {
     super(...arguments);
-    n(this, "schema", j);
+    a(this, "schema", it);
   }
   afterUpdate(e) {
-    if (e.getOptional(A) != null) return;
-    const i = [], { include: r, exclude: a, level: l } = this.state;
-    (r != null || a != null) && i.push(_.logLevelKeyFiler({ include: r, exclude: a })), l != null && i.push(_.logThresholdFilter(l)), i.length === 0 && i.push(() => !1), this.internal.ins = new _.Instrumentation({
+    if (e.getOptional(b) != null) return;
+    const i = [], { include: r, exclude: h, level: o } = this.state;
+    (r != null || h != null) && i.push(_.logLevelKeyFiler({ include: r, exclude: h })), o != null && i.push(_.logThresholdFilter(o)), i.length === 0 && i.push(() => !1), this.internal.ins = new _.Instrumentation({
       key: "aether",
       logger: new _.Logger({ filters: i })
-    }), e.set(A, this.internal.ins);
+    }), e.set(b, this.internal.ins);
   }
 }
-n(b, "TYPE", "alamos.Provider");
-const tt = (h, t) => {
-  const e = h.get(A);
+a(O, "TYPE", "alamos.Provider");
+const rt = (l, t) => {
+  const e = l.get(b);
   if (e == null) throw new Error("No instrumentation provider");
   return t == null ? e : e.child(t);
-}, St = {
-  [b.TYPE]: b
-}, E = (h, t) => c.construct(
-  c.left(h) - t.x,
-  c.top(h) - t.y,
-  c.width(h) + t.x * 2,
-  c.height(h) + t.y * 2
+}, Ct = {
+  [O.TYPE]: O
+}, T = (l, t) => n.construct(
+  n.left(l) - t.x,
+  n.top(l) - t.y,
+  n.width(l) + t.x * 2,
+  n.height(l) + t.y * 2
 );
 class R {
-  constructor(t, e, s, i = x.XY.IDENTITY) {
-    n(this, "scale_");
-    n(this, "wrapped");
-    n(this, "atlasRegistry");
-    n(this, "cachedFont", null);
-    n(this, "cachedFillStyle", null);
-    n(this, "cachedStrokeStyle", null);
-    n(this, "cachedLineWidth", null);
-    n(this, "cachedGlobalAlpha", null);
-    n(this, "cachedTextAlign", null);
-    n(this, "cachedTextBaseline", null);
-    n(this, "cachedLineCap", null);
-    n(this, "cachedLineJoin", null);
-    n(this, "cachedMiterLimit", null);
-    n(this, "dpr");
+  constructor(t, e, s, i = C.XY.IDENTITY) {
+    a(this, "scale_");
+    a(this, "wrapped");
+    a(this, "atlasRegistry");
+    a(this, "cachedFont", null);
+    a(this, "cachedFillStyle", null);
+    a(this, "cachedStrokeStyle", null);
+    a(this, "cachedLineWidth", null);
+    a(this, "cachedGlobalAlpha", null);
+    a(this, "cachedTextAlign", null);
+    a(this, "cachedTextBaseline", null);
+    a(this, "cachedLineCap", null);
+    a(this, "cachedLineJoin", null);
+    a(this, "cachedMiterLimit", null);
+    a(this, "dpr");
     this.wrapped = t, this.scale_ = i, this.atlasRegistry = e, this.dpr = s;
   }
   get fontStretch() {
@@ -88,6 +88,11 @@ class R {
   set textRendering(t) {
     this.wrapped.textRendering = t;
   }
+  checkAtlasFillStyle(t = !1) {
+    return t && typeof this.fillStyle == "string" ? [!0, this.fillStyle] : (t && console.warn(
+      "attempted to use a text atlas with a gradient fill style. This is not supported. Falling back to default canvas fill."
+    ), [!1, null]);
+  }
   reset() {
     this.wrapped.reset();
   }
@@ -133,16 +138,16 @@ class R {
   set strokeStyle(t) {
     t !== this.cachedStrokeStyle && (this.cachedStrokeStyle = t, this.wrapped.strokeStyle = t);
   }
-  drawImage(t, e, s, i, r, a, l, p, d) {
+  drawImage(t, e, s, i, r, h, o, c, d) {
     this.wrapped.drawImage(
       t,
       e,
       s,
       i,
       r,
-      a != null ? this.scale_.x.pos(a) : a,
-      l != null ? this.scale_.y.pos(l) : l,
-      p != null ? this.scale_.x.dim(p) : p,
+      h != null ? this.scale_.x.pos(h) : h,
+      o != null ? this.scale_.y.pos(o) : o,
+      c != null ? this.scale_.x.dim(c) : c,
       d != null ? this.scale_.y.dim(d) : d
     );
   }
@@ -175,8 +180,8 @@ class R {
   createPattern(t, e) {
     return this.wrapped.createPattern(t, e);
   }
-  createRadialGradient(t, e, s, i, r, a) {
-    return this.wrapped.createRadialGradient(t, e, s, i, r, a);
+  createRadialGradient(t, e, s, i, r, h) {
+    return this.wrapped.createRadialGradient(t, e, s, i, r, h);
   }
   get filter() {
     return this.wrapped.filter;
@@ -190,7 +195,7 @@ class R {
   getImageData(t, e, s, i, r) {
     return this.wrapped.getImageData(t, e, s, i, r);
   }
-  putImageData(t, e, s, i, r, a, l) {
+  putImageData(t, e, s, i, r, h, o) {
     this.wrapped.putImageData(
       // @ts-expect-error - typescript overloads cause issues here
       t,
@@ -198,8 +203,8 @@ class R {
       s,
       i,
       r,
-      a,
-      l
+      h,
+      o
     );
   }
   get imageSmoothingEnabled() {
@@ -214,14 +219,14 @@ class R {
   set imageSmoothingQuality(t) {
     this.wrapped.imageSmoothingQuality = t;
   }
-  arc(t, e, s, i, r, a) {
+  arc(t, e, s, i, r, h) {
     this.wrapped.arc(
       this.scale_.x.pos(t),
       this.scale_.y.pos(e),
       this.scale_.x.dim(s),
       i,
       r,
-      a
+      h
     );
   }
   arcTo(t, e, s, i, r) {
@@ -233,29 +238,29 @@ class R {
       this.scale_.x.dim(r)
     );
   }
-  bezierCurveTo(t, e, s, i, r, a) {
+  bezierCurveTo(t, e, s, i, r, h) {
     this.wrapped.bezierCurveTo(
       this.scale_.x.pos(t),
       this.scale_.y.pos(e),
       this.scale_.x.pos(s),
       this.scale_.y.pos(i),
       this.scale_.x.pos(r),
-      this.scale_.y.pos(a)
+      this.scale_.y.pos(h)
     );
   }
   closePath() {
     this.wrapped.closePath();
   }
-  ellipse(t, e, s, i, r, a, l, p) {
+  ellipse(t, e, s, i, r, h, o, c) {
     this.wrapped.ellipse(
       this.scale_.x.pos(t),
       this.scale_.y.pos(e),
       this.scale_.x.dim(s),
       this.scale_.y.dim(i),
       r,
-      a,
-      l,
-      p
+      h,
+      o,
+      c
     );
   }
   lineTo(t, e) {
@@ -368,13 +373,9 @@ class R {
     this.wrapped.save();
   }
   fillText(t, e, s, i, r = {}) {
-    const { useAtlas: a } = r;
-    if (a == !0) {
-      this.atlasRegistry.get({
-        font: this.font,
-        textColor: this.fillStyle,
-        dpr: this.dpr
-      }).fillText(this, t, e, s);
+    const [h, o] = this.checkAtlasFillStyle(r.useAtlas);
+    if (h) {
+      this.atlasRegistry.get({ font: this.font, textColor: o }).fillText(this, t, e, s);
       return;
     }
     this.wrapped.fillText(
@@ -384,20 +385,12 @@ class R {
       i != null ? this.scale_.x.dim(i) : void 0
     );
   }
-  atlasMeasureText(t) {
-    return this.atlasRegistry.get({
-      font: this.font,
-      textColor: this.fillStyle,
-      dpr: this.dpr
-    }).measureText(t);
-  }
   measureText(t) {
     return this.wrapped.measureText(t);
   }
   textDimensions(t, e = {}) {
-    const { useAtlas: s } = e;
-    let i;
-    return s ? i = this.atlasMeasureText(t) : i = M(this.measureText(t)), i;
+    const [s, i] = this.checkAtlasFillStyle(e.useAtlas);
+    return s ? this.atlasRegistry.get({ font: this.font, textColor: i }).measureText(t) : X(this.measureText(t));
   }
   strokeText(t, e, s, i) {
     this.wrapped.strokeText(
@@ -449,37 +442,37 @@ class R {
   scale(t, e) {
     this.wrapped.scale(t, e), this.dpr = t;
   }
-  scissor(t, e = f.ZERO) {
-    const s = new et(this.scale_);
-    return t = E(t, e), s.rect(...f.couple(c.topLeft(t)), ...G.couple(c.dims(t))), this.save(), this.clip(s.getPath()), () => this.restore();
+  scissor(t, e = u.ZERO) {
+    const s = new at(this.scale_);
+    return t = T(t, e), s.rect(...u.couple(n.topLeft(t)), ...M.couple(n.dims(t))), this.save(), this.clip(s.getPath()), () => this.restore();
   }
-  setTransform(t, e, s, i, r, a) {
-    this.wrapped.setTransform(t, e, s, i, r, a);
+  setTransform(t, e, s, i, r, h) {
+    this.wrapped.setTransform(t, e, s, i, r, h);
   }
-  transform(t, e, s, i, r, a) {
-    this.wrapped.transform(t, e, s, i, r, a);
+  transform(t, e, s, i, r, h) {
+    this.wrapped.transform(t, e, s, i, r, h);
   }
   translate(t, e) {
     this.wrapped.translate(t, e);
   }
 }
-class et {
-  constructor(t = x.XY.IDENTITY, e) {
-    n(this, "scale_");
-    n(this, "path");
+class at {
+  constructor(t = C.XY.IDENTITY, e) {
+    a(this, "scale_");
+    a(this, "path");
     this.scale_ = t, e instanceof Path2D || typeof e == "string" ? this.path = new Path2D(e) : this.path = new Path2D();
   }
   addPath(t, e) {
     this.path.addPath(t, e);
   }
-  arc(t, e, s, i, r, a) {
+  arc(t, e, s, i, r, h) {
     this.path.arc(
       this.scale_.x.pos(t),
       this.scale_.y.pos(e),
       this.scale_.x.dim(s),
       i,
       r,
-      a
+      h
     );
   }
   arcTo(t, e, s, i, r) {
@@ -491,29 +484,29 @@ class et {
       this.scale_.x.dim(r)
     );
   }
-  bezierCurveTo(t, e, s, i, r, a) {
+  bezierCurveTo(t, e, s, i, r, h) {
     this.path.bezierCurveTo(
       this.scale_.x.pos(t),
       this.scale_.y.pos(e),
       this.scale_.x.pos(s),
       this.scale_.y.pos(i),
       this.scale_.x.pos(r),
-      this.scale_.y.pos(a)
+      this.scale_.y.pos(h)
     );
   }
   closePath() {
     this.path.closePath();
   }
-  ellipse(t, e, s, i, r, a, l, p) {
+  ellipse(t, e, s, i, r, h, o, c) {
     this.path.ellipse(
       this.scale_.x.pos(t),
       this.scale_.y.pos(e),
       this.scale_.x.dim(s),
       this.scale_.y.dim(i),
       r,
-      a,
-      l,
-      p
+      h,
+      o,
+      c
     );
   }
   lineTo(t, e) {
@@ -539,13 +532,13 @@ class et {
     );
   }
   roundRect(t, e, s, i, r) {
-    const a = this.scaleRadii(r);
+    const h = this.scaleRadii(r);
     this.path.roundRect(
       this.scale_.x.pos(t),
       this.scale_.y.pos(e),
       this.scale_.x.dim(s),
       this.scale_.y.dim(i),
-      a
+      h
     );
   }
   // Helper method to scale radii for roundRect
@@ -563,18 +556,18 @@ class et {
     return this.path;
   }
 }
-const st = `precision mediump float;
+const ht = `precision mediump float;
 
 void main(void) {
     gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);    
 }
-`, it = `attribute vec4 a_position;
+`, nt = `attribute vec4 a_position;
 
 void main(void) {
   gl_Position = a_position;
 }
-`, k = (h) => new Error(`failed to compile webgl program: ${h}`), rt = new Error("null shader encountered");
-let at = class {
+`, k = (l) => new Error(`failed to compile webgl program: ${l}`), lt = new Error("null shader encountered");
+let ot = class {
   /**
    * @constructor compiles the given vertex and fragment shaders under the given
    * render context into a program.
@@ -585,14 +578,14 @@ let at = class {
    */
   constructor(t, e, s) {
     /** The render context used by this program. */
-    n(this, "renderCtx");
+    a(this, "renderCtx");
     /** The underlying webgl program. */
-    n(this, "prog");
+    a(this, "prog");
     /** The code for the vertex shader. */
-    n(this, "vertShader");
+    a(this, "vertShader");
     /** The code for the fragment shader. */
-    n(this, "fragShader");
-    n(this, "uniformLocCache", /* @__PURE__ */ new Map());
+    a(this, "fragShader");
+    a(this, "uniformLocCache", /* @__PURE__ */ new Map());
     this.renderCtx = t;
     const i = t.gl.createProgram();
     if (i == null) throw k("failed to create program");
@@ -609,7 +602,7 @@ let at = class {
    * @param value - The value to set.
    */
   uniformXY(t, e) {
-    this.renderCtx.gl.uniform2fv(this.getUniformLoc(t), f.couple(e));
+    this.renderCtx.gl.uniform2fv(this.getUniformLoc(t), u.couple(e));
   }
   /**
    * Sets a uniform color value.
@@ -633,22 +626,22 @@ let at = class {
   }
   compileShader(t, e) {
     const s = this.renderCtx.gl, i = s.createShader(e);
-    if (i == null) throw rt;
+    if (i == null) throw lt;
     if (s.shaderSource(i, t), s.compileShader(i), !s.getShaderParameter(i, s.COMPILE_STATUS)) {
-      const a = s.getShaderInfoLog(i);
-      throw s.deleteShader(i), k(a ?? "unknown");
+      const h = s.getShaderInfoLog(i);
+      throw s.deleteShader(i), k(h ?? "unknown");
     }
     s.attachShader(this.prog, i);
   }
 };
-const nt = new Float32Array([0, 0, 0, 0, 0, 0]);
-class ht extends at {
+const ct = new Float32Array([0, 0, 0, 0, 0, 0]);
+class pt extends ot {
   constructor(e) {
-    super(e, it, st);
-    n(this, "positionBuffer");
+    super(e, nt, ht);
+    a(this, "positionBuffer");
     const s = e.gl.createBuffer();
-    if (s == null) throw new Z("webgl: failed to create buffer");
-    this.positionBuffer = s, e.gl.bindBuffer(e.gl.ARRAY_BUFFER, this.positionBuffer), e.gl.bufferData(e.gl.ARRAY_BUFFER, nt, e.gl.STATIC_DRAW);
+    if (s == null) throw new J("webgl: failed to create buffer");
+    this.positionBuffer = s, e.gl.bindBuffer(e.gl.ARRAY_BUFFER, this.positionBuffer), e.gl.bufferData(e.gl.ARRAY_BUFFER, ct, e.gl.STATIC_DRAW);
   }
   exec() {
     const { gl: e } = this.renderCtx, s = e.getAttribLocation(this.prog, "a_position");
@@ -657,197 +650,24 @@ class ht extends at {
     e.bindVertexArray(i), e.enableVertexAttribArray(s), e.vertexAttribPointer(s, 2, e.FLOAT, !1, 0, 0), this.setAsActive(), e.drawArrays(e.TRIANGLES, 0, 3);
   }
 }
-const ot = new Error("request for lock canceled");
-var lt = function(h, t, e, s) {
-  function i(r) {
-    return r instanceof e ? r : new e(function(a) {
-      a(r);
-    });
-  }
-  return new (e || (e = Promise))(function(r, a) {
-    function l(o) {
-      try {
-        d(s.next(o));
-      } catch (u) {
-        a(u);
-      }
-    }
-    function p(o) {
-      try {
-        d(s.throw(o));
-      } catch (u) {
-        a(u);
-      }
-    }
-    function d(o) {
-      o.done ? r(o.value) : i(o.value).then(l, p);
-    }
-    d((s = s.apply(h, t || [])).next());
-  });
-};
-class ct {
-  constructor(t, e = ot) {
-    this._value = t, this._cancelError = e, this._queue = [], this._weightedWaiters = [];
-  }
-  acquire(t = 1, e = 0) {
-    if (t <= 0)
-      throw new Error(`invalid weight ${t}: must be positive`);
-    return new Promise((s, i) => {
-      const r = { resolve: s, reject: i, weight: t, priority: e }, a = Y(this._queue, (l) => e <= l.priority);
-      a === -1 && t <= this._value ? this._dispatchItem(r) : this._queue.splice(a + 1, 0, r);
-    });
-  }
-  runExclusive(t) {
-    return lt(this, arguments, void 0, function* (e, s = 1, i = 0) {
-      const [r, a] = yield this.acquire(s, i);
-      try {
-        return yield e(r);
-      } finally {
-        a();
-      }
-    });
-  }
-  waitForUnlock(t = 1, e = 0) {
-    if (t <= 0)
-      throw new Error(`invalid weight ${t}: must be positive`);
-    return this._couldLockImmediately(t, e) ? Promise.resolve() : new Promise((s) => {
-      this._weightedWaiters[t - 1] || (this._weightedWaiters[t - 1] = []), pt(this._weightedWaiters[t - 1], { resolve: s, priority: e });
-    });
-  }
-  isLocked() {
-    return this._value <= 0;
-  }
-  getValue() {
-    return this._value;
-  }
-  setValue(t) {
-    this._value = t, this._dispatchQueue();
-  }
-  release(t = 1) {
-    if (t <= 0)
-      throw new Error(`invalid weight ${t}: must be positive`);
-    this._value += t, this._dispatchQueue();
-  }
-  cancel() {
-    this._queue.forEach((t) => t.reject(this._cancelError)), this._queue = [];
-  }
-  _dispatchQueue() {
-    for (this._drainUnlockWaiters(); this._queue.length > 0 && this._queue[0].weight <= this._value; )
-      this._dispatchItem(this._queue.shift()), this._drainUnlockWaiters();
-  }
-  _dispatchItem(t) {
-    const e = this._value;
-    this._value -= t.weight, t.resolve([e, this._newReleaser(t.weight)]);
-  }
-  _newReleaser(t) {
-    let e = !1;
-    return () => {
-      e || (e = !0, this.release(t));
-    };
-  }
-  _drainUnlockWaiters() {
-    if (this._queue.length === 0)
-      for (let t = this._value; t > 0; t--) {
-        const e = this._weightedWaiters[t - 1];
-        e && (e.forEach((s) => s.resolve()), this._weightedWaiters[t - 1] = []);
-      }
-    else {
-      const t = this._queue[0].priority;
-      for (let e = this._value; e > 0; e--) {
-        const s = this._weightedWaiters[e - 1];
-        if (!s)
-          continue;
-        const i = s.findIndex((r) => r.priority <= t);
-        (i === -1 ? s : s.splice(0, i)).forEach((r) => r.resolve());
-      }
-    }
-  }
-  _couldLockImmediately(t, e) {
-    return (this._queue.length === 0 || this._queue[0].priority < e) && t <= this._value;
-  }
-}
-function pt(h, t) {
-  const e = Y(h, (s) => t.priority <= s.priority);
-  h.splice(e + 1, 0, t);
-}
-function Y(h, t) {
-  for (let e = h.length - 1; e >= 0; e--)
-    if (t(h[e]))
-      return e;
-  return -1;
-}
-var dt = function(h, t, e, s) {
-  function i(r) {
-    return r instanceof e ? r : new e(function(a) {
-      a(r);
-    });
-  }
-  return new (e || (e = Promise))(function(r, a) {
-    function l(o) {
-      try {
-        d(s.next(o));
-      } catch (u) {
-        a(u);
-      }
-    }
-    function p(o) {
-      try {
-        d(s.throw(o));
-      } catch (u) {
-        a(u);
-      }
-    }
-    function d(o) {
-      o.done ? r(o.value) : i(o.value).then(l, p);
-    }
-    d((s = s.apply(h, t || [])).next());
-  });
-};
-class ut {
-  constructor(t) {
-    this._semaphore = new ct(1, t);
-  }
-  acquire() {
-    return dt(this, arguments, void 0, function* (t = 0) {
-      const [, e] = yield this._semaphore.acquire(1, t);
-      return e;
-    });
-  }
-  runExclusive(t, e = 0) {
-    return this._semaphore.runExclusive(() => t(), 1, e);
-  }
-  isLocked() {
-    return this._semaphore.isLocked();
-  }
-  waitForUnlock(t = 0) {
-    return this._semaphore.waitForUnlock(1, t);
-  }
-  release() {
-    this._semaphore.isLocked() && this._semaphore.release();
-  }
-  cancel() {
-    return this._semaphore.cancel();
-  }
-}
-const F = { high: 1, low: 0 };
-class ft {
+const B = { high: 1, low: 0 };
+class dt {
   constructor({
     afterRender: t,
-    instrumentation: e = _.Instrumentation.NOOP
+    instrumentation: e = _.Instrumentation.NOOP,
+    handleError: s
   }) {
-    /** To lock things so renders don't collide */
-    n(this, "mutex", new ut());
     /** Stores the current requests for rendering. */
-    n(this, "requests", /* @__PURE__ */ new Map());
+    a(this, "requests", /* @__PURE__ */ new Map());
     /** Stores render cleanup functions for clearing canvases and other resources. */
-    n(this, "cleanup", /* @__PURE__ */ new Map());
+    a(this, "cleanup", /* @__PURE__ */ new Map());
     /** A callback to run after each render call. */
-    n(this, "afterRender");
+    a(this, "afterRender");
     /** Instrumentation for logging, tracing, metrics, etc. */
-    n(this, "instrumentation");
-    /** The total number of renders */
-    n(this, "count", 0);
-    this.afterRender = t, this.instrumentation = e, this.start();
+    a(this, "instrumentation");
+    /** A function to add status to the status bar. */
+    a(this, "handleError");
+    this.afterRender = t, this.instrumentation = e, this.handleError = s, this.start();
   }
   /**
    * Sets a new request in the queue according to a set of rules:
@@ -863,19 +683,15 @@ class ft {
     const e = this.requests.get(t.key);
     if (e == null) this.requests.set(t.key, t);
     else {
-      const s = F[t.priority] >= F[e.priority], i = t.canvases.length >= e.canvases.length;
+      const s = B[t.priority] >= B[e.priority], i = t.canvases.length >= e.canvases.length;
       s && i && this.requests.set(t.key, t);
     }
   }
   /** Execute the render. */
   render() {
-    var r;
+    var e;
     const { requests: t } = this;
-    if (t.size === 0) return;
-    const e = this.instrumentation.T.bench("render-cycle"), s = this.instrumentation.T.bench("render-cycle-cleanup");
-    this.runCleanupsSync(), s();
-    const i = this.instrumentation.T.bench("render-cycle-render");
-    this.renderSync(), i(), e(), this.requests.clear(), (r = this.afterRender) == null || r.call(this);
+    t.size !== 0 && (this.runCleanupsSync(), this.renderSync(), this.requests.clear(), (e = this.afterRender) == null || e.call(this));
   }
   runCleanupsSync() {
     const { cleanup: t, requests: e } = this;
@@ -891,66 +707,64 @@ class ft {
         const s = e.render();
         s != null && this.cleanup.set(e.key, s);
       } catch (s) {
-        console.error(s);
+        this.handleError(s, "render loop failed");
       }
     });
   }
   /** Starts the rendering loop. */
-  async start() {
+  start() {
     const t = () => {
       try {
         this.render();
       } catch (e) {
-        console.error(e);
+        this.handleError(e, "render loop failed");
       }
       requestAnimationFrame(t);
     };
     requestAnimationFrame(t);
   }
 }
-const T = 2, v = class v {
+const S = 2, f = 2, E = class E {
   constructor(t) {
     // A canvas buffer that holds rendered characters.
-    n(this, "atlas");
+    a(this, "atlas");
     // Cached dimensions of a character.
-    n(this, "charDims");
-    // The device pixel ratio of the atlas.
-    n(this, "dpr");
+    a(this, "charDims");
     // A map of characters to their index in the atlas.
-    n(this, "charMap");
-    const { font: e, dpr: s, characters: i = v.DEFAULT_CHARS, textColor: r } = t;
-    this.dpr = s, this.charMap = /* @__PURE__ */ new Map();
-    const a = K.unique(Array.from(i)), p = new OffscreenCanvas(1, 1).getContext("2d");
-    p.font = e;
-    const d = p.measureText("0");
-    this.charDims = M(d), this.charDims.width += T, this.charDims.height += T;
-    const o = a.length, u = this.charDims.width, C = this.charDims.height, S = Math.ceil(Math.sqrt(o)), W = Math.ceil(o / S);
+    a(this, "charMap");
+    const { font: e, characters: s = E.DEFAULT_CHARS, textColor: i } = t;
+    this.charMap = /* @__PURE__ */ new Map();
+    const r = V.unique(Array.from(s)), o = new OffscreenCanvas(1, 1).getContext("2d");
+    o.font = e;
+    const c = o.measureText("0");
+    this.charDims = X(c), this.charDims.width += S, this.charDims.height += S;
+    const d = r.length, g = this.charDims.width, x = this.charDims.height, p = Math.ceil(Math.sqrt(d)), A = Math.ceil(d / p);
     this.atlas = new OffscreenCanvas(
-      u * S * this.dpr,
-      C * (W + 1) * this.dpr
+      g * p * f,
+      x * (A + 1) * f
     );
-    const w = this.atlas.getContext("2d");
-    w.scale(this.dpr, this.dpr), w.font = e, w.textBaseline = "alphabetic", w.textAlign = "left", w.fillStyle = y.hex(r), w.clearRect(0, 0, this.atlas.width, this.atlas.height), a.forEach((I, L) => {
-      const U = L % S, N = Math.floor(L / S), X = U * u, V = (N + 1) * C;
-      w.fillText(I, X, V), this.charMap.set(I, L);
+    const m = this.atlas.getContext("2d");
+    m.scale(f, f), m.font = e, m.textBaseline = "alphabetic", m.textAlign = "left", m.fillStyle = y.hex(i), m.clearRect(0, 0, this.atlas.width, this.atlas.height), r.forEach((F, L) => {
+      const q = L % p, K = Math.floor(L / p), U = q * g, W = (K + 1) * x;
+      m.fillText(F, U, W), this.charMap.set(F, L);
     });
   }
   fillText(t, e, s, i) {
-    const { width: r, height: a } = this.charDims, l = Math.ceil(Math.sqrt(this.charMap.size));
-    for (let p = 0; p < e.length; p++) {
-      const d = e[p], o = this.charMap.get(d);
-      if (o === void 0) continue;
-      const u = o % l, C = Math.floor(o / l);
+    const { width: r, height: h } = this.charDims, o = Math.ceil(Math.sqrt(this.charMap.size));
+    for (let c = 0; c < e.length; c++) {
+      const d = e[c], g = this.charMap.get(d);
+      if (g === void 0) continue;
+      const x = g % o, p = Math.floor(g / o);
       t.drawImage(
         this.atlas,
-        u * r * this.dpr,
-        C * a * this.dpr + T,
-        r * this.dpr,
-        a * this.dpr,
-        s + p * r,
-        i - a - T / this.dpr,
+        x * r * f,
+        p * h * f + S,
+        r * f,
+        h * f,
+        s + c * r,
+        i - h - S / f,
         r,
-        a
+        h
       );
     }
   }
@@ -959,11 +773,11 @@ const T = 2, v = class v {
   }
 };
 // The default characters to include in the atlas.
-n(v, "DEFAULT_CHARS", "0123456789.:-umsNa∞ᴇ");
-let O = v;
-class gt {
+a(E, "DEFAULT_CHARS", "0123456789.:-µmsNa∞ᴇ");
+let v = E;
+class ut {
   constructor() {
-    n(this, "atlases");
+    a(this, "atlases");
     this.atlases = /* @__PURE__ */ new Map();
   }
   /**
@@ -971,96 +785,102 @@ class gt {
    * atlas does not exist in the registry, it is created and added to the registry.
    */
   get(t) {
-    const e = `${t.font}-${y.hex(t.textColor)}-${t.dpr}-${t.characters}`;
+    const e = `${t.font}-${y.hex(t.textColor)}-${t.characters}`;
     if (this.atlases.has(e)) return this.atlases.get(e);
-    const s = new O(t);
+    const s = new v(t);
     return this.atlases.set(e, s), s;
   }
 }
-const q = (h) => (h.textRendering = "optimizeSpeed", h.imageSmoothingEnabled = !1, h), g = class g {
-  constructor(t, e, s, i, r) {
+const G = (l) => (l.textRendering = "optimizeSpeed", l.imageSmoothingEnabled = !1, l), w = class w {
+  constructor(t, e, s, i, r, h, o) {
     /* The canvas element used by WebGL. */
-    n(this, "glCanvas");
+    a(this, "glCanvas");
     /** The canvas element used by the 2D canvas. */
-    n(this, "upper2dCanvas");
+    a(this, "upper2dCanvas");
     /** The canvas element used by the 2D canvas. */
-    n(this, "lower2dCanvas");
+    a(this, "lower2dCanvas");
     /** The WebGL rendering context.  */
-    n(this, "gl");
+    a(this, "gl");
     /** A 2D canvas that sits below the WebGL canvas. */
-    n(this, "lower2d");
+    a(this, "lower2d");
     /** A 2D canvas that sits above the WebGL canvas. */
-    n(this, "upper2d");
+    a(this, "upper2d");
     /** The region the canvas occupies in pixel space */
-    n(this, "region");
+    a(this, "region");
     /** The device pixel ratio of the canvas */
-    n(this, "dpr");
+    a(this, "dpr");
     /** queue render transitions onto the stack */
-    n(this, "loop");
+    a(this, "loop");
     /** See the @link{clear.Program} for why this is necessary. */
-    n(this, "clearProgram");
-    n(this, "os");
-    n(this, "instrumentation");
+    a(this, "clearProgram");
+    a(this, "os");
+    a(this, "instrumentation");
     this.upper2dCanvas = s, this.lower2dCanvas = e, this.glCanvas = t, this.os = i, this.instrumentation = r, this.dpr = 1;
-    const a = this.lower2dCanvas.getContext("2d");
-    if (a == null) throw new Error("Could not get 2D context");
-    const l = new gt();
-    this.lower2d = q(
-      new R(a, l, this.dpr)
+    const c = this.lower2dCanvas.getContext("2d");
+    if (c == null) throw new Error("Could not get 2D context");
+    const d = new ut();
+    this.lower2d = G(
+      new R(c, d, this.dpr)
     );
-    const p = this.upper2dCanvas.getContext("2d");
-    if (p == null) throw new Error("Could not get 2D context");
-    this.upper2d = q(
-      new R(p, l, this.dpr)
+    const g = this.upper2dCanvas.getContext("2d");
+    if (g == null) throw new Error("Could not get 2D context");
+    this.upper2d = G(
+      new R(g, d, this.dpr)
     );
-    const d = {
+    const x = {
       preserveDrawingBuffer: !0,
       powerPreference: "high-performance",
       stencil: !1,
       depth: !1
-    }, o = this.glCanvas.getContext("webgl2", d);
-    if (o == null) throw new Error("Could not get WebGL context");
-    o.disable(o.DEPTH_TEST), o.disable(o.STENCIL_TEST), o.disable(o.CULL_FACE), o.disable(o.DITHER), this.gl = o, this.glCanvas.oncontextlost = console.error;
-    const u = () => {
+    }, p = this.glCanvas.getContext("webgl2", x);
+    if (p == null) throw new Error("Could not get WebGL context");
+    p.disable(p.DEPTH_TEST), p.disable(p.STENCIL_TEST), p.disable(p.CULL_FACE), p.disable(p.DITHER), this.gl = p, this.glCanvas.oncontextlost = () => h({
+      variant: "error",
+      message: "WebGL context lost"
+    });
+    const A = () => {
       this.gl.flush(), this.gl.finish();
     };
-    this.loop = new ft({
-      afterRender: u,
-      instrumentation: this.instrumentation
-    }), this.region = c.ZERO, this.os === "Windows" && (this.clearProgram = new ht(this));
+    this.loop = new dt({
+      afterRender: A,
+      instrumentation: this.instrumentation,
+      handleError: o
+    }), this.region = n.ZERO, this.os === "Windows" && (this.clearProgram = new pt(this));
   }
   static create(t, e, s, i, r) {
-    const a = tt(t, "render_context"), l = new g(
+    const h = rt(t, "render_context"), o = new w(
       e,
       s,
       i,
       r,
-      a
+      h,
+      Q(t),
+      j(t)
     );
-    return t.set(g.CONTEXT_KEY, l), l;
+    return t.set(w.CONTEXT_KEY, o), o;
   }
   static useOptional(t) {
-    return t.getOptional(g.CONTEXT_KEY);
+    return t.getOptional(w.CONTEXT_KEY);
   }
   static use(t) {
-    return t.get(g.CONTEXT_KEY);
+    return t.get(w.CONTEXT_KEY);
   }
   update(t) {
-    t.set(g.CONTEXT_KEY, this);
+    t.set(w.CONTEXT_KEY, this);
   }
   /**
    * Resizes the canvas to the given region and device pixel ratio. Ensuring
    * that all drawing operations and viewports are scaled correctly.
    */
   resize(t, e) {
-    c.equals(this.region, t) && this.dpr === e || (this.region = t, this.dpr = e, this.resizeCanvas(this.glCanvas), this.resizeCanvas(this.upper2dCanvas), this.resizeCanvas(this.lower2dCanvas), this.lower2d.scale(this.dpr, this.dpr), this.upper2d.scale(this.dpr, this.dpr), this.gl.viewport(0, 0, c.width(t) * e, c.height(t) * e));
+    n.equals(this.region, t) && this.dpr === e || (this.region = t, this.dpr = e, this.resizeCanvas(this.glCanvas), this.resizeCanvas(this.upper2dCanvas), this.resizeCanvas(this.lower2dCanvas), this.lower2d.scale(this.dpr, this.dpr), this.upper2d.scale(this.dpr, this.dpr), this.gl.viewport(0, 0, n.width(t) * e, n.height(t) * e));
   }
   resizeCanvas(t) {
-    t.width = c.width(this.region) * this.dpr, t.height = c.height(this.region) * this.dpr;
+    t.width = n.width(this.region) * this.dpr, t.height = n.height(this.region) * this.dpr;
   }
   /** @returns the aspect ratio of the canvas. */
   get aspect() {
-    return c.aspect(this.region);
+    return n.aspect(this.region);
   }
   /**
    * Takes the given box in PIXEL space and produces a transform
@@ -1068,48 +888,48 @@ const q = (h) => (h.textRendering = "optimizeSpeed", h.imageSmoothingEnabled = !
    * in the canvas.
    */
   scaleRegion(t) {
-    return new x.XY(
+    return new C.XY(
       // Accept a value in decimal.
-      x.Scale.scale(0, 1).scale(c.width(t)).translate(c.left(t)).reBound(c.width(this.region)).scale(-1, 1),
+      C.Scale.scale(0, 1).scale(n.width(t)).translate(n.left(t)).reBound(n.width(this.region)).scale(-1, 1),
       // Accept a value in decimal.
-      x.Scale.scale(0, 1).scale(c.height(t)).invert().translate(c.top(t)).reBound(c.height(this.region)).scale(-1, 1).invert()
+      C.Scale.scale(0, 1).scale(n.height(t)).invert().translate(n.top(t)).reBound(n.height(this.region)).scale(-1, 1).invert()
     );
   }
-  scissor(t, e = f.ZERO, s) {
+  scissor(t, e = u.ZERO, s) {
     const i = [];
     return s.includes("upper2d") && i.push(this.upper2d.scissor(t, e)), s.includes("lower2d") && i.push(this.lower2d.scissor(t, e)), s.includes("gl") && i.push(this.scissorGL(t, e)), () => i.forEach((r) => r());
   }
-  scissorGL(t, e = f.ZERO) {
-    return this.gl.enable(this.gl.SCISSOR_TEST), t = E(t, e), this.gl.scissor(
-      c.left(t) * this.dpr,
-      (c.height(this.region) - c.bottom(t)) * this.dpr,
-      c.width(t) * this.dpr,
-      c.height(t) * this.dpr
+  scissorGL(t, e = u.ZERO) {
+    return this.gl.enable(this.gl.SCISSOR_TEST), t = T(t, e), this.gl.scissor(
+      n.left(t) * this.dpr,
+      (n.height(this.region) - n.bottom(t)) * this.dpr,
+      n.width(t) * this.dpr,
+      n.height(t) * this.dpr
     ), () => this.gl.disable(this.gl.SCISSOR_TEST);
   }
-  erase(t, e = f.ZERO, ...s) {
-    e = f.construct(e), s.length === 0 && (s = ["upper2d", "lower2d", "gl"]), s.includes("upper2d") && this.eraseCanvas(this.upper2d, t, e), s.includes("lower2d") && this.eraseCanvas(this.lower2d, t, e), s.includes("gl") && this.eraseGL(t, e);
+  erase(t, e = u.ZERO, ...s) {
+    e = u.construct(e), s.length === 0 && (s = ["upper2d", "lower2d", "gl"]), s.includes("upper2d") && this.eraseCanvas(this.upper2d, t, e), s.includes("lower2d") && this.eraseCanvas(this.lower2d, t, e), s.includes("gl") && this.eraseGL(t, e);
   }
-  eraseGL(t, e = f.ZERO) {
+  eraseGL(t, e = u.ZERO) {
     var r;
-    const { gl: s } = this, i = this.scissorGL(E(t, e));
+    const { gl: s } = this, i = this.scissorGL(T(t, e));
     s.clearColor(...y.rgba1(y.ZERO)), s.clear(s.COLOR_BUFFER_BIT), this.os === "Windows" && ((r = this.clearProgram) == null || r.exec()), i();
   }
-  eraseCanvas(t, e, s = f.ZERO) {
-    const i = E(e, s);
-    t.clearRect(...f.couple(c.topLeft(i)), ...G.couple(c.dims(i)));
+  eraseCanvas(t, e, s = u.ZERO) {
+    const i = T(e, s);
+    t.clearRect(...u.couple(n.topLeft(i)), ...M.couple(n.dims(i)));
   }
 };
-n(g, "CONTEXT_KEY", H.B("render-context"));
-let D = g;
-const wt = m.object({
-  region: c.box,
-  enabled: m.boolean().optional().default(!1)
-}), B = ["gl", "lower2d", "upper2d"];
-class P extends Q {
+a(w, "CONTEXT_KEY", Z.B("render-context"));
+let D = w;
+const gt = N({
+  region: n.box,
+  enabled: st().optional().default(!1)
+}), Y = ["gl", "lower2d", "upper2d"];
+class P extends tt {
   constructor() {
     super(...arguments);
-    n(this, "schema", wt);
+    a(this, "schema", gt);
   }
   afterUpdate(e) {
     this.deleted || (this.internal.renderCtx = D.use(e), this.renderOnLifecycleChange());
@@ -1122,27 +942,26 @@ class P extends Q {
       key: `${this.type}-${this.key}`,
       render: this.render.bind(this),
       priority: "high",
-      canvases: B
+      canvases: Y
     });
   }
   render() {
-    this.deleted || !this.state.enabled || this.internal.renderCtx.erase(this.state.region, f.construct(0), ...B);
+    this.deleted || !this.state.enabled || this.internal.renderCtx.erase(this.state.region, u.construct(0), ...Y);
   }
 }
-n(P, "TYPE", "eraser");
-const Et = {
+a(P, "TYPE", "eraser");
+const St = {
   [P.TYPE]: P
 };
 export {
   D as C,
   P as E,
-  at as G,
-  ft as L,
-  ut as M,
-  b as P,
-  Et as R,
-  St as a,
-  wt as e,
-  j as p,
-  tt as u
+  ot as G,
+  dt as L,
+  O as P,
+  St as R,
+  Ct as a,
+  gt as e,
+  it as p,
+  rt as u
 };