@synnaxlabs/pluto 0.41.0 → 0.42.3

package/dist/eraser-BjtEI-1I.js

@@ -1,823 +0,0 @@
-var b = Object.defineProperty;
-var A = (h, e, t) => e in h ? b(h, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : h[e] = t;
-var o = (h, e, t) => A(h, typeof e != "symbol" ? e + "" : e, t);
-import { $ as L, w as P } from "./index-CSKP1UPN.js";
-import { z as y } from "zod";
-import { Z as D, M as I, L as B } from "./provider-CH0eoGfz.js";
-import { $ as n, q as u, J as p, _ as O, C as k, Z as G } from "./css-Dyt-QnKy.js";
-const g = (h, e) => n.construct(
-  n.left(h) - e.x,
-  n.top(h) - e.y,
-  n.width(h) + e.x * 2,
-  n.height(h) + e.y * 2
-);
-class w {
-  constructor(e, t = u.XY.IDENTITY) {
-    o(this, "scale_");
-    o(this, "wrapped");
-    this.wrapped = e, this.scale_ = t;
-  }
-  get fontStretch() {
-    return this.wrapped.fontStretch;
-  }
-  set fontStretch(e) {
-    this.wrapped.fontStretch = e;
-  }
-  get fontVariantCaps() {
-    return this.wrapped.fontVariantCaps;
-  }
-  set fontVariantCaps(e) {
-    this.wrapped.fontVariantCaps = e;
-  }
-  isContextLost() {
-    return this.wrapped.isContextLost();
-  }
-  get wordSpacing() {
-    return this.wrapped.wordSpacing;
-  }
-  set wordSpacing(e) {
-    this.wrapped.wordSpacing = e;
-  }
-  get letterSpacing() {
-    return this.wrapped.letterSpacing;
-  }
-  set letterSpacing(e) {
-    this.wrapped.letterSpacing = e;
-  }
-  get textRendering() {
-    return this.wrapped.textRendering;
-  }
-  set textRendering(e) {
-    this.wrapped.textRendering = e;
-  }
-  reset() {
-    this.wrapped.reset();
-  }
-  applyScale(e) {
-    return new w(this, e);
-  }
-  get canvas() {
-    return this.wrapped.canvas;
-  }
-  get miterLimit() {
-    return this.wrapped.miterLimit;
-  }
-  set miterLimit(e) {
-    this.wrapped.miterLimit = this.scale_.x.dim(e);
-  }
-  get globalAlpha() {
-    return this.wrapped.globalAlpha;
-  }
-  set globalAlpha(e) {
-    this.wrapped.globalAlpha = e;
-  }
-  get globalCompositeOperation() {
-    return this.wrapped.globalCompositeOperation;
-  }
-  set globalCompositeOperation(e) {
-    this.wrapped.globalCompositeOperation = e;
-  }
-  get fillStyle() {
-    return this.wrapped.fillStyle;
-  }
-  set fillStyle(e) {
-    this.wrapped.fillStyle = e;
-  }
-  get strokeStyle() {
-    return this.wrapped.strokeStyle;
-  }
-  set strokeStyle(e) {
-    this.wrapped.strokeStyle = e;
-  }
-  drawImage(e, t, s, i, r, a, c, l, f) {
-    this.wrapped.drawImage(e, t, s, i, r, a, c, l, f);
-  }
-  beginPath() {
-    this.wrapped.beginPath();
-  }
-  clip(e, t) {
-    this.wrapped.clip(e, t);
-  }
-  fill(e, t) {
-    if (e == null) return this.wrapped.fill();
-    this.wrapped.fill(e, t);
-  }
-  isPointInPath(e, t, s, i) {
-    return this.wrapped.isPointInPath(e, t, s, i);
-  }
-  isPointInStroke(e, t, s) {
-    return this.wrapped.isPointInStroke(e, t, s);
-  }
-  stroke(e) {
-    if (e == null) return this.wrapped.stroke();
-    this.wrapped.stroke(e);
-  }
-  createConicGradient(e, t, s) {
-    return this.wrapped.createConicGradient(e, t, s);
-  }
-  createLinearGradient(e, t, s, i) {
-    return this.wrapped.createLinearGradient(e, t, s, i);
-  }
-  createPattern(e, t) {
-    return this.wrapped.createPattern(e, t);
-  }
-  createRadialGradient(e, t, s, i, r, a) {
-    return this.wrapped.createRadialGradient(e, t, s, i, r, a);
-  }
-  get filter() {
-    return this.wrapped.filter;
-  }
-  set filter(e) {
-    this.wrapped.filter = e;
-  }
-  createImageData(e, t, s) {
-    return this.wrapped.createImageData(e, t, s);
-  }
-  getImageData(e, t, s, i, r) {
-    return this.wrapped.getImageData(e, t, s, i, r);
-  }
-  putImageData(e, t, s, i, r, a, c) {
-    this.wrapped.putImageData(
-      // @ts-expect-error - typescript overloads cause issues here
-      e,
-      t,
-      s,
-      i,
-      r,
-      a,
-      c
-    );
-  }
-  get imageSmoothingEnabled() {
-    return this.wrapped.imageSmoothingEnabled;
-  }
-  set imageSmoothingEnabled(e) {
-    this.wrapped.imageSmoothingEnabled = e;
-  }
-  get imageSmoothingQuality() {
-    return this.wrapped.imageSmoothingQuality;
-  }
-  set imageSmoothingQuality(e) {
-    this.wrapped.imageSmoothingQuality = e;
-  }
-  arc(e, t, s, i, r, a) {
-    this.wrapped.arc(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      i,
-      r,
-      a
-    );
-  }
-  arcTo(e, t, s, i, r) {
-    this.wrapped.arcTo(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.pos(s),
-      this.scale_.y.pos(i),
-      this.scale_.x.dim(r)
-    );
-  }
-  bezierCurveTo(e, t, s, i, r, a) {
-    this.wrapped.bezierCurveTo(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      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(e, t, s, i, r, a, c, l) {
-    this.wrapped.ellipse(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i),
-      r,
-      a,
-      c,
-      l
-    );
-  }
-  lineTo(e, t) {
-    this.wrapped.lineTo(this.scale_.x.pos(e), this.scale_.y.pos(t));
-  }
-  moveTo(e, t) {
-    this.wrapped.moveTo(this.scale_.x.pos(e), this.scale_.y.pos(t));
-  }
-  quadraticCurveTo(e, t, s, i) {
-    this.wrapped.quadraticCurveTo(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.pos(s),
-      this.scale_.y.pos(i)
-    );
-  }
-  rect(e, t, s, i) {
-    this.wrapped.rect(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i)
-    );
-  }
-  roundRect(e, t, s, i, r) {
-    this.wrapped.roundRect(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i),
-      typeof r == "number" ? this.scale_.x.dim(r) : r
-    );
-  }
-  get lineCap() {
-    return this.wrapped.lineCap;
-  }
-  set lineCap(e) {
-    this.wrapped.lineCap = e;
-  }
-  get lineDashOffset() {
-    return this.wrapped.lineDashOffset;
-  }
-  set lineDashOffset(e) {
-    this.wrapped.lineDashOffset = this.scale_.x.dim(e);
-  }
-  get lineJoin() {
-    return this.wrapped.lineJoin;
-  }
-  set lineJoin(e) {
-    this.wrapped.lineJoin = e;
-  }
-  get lineWidth() {
-    return this.wrapped.lineWidth;
-  }
-  set lineWidth(e) {
-    this.wrapped.lineWidth = this.scale_.x.dim(e);
-  }
-  getLineDash() {
-    return this.wrapped.getLineDash();
-  }
-  setLineDash(e) {
-    const t = Array.from(e).map((s) => this.scale_.x.dim(s));
-    this.wrapped.setLineDash(t);
-  }
-  clearRect(e, t, s, i) {
-    this.wrapped.clearRect(e, t, s, i);
-  }
-  fillRect(e, t, s, i) {
-    this.wrapped.fillRect(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i)
-    );
-  }
-  strokeRect(e, t, s, i) {
-    this.wrapped.strokeRect(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i)
-    );
-  }
-  get shadowBlur() {
-    return this.wrapped.shadowBlur;
-  }
-  set shadowBlur(e) {
-    this.wrapped.shadowBlur = e;
-  }
-  get shadowColor() {
-    return this.wrapped.shadowColor;
-  }
-  set shadowColor(e) {
-    this.wrapped.shadowColor = e;
-  }
-  get shadowOffsetX() {
-    return this.wrapped.shadowOffsetX;
-  }
-  set shadowOffsetX(e) {
-    this.wrapped.shadowOffsetX = e;
-  }
-  get shadowOffsetY() {
-    return this.wrapped.shadowOffsetY;
-  }
-  restore() {
-    this.wrapped.restore();
-  }
-  save() {
-    this.wrapped.save();
-  }
-  fillText(e, t, s, i) {
-    this.wrapped.fillText(
-      e,
-      this.scale_.x.pos(t),
-      this.scale_.y.pos(s),
-      i != null ? this.scale_.x.dim(i) : void 0
-    );
-  }
-  measureText(e) {
-    this.wrapped.font = m(this.wrapped.font, this.scale_.x.reverse());
-    const t = this.wrapped.measureText(e);
-    return this.wrapped.font = m(this.wrapped.font, this.scale_.x), t;
-  }
-  strokeText(e, t, s, i) {
-    this.wrapped.strokeText(
-      e,
-      this.scale_.x.pos(t),
-      this.scale_.y.pos(s),
-      i != null ? this.scale_.x.dim(i) : void 0
-    );
-  }
-  get direction() {
-    return this.wrapped.direction;
-  }
-  set direction(e) {
-    this.wrapped.direction = e;
-  }
-  get font() {
-    return this.wrapped.font;
-  }
-  set font(e) {
-    this.wrapped.font = m(e, this.scale_.x);
-  }
-  get fontKerning() {
-    return this.wrapped.fontKerning;
-  }
-  set fontKerning(e) {
-    this.wrapped.fontKerning = e;
-  }
-  get textAlign() {
-    return this.wrapped.textAlign;
-  }
-  set textAlign(e) {
-    this.wrapped.textAlign = e;
-  }
-  get textBaseline() {
-    return this.wrapped.textBaseline;
-  }
-  set textBaseline(e) {
-    this.wrapped.textBaseline = e;
-  }
-  getTransform() {
-    return this.wrapped.getTransform();
-  }
-  resetTransform() {
-    this.wrapped.resetTransform();
-  }
-  rotate(e) {
-    this.wrapped.rotate(e);
-  }
-  scale(e, t) {
-    this.wrapped.scale(e, t);
-  }
-  scissor(e, t = p.ZERO) {
-    const s = new Y(this.scale_);
-    return e = g(e, t), s.rect(...p.couple(n.topLeft(e)), ...O.couple(n.dims(e))), this.save(), this.clip(s.getPath()), () => this.restore();
-  }
-  setTransform(e, t, s, i, r, a) {
-    this.wrapped.setTransform(e, t, s, i, r, a);
-  }
-  transform(e, t, s, i, r, a) {
-    this.wrapped.transform(e, t, s, i, r, a);
-  }
-  translate(e, t) {
-    this.wrapped.translate(e, t);
-  }
-}
-const C = /(\d+(\.\d+)?)px/, m = (h, e) => {
-  var i;
-  const t = Number((i = h.match(C)) == null ? void 0 : i[1]);
-  if (t == null) return h;
-  const s = e.dim(t);
-  return h.replace(C, `${s}px`);
-};
-class Y {
-  constructor(e = u.XY.IDENTITY, t) {
-    o(this, "scale_");
-    o(this, "path");
-    this.scale_ = e, t instanceof Path2D || typeof t == "string" ? this.path = new Path2D(t) : this.path = new Path2D();
-  }
-  addPath(e, t) {
-    this.path.addPath(e, t);
-  }
-  arc(e, t, s, i, r, a) {
-    this.path.arc(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      i,
-      r,
-      a
-    );
-  }
-  arcTo(e, t, s, i, r) {
-    this.path.arcTo(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.pos(s),
-      this.scale_.y.pos(i),
-      this.scale_.x.dim(r)
-    );
-  }
-  bezierCurveTo(e, t, s, i, r, a) {
-    this.path.bezierCurveTo(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      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(e, t, s, i, r, a, c, l) {
-    this.path.ellipse(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i),
-      r,
-      a,
-      c,
-      l
-    );
-  }
-  lineTo(e, t) {
-    this.path.lineTo(this.scale_.x.pos(e), this.scale_.y.pos(t));
-  }
-  moveTo(e, t) {
-    this.path.moveTo(this.scale_.x.pos(e), this.scale_.y.pos(t));
-  }
-  quadraticCurveTo(e, t, s, i) {
-    this.path.quadraticCurveTo(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.pos(s),
-      this.scale_.y.pos(i)
-    );
-  }
-  rect(e, t, s, i) {
-    this.path.rect(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i)
-    );
-  }
-  roundRect(e, t, s, i, r) {
-    const a = this.scaleRadii(r);
-    this.path.roundRect(
-      this.scale_.x.pos(e),
-      this.scale_.y.pos(t),
-      this.scale_.x.dim(s),
-      this.scale_.y.dim(i),
-      a
-    );
-  }
-  // Helper method to scale radii for roundRect
-  scaleRadii(e) {
-    return e == null ? e : typeof e == "number" ? this.scale_.x.dim(e) : Array.isArray(e) ? e.map((t) => this.scaleRadius(t)) : this.scaleRadius(e);
-  }
-  scaleRadius(e) {
-    return typeof e == "number" ? this.scale_.x.dim(e) : {
-      x: this.scale_.x.dim(e.x ?? 0),
-      y: this.scale_.y.dim(e.y ?? 0)
-    };
-  }
-  // Method to retrieve the underlying Path2D
-  getPath() {
-    return this.path;
-  }
-}
-const F = `precision mediump float;
-
-void main(void) {
-    gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);    
-}
-`, z = `attribute vec4 a_position;
-
-void main(void) {
-  gl_Position = a_position;
-}
-`, S = (h) => new Error(`failed to compile webgl program: ${h}`), X = new Error("null shader encountered");
-let N = 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(e, t, s) {
-    /** The render context used by this program. */
-    o(this, "renderCtx");
-    /** The underlying webgl program. */
-    o(this, "prog");
-    /** The code for the vertex shader. */
-    o(this, "vertShader");
-    /** The code for the fragment shader. */
-    o(this, "fragShader");
-    o(this, "uniformLocCache", /* @__PURE__ */ new Map());
-    this.renderCtx = e;
-    const i = e.gl.createProgram();
-    if (i == null) throw S("failed to create program");
-    this.prog = i, this.vertShader = t, 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(e, t) {
-    this.renderCtx.gl.uniform2fv(this.getUniformLoc(e), p.couple(t));
-  }
-  /**
-   * Sets a uniform color value.
-   *
-   * @param name - The name of the uniform.
-   * @param value - The value to set.
-   */
-  uniformColor(e, t) {
-    this.renderCtx.gl.uniform4fv(this.getUniformLoc(e), t.rgba1);
-  }
-  getUniformLoc(e) {
-    const t = this.uniformLocCache.get(e);
-    if (t != null) return t;
-    const s = this.renderCtx.gl.getUniformLocation(this.prog, e);
-    if (s == null) throw new Error(`unexpected missing uniform ${e}`);
-    return this.uniformLocCache.set(e, s), s;
-  }
-  compile() {
-    const e = this.renderCtx.gl;
-    this.compileShader(this.vertShader, e.VERTEX_SHADER), this.compileShader(this.fragShader, e.FRAGMENT_SHADER), e.linkProgram(this.prog);
-  }
-  compileShader(e, t) {
-    const s = this.renderCtx.gl, i = s.createShader(t);
-    if (i == null) throw X;
-    if (s.shaderSource(i, e), s.compileShader(i), !s.getShaderParameter(i, s.COMPILE_STATUS)) {
-      const a = s.getShaderInfoLog(i);
-      throw s.deleteShader(i), S(a ?? "unknown");
-    }
-    s.attachShader(this.prog, i);
-  }
-};
-const q = new Float32Array([0, 0, 0, 0, 0, 0]);
-class Z extends N {
-  constructor(t) {
-    super(t, z, F);
-    o(this, "positionBuffer");
-    const s = t.gl.createBuffer();
-    if (s == null) throw new D("webgl: failed to create buffer");
-    this.positionBuffer = s, t.gl.bindBuffer(t.gl.ARRAY_BUFFER, this.positionBuffer), t.gl.bufferData(t.gl.ARRAY_BUFFER, q, t.gl.STATIC_DRAW);
-  }
-  exec() {
-    const { gl: t } = this.renderCtx, s = t.getAttribLocation(this.prog, "a_position");
-    t.bindBuffer(t.ARRAY_BUFFER, this.positionBuffer);
-    const i = t.createVertexArray();
-    t.bindVertexArray(i), t.enableVertexAttribArray(s), t.vertexAttribPointer(s, 2, t.FLOAT, !1, 0, 0), this.setAsActive(), t.drawArrays(t.TRIANGLES, 0, 3);
-  }
-}
-const T = { high: 1, low: 0 }, R = L.hz(45);
-class K {
-  constructor(e) {
-    /** To lock things so renders don't collide */
-    o(this, "mutex", new I());
-    /** Stores the current requests for rendering. */
-    o(this, "requests", /* @__PURE__ */ new Map());
-    /** Stores render cleanup functions for clearing canvases and other resources. */
-    o(this, "cleanup", /* @__PURE__ */ new Map());
-    o(this, "afterRender");
-    this.start(), this.afterRender = e;
-  }
-  /**
-   * 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.
-   */
-  async set(e) {
-    let t;
-    e.priority === "high" && (t = await this.mutex.acquire());
-    const s = this.requests.get(e.key);
-    if (s == null) this.requests.set(e.key, e);
-    else {
-      const i = T[e.priority] >= T[s.priority], r = e.canvases.length >= s.canvases.length;
-      i && r && this.requests.set(e.key, e);
-    }
-    t == null || t();
-  }
-  /** Execute the render. */
-  async render() {
-    await this.mutex.runExclusive(async () => {
-      var r;
-      const e = performance.now(), { requests: t } = this;
-      if (t.size === 0) return;
-      await this.runCleanupsSync(), await this.renderSync();
-      const s = performance.now(), i = P.milliseconds(s - e);
-      i.greaterThan(R.period) && console.warn(
-        `Render loop for ${this.requests.size} took longer than ${R.period.toString()} to execute: ${i.milliseconds}`
-      ), this.requests.clear(), (r = this.afterRender) == null || r.call(this);
-    });
-  }
-  async runCleanupsSync() {
-    const { cleanup: e, requests: t } = this;
-    for (const [s, i] of e.entries()) {
-      const r = t.get(s);
-      r != null && (await i(r), e.delete(s));
-    }
-  }
-  async renderSync() {
-    const { requests: e } = this;
-    for (const t of e.values())
-      try {
-        const s = await t.render();
-        s != null && this.cleanup.set(t.key, s);
-      } catch (s) {
-        console.error(s);
-      }
-  }
-  /** Starts the rendering loop. */
-  async start() {
-    do {
-      try {
-        await this.render();
-      } catch (e) {
-        console.error(e);
-      }
-      await this.sleep();
-    } while (!0);
-  }
-  async sleep() {
-    return await new Promise(requestAnimationFrame);
-  }
-}
-const E = (h) => (h.textRendering = "optimizeSpeed", h.imageSmoothingEnabled = !1, h), d = class d {
-  constructor(e, t, s, i) {
-    /* The canvas element used by WebGL. */
-    o(this, "glCanvas");
-    /** The canvas element used by the 2D canvas. */
-    o(this, "upper2dCanvas");
-    /** The canvas element used by the 2D canvas. */
-    o(this, "lower2dCanvas");
-    /** The WebGL rendering context.  */
-    o(this, "gl");
-    /** A 2D canvas that sits below the WebGL canvas. */
-    o(this, "lower2d");
-    /** A 2D canvas that sits above the WebGL canvas. */
-    o(this, "upper2d");
-    /** The region the canvas occupies in pixel space */
-    o(this, "region");
-    /** The device pixel ratio of the canvas */
-    o(this, "dpr");
-    /** queue render transitions onto the stack */
-    o(this, "loop");
-    /** See the @link{clear.Program} for why this is necessary. */
-    o(this, "clearProgram");
-    o(this, "os");
-    this.upper2dCanvas = s, this.lower2dCanvas = t, this.glCanvas = e, this.os = i;
-    const r = this.lower2dCanvas.getContext("2d");
-    if (r == null) throw new Error("Could not get 2D context");
-    this.lower2d = E(
-      new w(r)
-    );
-    const a = this.upper2dCanvas.getContext("2d");
-    if (a == null) throw new Error("Could not get 2D context");
-    this.upper2d = E(
-      new w(a)
-    );
-    const c = {
-      preserveDrawingBuffer: !0,
-      powerPreference: "high-performance",
-      stencil: !1,
-      depth: !1
-    }, l = this.glCanvas.getContext("webgl2", c);
-    if (l == null) throw new Error("Could not get WebGL context");
-    l.disable(l.DEPTH_TEST), l.disable(l.STENCIL_TEST), l.disable(l.CULL_FACE), l.disable(l.DITHER), this.gl = l, this.glCanvas.oncontextlost = console.log;
-    const f = () => {
-      this.gl.flush(), this.gl.finish();
-    };
-    this.loop = new K(f), this.region = n.ZERO, this.dpr = 1, this.os === "Windows" && (this.clearProgram = new Z(this));
-  }
-  static create(e, t, s, i, r) {
-    const a = new d(t, s, i, r);
-    return e.set(d.CONTEXT_KEY, a), a;
-  }
-  static useOptional(e) {
-    return e.getOptional(d.CONTEXT_KEY);
-  }
-  static use(e) {
-    return e.get(d.CONTEXT_KEY);
-  }
-  update(e) {
-    e.set(d.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(e, t) {
-    n.equals(this.region, e) && this.dpr === t || (this.region = e, this.dpr = t, 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(e) * t, n.height(e) * t));
-  }
-  resizeCanvas(e) {
-    e.width = n.width(this.region) * this.dpr, e.height = n.height(this.region) * this.dpr;
-  }
-  /** @returns the aspect ratio of the canvas. */
-  get aspect() {
-    return n.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(e) {
-    return new u.XY(
-      // Accept a value in decimal.
-      u.Scale.scale(0, 1).scale(n.width(e)).translate(n.left(e)).reBound(n.width(this.region)).scale(-1, 1),
-      // Accept a value in decimal.
-      u.Scale.scale(0, 1).scale(n.height(e)).invert().translate(n.top(e)).reBound(n.height(this.region)).scale(-1, 1).invert()
-    );
-  }
-  scissor(e, t = p.ZERO, s) {
-    const i = [];
-    return s.includes("upper2d") && i.push(this.upper2d.scissor(e, t)), s.includes("lower2d") && i.push(this.lower2d.scissor(e, t)), s.includes("gl") && i.push(this.scissorGL(e, t)), () => i.forEach((r) => r());
-  }
-  scissorGL(e, t = p.ZERO) {
-    return this.gl.enable(this.gl.SCISSOR_TEST), e = g(e, t), this.gl.scissor(
-      n.left(e) * this.dpr,
-      (n.height(this.region) - n.bottom(e)) * this.dpr,
-      n.width(e) * this.dpr,
-      n.height(e) * this.dpr
-    ), () => this.gl.disable(this.gl.SCISSOR_TEST);
-  }
-  erase(e, t = p.ZERO, ...s) {
-    t = p.construct(t), s.length === 0 && (s = ["upper2d", "lower2d", "gl"]), s.includes("upper2d") && this.eraseCanvas(this.upper2d, e, t), s.includes("lower2d") && this.eraseCanvas(this.lower2d, e, t), s.includes("gl") && this.eraseGL(e, t);
-  }
-  eraseGL(e, t = p.ZERO) {
-    var r;
-    const { gl: s } = this, i = this.scissorGL(g(e, t));
-    s.clearColor(...G.rgba1), s.clear(s.COLOR_BUFFER_BIT), this.os === "Windows" && ((r = this.clearProgram) == null || r.exec()), i();
-  }
-  eraseCanvas(e, t, s = p.ZERO) {
-    const i = g(t, s);
-    e.clearRect(...p.couple(n.topLeft(i)), ...O.couple(n.dims(i)));
-  }
-};
-o(d, "CONTEXT_KEY", k.B("render-context"));
-let _ = d;
-const U = y.object({
-  region: n.box,
-  enabled: y.boolean().optional().default(!1)
-}), v = ["gl", "lower2d", "upper2d"];
-class x extends B {
-  constructor() {
-    super(...arguments);
-    o(this, "schema", U);
-  }
-  async afterUpdate(t) {
-    this.deleted || (this.internal.renderCtx = _.use(t), await this.renderOnLifecycleChange());
-  }
-  async afterDelete() {
-    await this.renderOnLifecycleChange();
-  }
-  async renderOnLifecycleChange() {
-    await this.internal.renderCtx.loop.set({
-      key: `${this.type}-${this.key}`,
-      render: this.render.bind(this),
-      priority: "high",
-      canvases: v
-    });
-  }
-  async render() {
-    this.deleted || !this.state.enabled || this.internal.renderCtx.erase(this.state.region, p.construct(0), ...v);
-  }
-}
-o(x, "TYPE", "eraser");
-const Q = {
-  [x.TYPE]: x
-};
-export {
-  _ as C,
-  x as E,
-  N as G,
-  K as L,
-  Q as R,
-  U as e
-};