@synnaxlabs/pluto 0.41.0 → 0.42.3

package/dist/eraser-CK8SwEJa.js

@@ -0,0 +1,1148 @@
+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 {
+  constructor() {
+    super(...arguments);
+    n(this, "schema", j);
+  }
+  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({
+      key: "aether",
+      logger: new _.Logger({ filters: i })
+    }), e.set(A, this.internal.ins);
+  }
+}
+n(b, "TYPE", "alamos.Provider");
+const tt = (h, t) => {
+  const e = h.get(A);
+  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
+);
+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");
+    this.wrapped = t, this.scale_ = i, this.atlasRegistry = e, this.dpr = s;
+  }
+  get fontStretch() {
+    return this.wrapped.fontStretch;
+  }
+  set fontStretch(t) {
+    this.wrapped.fontStretch = t;
+  }
+  get fontVariantCaps() {
+    return this.wrapped.fontVariantCaps;
+  }
+  set fontVariantCaps(t) {
+    this.wrapped.fontVariantCaps = t;
+  }
+  isContextLost() {
+    return this.wrapped.isContextLost();
+  }
+  get wordSpacing() {
+    return this.wrapped.wordSpacing;
+  }
+  set wordSpacing(t) {
+    this.wrapped.wordSpacing = t;
+  }
+  get letterSpacing() {
+    return this.wrapped.letterSpacing;
+  }
+  set letterSpacing(t) {
+    this.wrapped.letterSpacing = t;
+  }
+  get textRendering() {
+    return this.wrapped.textRendering;
+  }
+  set textRendering(t) {
+    this.wrapped.textRendering = t;
+  }
+  reset() {
+    this.wrapped.reset();
+  }
+  applyScale(t) {
+    return new R(
+      this,
+      this.atlasRegistry,
+      this.dpr,
+      t
+    );
+  }
+  get canvas() {
+    return this.wrapped.canvas;
+  }
+  get miterLimit() {
+    return this.cachedMiterLimit ?? this.wrapped.miterLimit;
+  }
+  set miterLimit(t) {
+    const e = this.scale_.x.dim(t);
+    e !== this.cachedMiterLimit && (this.cachedMiterLimit = e, this.wrapped.miterLimit = e);
+  }
+  get globalAlpha() {
+    return this.cachedGlobalAlpha ?? this.wrapped.globalAlpha;
+  }
+  set globalAlpha(t) {
+    t !== this.cachedGlobalAlpha && (this.cachedGlobalAlpha = t, this.wrapped.globalAlpha = t);
+  }
+  get globalCompositeOperation() {
+    return this.wrapped.globalCompositeOperation;
+  }
+  set globalCompositeOperation(t) {
+    this.wrapped.globalCompositeOperation = t;
+  }
+  get fillStyle() {
+    return this.cachedFillStyle ?? this.wrapped.fillStyle;
+  }
+  set fillStyle(t) {
+    t !== this.cachedFillStyle && (this.cachedFillStyle = t, this.wrapped.fillStyle = t);
+  }
+  get strokeStyle() {
+    return this.cachedStrokeStyle ?? this.wrapped.strokeStyle;
+  }
+  set strokeStyle(t) {
+    t !== this.cachedStrokeStyle && (this.cachedStrokeStyle = t, this.wrapped.strokeStyle = t);
+  }
+  drawImage(t, e, s, i, r, a, l, p, 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,
+      d != null ? this.scale_.y.dim(d) : d
+    );
+  }
+  beginPath() {
+    this.wrapped.beginPath();
+  }
+  clip(t, e) {
+    this.wrapped.clip(t, e);
+  }
+  fill(t, e) {
+    if (t == null) return this.wrapped.fill();
+    this.wrapped.fill(t, e);
+  }
+  isPointInPath(t, e, s, i) {
+    return this.wrapped.isPointInPath(t, e, s, i);
+  }
+  isPointInStroke(t, e, s) {
+    return this.wrapped.isPointInStroke(t, e, s);
+  }
+  stroke(t) {
+    if (t == null) return this.wrapped.stroke();
+    this.wrapped.stroke(t);
+  }
+  createConicGradient(t, e, s) {
+    return this.wrapped.createConicGradient(t, e, s);
+  }
+  createLinearGradient(t, e, s, i) {
+    return this.wrapped.createLinearGradient(t, e, s, i);
+  }
+  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);
+  }
+  get filter() {
+    return this.wrapped.filter;
+  }
+  set filter(t) {
+    this.wrapped.filter = t;
+  }
+  createImageData(t, e, s) {
+    return this.wrapped.createImageData(t, e, s);
+  }
+  getImageData(t, e, s, i, r) {
+    return this.wrapped.getImageData(t, e, s, i, r);
+  }
+  putImageData(t, e, s, i, r, a, l) {
+    this.wrapped.putImageData(
+      // @ts-expect-error - typescript overloads cause issues here
+      t,
+      e,
+      s,
+      i,
+      r,
+      a,
+      l
+    );
+  }
+  get imageSmoothingEnabled() {
+    return this.wrapped.imageSmoothingEnabled;
+  }
+  set imageSmoothingEnabled(t) {
+    this.wrapped.imageSmoothingEnabled = t;
+  }
+  get imageSmoothingQuality() {
+    return this.wrapped.imageSmoothingQuality;
+  }
+  set imageSmoothingQuality(t) {
+    this.wrapped.imageSmoothingQuality = t;
+  }
+  arc(t, e, s, i, r, a) {
+    this.wrapped.arc(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.dim(s),
+      i,
+      r,
+      a
+    );
+  }
+  arcTo(t, e, s, i, r) {
+    this.wrapped.arcTo(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.pos(s),
+      this.scale_.y.pos(i),
+      this.scale_.x.dim(r)
+    );
+  }
+  bezierCurveTo(t, e, s, i, r, a) {
+    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)
+    );
+  }
+  closePath() {
+    this.wrapped.closePath();
+  }
+  ellipse(t, e, s, i, r, a, l, p) {
+    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
+    );
+  }
+  lineTo(t, e) {
+    this.wrapped.lineTo(this.scale_.x.pos(t), this.scale_.y.pos(e));
+  }
+  moveTo(t, e) {
+    this.wrapped.moveTo(this.scale_.x.pos(t), this.scale_.y.pos(e));
+  }
+  quadraticCurveTo(t, e, s, i) {
+    this.wrapped.quadraticCurveTo(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.pos(s),
+      this.scale_.y.pos(i)
+    );
+  }
+  rect(t, e, s, i) {
+    this.wrapped.rect(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.dim(s),
+      this.scale_.y.dim(i)
+    );
+  }
+  roundRect(t, e, s, i, r) {
+    this.wrapped.roundRect(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.dim(s),
+      this.scale_.y.dim(i),
+      typeof r == "number" ? this.scale_.x.dim(r) : r
+    );
+  }
+  get lineCap() {
+    return this.cachedLineCap ?? this.wrapped.lineCap;
+  }
+  set lineCap(t) {
+    t !== this.cachedLineCap && (this.cachedLineCap = t, this.wrapped.lineCap = t);
+  }
+  get lineDashOffset() {
+    return this.wrapped.lineDashOffset;
+  }
+  set lineDashOffset(t) {
+    this.wrapped.lineDashOffset = this.scale_.x.dim(t);
+  }
+  get lineJoin() {
+    return this.cachedLineJoin ?? this.wrapped.lineJoin;
+  }
+  set lineJoin(t) {
+    t !== this.cachedLineJoin && (this.cachedLineJoin = t, this.wrapped.lineJoin = t);
+  }
+  get lineWidth() {
+    return this.cachedLineWidth ?? this.wrapped.lineWidth;
+  }
+  set lineWidth(t) {
+    const e = this.scale_.x.dim(t);
+    e !== this.cachedLineWidth && (this.cachedLineWidth = e, this.wrapped.lineWidth = e);
+  }
+  getLineDash() {
+    return this.wrapped.getLineDash();
+  }
+  setLineDash(t) {
+    const e = Array.from(t).map((s) => this.scale_.x.dim(s));
+    this.wrapped.setLineDash(e);
+  }
+  clearRect(t, e, s, i) {
+    this.wrapped.clearRect(t, e, s, i);
+  }
+  fillRect(t, e, s, i) {
+    this.wrapped.fillRect(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.dim(s),
+      this.scale_.y.dim(i)
+    );
+  }
+  strokeRect(t, e, s, i) {
+    this.wrapped.strokeRect(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.dim(s),
+      this.scale_.y.dim(i)
+    );
+  }
+  get shadowBlur() {
+    return this.wrapped.shadowBlur;
+  }
+  set shadowBlur(t) {
+    this.wrapped.shadowBlur = t;
+  }
+  get shadowColor() {
+    return this.wrapped.shadowColor;
+  }
+  set shadowColor(t) {
+    this.wrapped.shadowColor = t;
+  }
+  get shadowOffsetX() {
+    return this.wrapped.shadowOffsetX;
+  }
+  set shadowOffsetX(t) {
+    this.wrapped.shadowOffsetX = t;
+  }
+  get shadowOffsetY() {
+    return this.wrapped.shadowOffsetY;
+  }
+  restore() {
+    this.cachedFillStyle = null, this.cachedStrokeStyle = null, this.cachedLineWidth = null, this.cachedGlobalAlpha = null, this.cachedTextAlign = null, this.cachedTextBaseline = null, this.cachedLineCap = null, this.cachedLineJoin = null, this.cachedMiterLimit = null, this.cachedFont = null, this.wrapped.restore();
+  }
+  save() {
+    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);
+      return;
+    }
+    this.wrapped.fillText(
+      t,
+      this.scale_.x.pos(e),
+      this.scale_.y.pos(s),
+      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;
+  }
+  strokeText(t, e, s, i) {
+    this.wrapped.strokeText(
+      t,
+      this.scale_.x.pos(e),
+      this.scale_.y.pos(s),
+      i != null ? this.scale_.x.dim(i) : void 0
+    );
+  }
+  get direction() {
+    return this.wrapped.direction;
+  }
+  set direction(t) {
+    this.wrapped.direction = t;
+  }
+  get font() {
+    return this.cachedFont != null ? this.cachedFont : this.wrapped.font;
+  }
+  set font(t) {
+    t !== this.cachedFont && (this.cachedFont = t, this.wrapped.font = this.cachedFont);
+  }
+  get fontKerning() {
+    return this.wrapped.fontKerning;
+  }
+  set fontKerning(t) {
+    this.wrapped.fontKerning = t;
+  }
+  get textAlign() {
+    return this.cachedTextAlign ?? this.wrapped.textAlign;
+  }
+  set textAlign(t) {
+    t !== this.cachedTextAlign && (this.cachedTextAlign = t, this.wrapped.textAlign = t);
+  }
+  get textBaseline() {
+    return this.cachedTextBaseline ?? this.wrapped.textBaseline;
+  }
+  set textBaseline(t) {
+    t !== this.cachedTextBaseline && (this.cachedTextBaseline = t, this.wrapped.textBaseline = t);
+  }
+  getTransform() {
+    return this.wrapped.getTransform();
+  }
+  resetTransform() {
+    this.wrapped.resetTransform();
+  }
+  rotate(t) {
+    this.wrapped.rotate(t);
+  }
+  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();
+  }
+  setTransform(t, e, s, i, r, a) {
+    this.wrapped.setTransform(t, e, s, i, r, a);
+  }
+  transform(t, e, s, i, r, a) {
+    this.wrapped.transform(t, e, s, i, r, a);
+  }
+  translate(t, e) {
+    this.wrapped.translate(t, e);
+  }
+}
+class et {
+  constructor(t = x.XY.IDENTITY, e) {
+    n(this, "scale_");
+    n(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) {
+    this.path.arc(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.dim(s),
+      i,
+      r,
+      a
+    );
+  }
+  arcTo(t, e, s, i, r) {
+    this.path.arcTo(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.pos(s),
+      this.scale_.y.pos(i),
+      this.scale_.x.dim(r)
+    );
+  }
+  bezierCurveTo(t, e, s, i, r, a) {
+    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)
+    );
+  }
+  closePath() {
+    this.path.closePath();
+  }
+  ellipse(t, e, s, i, r, a, l, p) {
+    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
+    );
+  }
+  lineTo(t, e) {
+    this.path.lineTo(this.scale_.x.pos(t), this.scale_.y.pos(e));
+  }
+  moveTo(t, e) {
+    this.path.moveTo(this.scale_.x.pos(t), this.scale_.y.pos(e));
+  }
+  quadraticCurveTo(t, e, s, i) {
+    this.path.quadraticCurveTo(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.pos(s),
+      this.scale_.y.pos(i)
+    );
+  }
+  rect(t, e, s, i) {
+    this.path.rect(
+      this.scale_.x.pos(t),
+      this.scale_.y.pos(e),
+      this.scale_.x.dim(s),
+      this.scale_.y.dim(i)
+    );
+  }
+  roundRect(t, e, s, i, r) {
+    const a = 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
+    );
+  }
+  // Helper method to scale radii for roundRect
+  scaleRadii(t) {
+    return t == null ? t : typeof t == "number" ? this.scale_.x.dim(t) : Array.isArray(t) ? t.map((e) => this.scaleRadius(e)) : this.scaleRadius(t);
+  }
+  scaleRadius(t) {
+    return typeof t == "number" ? this.scale_.x.dim(t) : {
+      x: this.scale_.x.dim(t.x ?? 0),
+      y: this.scale_.y.dim(t.y ?? 0)
+    };
+  }
+  // Method to retrieve the underlying Path2D
+  getPath() {
+    return this.path;
+  }
+}
+const st = `precision mediump float;
+
+void main(void) {
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);    
+}
+`, it = `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 {
+  /**
+   * @constructor compiles the given vertex and fragment shaders under the given
+   * render context into a program.
+   *
+   * @param ctx - The render context to use.
+   * @param vertShader - The vertex shader code.
+   * @param fragShader - The fragment shader code.
+   */
+  constructor(t, e, s) {
+    /** The render context used by this program. */
+    n(this, "renderCtx");
+    /** The underlying webgl program. */
+    n(this, "prog");
+    /** The code for the vertex shader. */
+    n(this, "vertShader");
+    /** The code for the fragment shader. */
+    n(this, "fragShader");
+    n(this, "uniformLocCache", /* @__PURE__ */ new Map());
+    this.renderCtx = t;
+    const i = t.gl.createProgram();
+    if (i == null) throw k("failed to create program");
+    this.prog = i, this.vertShader = e, this.fragShader = s, this.compile();
+  }
+  /** Sets the current program as the active program used by the context. */
+  setAsActive() {
+    return this.renderCtx.gl.useProgram(this.prog), () => this.renderCtx.gl.useProgram(null);
+  }
+  /**
+   * Sets a uniform XY coordinate value.
+   *
+   * @param name - The name of the uniform.
+   * @param value - The value to set.
+   */
+  uniformXY(t, e) {
+    this.renderCtx.gl.uniform2fv(this.getUniformLoc(t), f.couple(e));
+  }
+  /**
+   * Sets a uniform color value.
+   *
+   * @param name - The name of the uniform.
+   * @param value - The value to set.
+   */
+  uniformColor(t, e) {
+    this.renderCtx.gl.uniform4fv(this.getUniformLoc(t), y.rgba1(e));
+  }
+  getUniformLoc(t) {
+    const e = this.uniformLocCache.get(t);
+    if (e != null) return e;
+    const s = this.renderCtx.gl.getUniformLocation(this.prog, t);
+    if (s == null) throw new Error(`unexpected missing uniform ${t}`);
+    return this.uniformLocCache.set(t, s), s;
+  }
+  compile() {
+    const t = this.renderCtx.gl;
+    this.compileShader(this.vertShader, t.VERTEX_SHADER), this.compileShader(this.fragShader, t.FRAGMENT_SHADER), t.linkProgram(this.prog);
+  }
+  compileShader(t, e) {
+    const s = this.renderCtx.gl, i = s.createShader(e);
+    if (i == null) throw rt;
+    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");
+    }
+    s.attachShader(this.prog, i);
+  }
+};
+const nt = new Float32Array([0, 0, 0, 0, 0, 0]);
+class ht extends at {
+  constructor(e) {
+    super(e, it, st);
+    n(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);
+  }
+  exec() {
+    const { gl: e } = this.renderCtx, s = e.getAttribLocation(this.prog, "a_position");
+    e.bindBuffer(e.ARRAY_BUFFER, this.positionBuffer);
+    const i = e.createVertexArray();
+    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 {
+  constructor({
+    afterRender: t,
+    instrumentation: e = _.Instrumentation.NOOP
+  }) {
+    /** 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());
+    /** Stores render cleanup functions for clearing canvases and other resources. */
+    n(this, "cleanup", /* @__PURE__ */ new Map());
+    /** A callback to run after each render call. */
+    n(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();
+  }
+  /**
+   * Sets a new request in the queue according to a set of rules:
+   *
+   * 1. If no request with the same key exists, add the request to the queue.
+   * 2. If a request with the same key exists, replace it if the new request has a
+   * greater or equal priority and a greater or equal number of canvases that are
+   * being rendered to.
+   *
+   * @param req - The request to set.
+   */
+  set(t) {
+    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;
+      s && i && this.requests.set(t.key, t);
+    }
+  }
+  /** Execute the render. */
+  render() {
+    var r;
+    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);
+  }
+  runCleanupsSync() {
+    const { cleanup: t, requests: e } = this;
+    t.forEach((s, i) => {
+      const r = e.get(i);
+      r != null && (s(r), t.delete(i));
+    });
+  }
+  renderSync() {
+    const { requests: t } = this;
+    t.forEach((e) => {
+      try {
+        const s = e.render();
+        s != null && this.cleanup.set(e.key, s);
+      } catch (s) {
+        console.error(s);
+      }
+    });
+  }
+  /** Starts the rendering loop. */
+  async start() {
+    const t = () => {
+      try {
+        this.render();
+      } catch (e) {
+        console.error(e);
+      }
+      requestAnimationFrame(t);
+    };
+    requestAnimationFrame(t);
+  }
+}
+const T = 2, v = class v {
+  constructor(t) {
+    // A canvas buffer that holds rendered characters.
+    n(this, "atlas");
+    // Cached dimensions of a character.
+    n(this, "charDims");
+    // The device pixel ratio of the atlas.
+    n(this, "dpr");
+    // 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);
+    this.atlas = new OffscreenCanvas(
+      u * S * this.dpr,
+      C * (W + 1) * this.dpr
+    );
+    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);
+    });
+  }
+  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);
+      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,
+        r,
+        a
+      );
+    }
+  }
+  measureText(t) {
+    return { width: t.length * this.charDims.width, height: this.charDims.height };
+  }
+};
+// The default characters to include in the atlas.
+n(v, "DEFAULT_CHARS", "0123456789.:-umsNa∞ᴇ");
+let O = v;
+class gt {
+  constructor() {
+    n(this, "atlases");
+    this.atlases = /* @__PURE__ */ new Map();
+  }
+  /**
+   * @returns at atlas from the registry compatible with the given props. If the
+   * 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}`;
+    if (this.atlases.has(e)) return this.atlases.get(e);
+    const s = new O(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) {
+    /* The canvas element used by WebGL. */
+    n(this, "glCanvas");
+    /** The canvas element used by the 2D canvas. */
+    n(this, "upper2dCanvas");
+    /** The canvas element used by the 2D canvas. */
+    n(this, "lower2dCanvas");
+    /** The WebGL rendering context.  */
+    n(this, "gl");
+    /** A 2D canvas that sits below the WebGL canvas. */
+    n(this, "lower2d");
+    /** A 2D canvas that sits above the WebGL canvas. */
+    n(this, "upper2d");
+    /** The region the canvas occupies in pixel space */
+    n(this, "region");
+    /** The device pixel ratio of the canvas */
+    n(this, "dpr");
+    /** queue render transitions onto the stack */
+    n(this, "loop");
+    /** See the @link{clear.Program} for why this is necessary. */
+    n(this, "clearProgram");
+    n(this, "os");
+    n(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 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 d = {
+      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 = () => {
+      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));
+  }
+  static create(t, e, s, i, r) {
+    const a = tt(t, "render_context"), l = new g(
+      e,
+      s,
+      i,
+      r,
+      a
+    );
+    return t.set(g.CONTEXT_KEY, l), l;
+  }
+  static useOptional(t) {
+    return t.getOptional(g.CONTEXT_KEY);
+  }
+  static use(t) {
+    return t.get(g.CONTEXT_KEY);
+  }
+  update(t) {
+    t.set(g.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));
+  }
+  resizeCanvas(t) {
+    t.width = c.width(this.region) * this.dpr, t.height = c.height(this.region) * this.dpr;
+  }
+  /** @returns the aspect ratio of the canvas. */
+  get aspect() {
+    return c.aspect(this.region);
+  }
+  /**
+   * Takes the given box in PIXEL space and produces a transform
+   * in CLIP space representing the sub-region represented by the box
+   * in the canvas.
+   */
+  scaleRegion(t) {
+    return new x.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),
+      // 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()
+    );
+  }
+  scissor(t, e = f.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
+    ), () => 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);
+  }
+  eraseGL(t, e = f.ZERO) {
+    var r;
+    const { gl: s } = this, i = this.scissorGL(E(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)));
+  }
+};
+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 {
+  constructor() {
+    super(...arguments);
+    n(this, "schema", wt);
+  }
+  afterUpdate(e) {
+    this.deleted || (this.internal.renderCtx = D.use(e), this.renderOnLifecycleChange());
+  }
+  afterDelete() {
+    this.renderOnLifecycleChange();
+  }
+  renderOnLifecycleChange() {
+    this.internal.renderCtx.loop.set({
+      key: `${this.type}-${this.key}`,
+      render: this.render.bind(this),
+      priority: "high",
+      canvases: B
+    });
+  }
+  render() {
+    this.deleted || !this.state.enabled || this.internal.renderCtx.erase(this.state.region, f.construct(0), ...B);
+  }
+}
+n(P, "TYPE", "eraser");
+const Et = {
+  [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
+};