@synnaxlabs/pluto 0.53.1 → 0.54.0

package/dist/aether-DmSenWd4.js

@@ -0,0 +1,704 @@
+import { n as e } from "./chunk-DeC0fbbY.js";
+import { l as t } from "./types-BGbd8pRh.js";
+import { C as n, S as r, g as i, v as a } from "./aether-Bl3vMZO3.js";
+import { n as o } from "./css-UEo6g0SR.js";
+import { UnexpectedError as s } from "@synnaxlabs/client";
+import { box as c, color as l, dimensions as u, scale as d, unique as f, xy as p } from "@synnaxlabs/x";
+import { z as m } from "zod";
+import { alamos as h } from "@synnaxlabs/alamos";
+//#region src/alamos/aether/alamos.ts
+var g = m.object({
+	include: m.string().array().optional(),
+	exclude: m.string().array().optional(),
+	level: m.enum(h.LOG_LEVELS).default("info")
+}), _ = "alamos-provider", v = class extends r {
+	static TYPE = "alamos.Provider";
+	schema = g;
+	afterUpdate(e) {
+		if (e.getOptional(_) != null) return;
+		let t = [], { include: n, exclude: r, level: i } = this.state;
+		(n != null || r != null) && t.push(h.logLevelKeyFiler({
+			include: n,
+			exclude: r
+		})), i != null && t.push(h.logThresholdFilter(i)), t.length === 0 && t.push(() => !1), this.internal.ins = new h.Instrumentation({
+			key: "aether",
+			logger: new h.Logger({ filters: t })
+		}), e.set(_, this.internal.ins);
+	}
+}, y = (e, t) => {
+	let n = e.get(_);
+	if (n == null) throw Error("No instrumentation provider");
+	return t == null ? n : n.child(t);
+}, b = { [v.TYPE]: v }, x = (e, t) => c.construct(c.left(e) - t.x, c.top(e) - t.y, c.width(e) + t.x * 2, c.height(e) + t.y * 2), S = class e {
+	scale_;
+	wrapped;
+	atlasRegistry;
+	cachedFont = null;
+	cachedFillStyle = null;
+	cachedStrokeStyle = null;
+	cachedLineWidth = null;
+	cachedGlobalAlpha = null;
+	cachedTextAlign = null;
+	cachedTextBaseline = null;
+	cachedLineCap = null;
+	cachedLineJoin = null;
+	cachedMiterLimit = null;
+	dpr;
+	constructor(e, t, n, r = d.XY.IDENTITY) {
+		this.wrapped = e, this.scale_ = r, this.atlasRegistry = t, this.dpr = n;
+	}
+	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;
+	}
+	checkAtlasFillStyle(e = !1) {
+		return e && typeof this.fillStyle == "string" ? [!0, this.fillStyle] : (e && 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();
+	}
+	applyScale(t) {
+		return new e(this, this.atlasRegistry, this.dpr, t);
+	}
+	get canvas() {
+		return this.wrapped.canvas;
+	}
+	get miterLimit() {
+		return this.cachedMiterLimit ?? this.wrapped.miterLimit;
+	}
+	set miterLimit(e) {
+		let t = this.scale_.x.dim(e);
+		t !== this.cachedMiterLimit && (this.cachedMiterLimit = t, this.wrapped.miterLimit = t);
+	}
+	get globalAlpha() {
+		return this.cachedGlobalAlpha ?? this.wrapped.globalAlpha;
+	}
+	set globalAlpha(e) {
+		e !== this.cachedGlobalAlpha && (this.cachedGlobalAlpha = e, this.wrapped.globalAlpha = e);
+	}
+	get globalCompositeOperation() {
+		return this.wrapped.globalCompositeOperation;
+	}
+	set globalCompositeOperation(e) {
+		this.wrapped.globalCompositeOperation = e;
+	}
+	get fillStyle() {
+		return this.cachedFillStyle ?? this.wrapped.fillStyle;
+	}
+	set fillStyle(e) {
+		e !== this.cachedFillStyle && (this.cachedFillStyle = e, this.wrapped.fillStyle = e);
+	}
+	get strokeStyle() {
+		return this.cachedStrokeStyle ?? this.wrapped.strokeStyle;
+	}
+	set strokeStyle(e) {
+		e !== this.cachedStrokeStyle && (this.cachedStrokeStyle = e, this.wrapped.strokeStyle = e);
+	}
+	drawImage(e, t, n, r, i, a, o, s, c) {
+		this.wrapped.drawImage(e, t, n, r, i, a == null ? a : this.scale_.x.pos(a), o == null ? o : this.scale_.y.pos(o), s == null ? s : this.scale_.x.dim(s), c == null ? c : this.scale_.y.dim(c));
+	}
+	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, n, r) {
+		return this.wrapped.isPointInPath(e, t, n, r);
+	}
+	isPointInStroke(e, t, n) {
+		return this.wrapped.isPointInStroke(e, t, n);
+	}
+	stroke(e) {
+		if (e == null) return this.wrapped.stroke();
+		this.wrapped.stroke(e);
+	}
+	createConicGradient(e, t, n) {
+		return this.wrapped.createConicGradient(e, t, n);
+	}
+	createLinearGradient(e, t, n, r) {
+		return this.wrapped.createLinearGradient(e, t, n, r);
+	}
+	createPattern(e, t) {
+		return this.wrapped.createPattern(e, t);
+	}
+	createRadialGradient(e, t, n, r, i, a) {
+		return this.wrapped.createRadialGradient(e, t, n, r, i, a);
+	}
+	get filter() {
+		return this.wrapped.filter;
+	}
+	set filter(e) {
+		this.wrapped.filter = e;
+	}
+	createImageData(e, t, n) {
+		return this.wrapped.createImageData(e, t, n);
+	}
+	getImageData(e, t, n, r, i) {
+		return this.wrapped.getImageData(e, t, n, r, i);
+	}
+	putImageData(e, t, n, r, i, a, o) {
+		this.wrapped.putImageData(e, t, n, r, i, a, o);
+	}
+	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, n, r, i, a) {
+		this.wrapped.arc(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), r, i, a);
+	}
+	arcTo(e, t, n, r, i) {
+		this.wrapped.arcTo(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.pos(n), this.scale_.y.pos(r), this.scale_.x.dim(i));
+	}
+	bezierCurveTo(e, t, n, r, i, a) {
+		this.wrapped.bezierCurveTo(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.pos(n), this.scale_.y.pos(r), this.scale_.x.pos(i), this.scale_.y.pos(a));
+	}
+	closePath() {
+		this.wrapped.closePath();
+	}
+	ellipse(e, t, n, r, i, a, o, s) {
+		this.wrapped.ellipse(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r), i, a, o, s);
+	}
+	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, n, r) {
+		this.wrapped.quadraticCurveTo(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.pos(n), this.scale_.y.pos(r));
+	}
+	rect(e, t, n, r) {
+		this.wrapped.rect(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r));
+	}
+	roundRect(e, t, n, r, i) {
+		this.wrapped.roundRect(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r), typeof i == "number" ? this.scale_.x.dim(i) : i);
+	}
+	get lineCap() {
+		return this.cachedLineCap ?? this.wrapped.lineCap;
+	}
+	set lineCap(e) {
+		e !== this.cachedLineCap && (this.cachedLineCap = 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.cachedLineJoin ?? this.wrapped.lineJoin;
+	}
+	set lineJoin(e) {
+		e !== this.cachedLineJoin && (this.cachedLineJoin = e, this.wrapped.lineJoin = e);
+	}
+	get lineWidth() {
+		return this.cachedLineWidth ?? this.wrapped.lineWidth;
+	}
+	set lineWidth(e) {
+		let t = this.scale_.x.dim(e);
+		t !== this.cachedLineWidth && (this.cachedLineWidth = t, this.wrapped.lineWidth = t);
+	}
+	getLineDash() {
+		return this.wrapped.getLineDash();
+	}
+	setLineDash(e) {
+		let t = Array.from(e).map((e) => this.scale_.x.dim(e));
+		this.wrapped.setLineDash(t);
+	}
+	clearRect(e, t, n, r) {
+		this.wrapped.clearRect(e, t, n, r);
+	}
+	fillRect(e, t, n, r) {
+		this.wrapped.fillRect(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r));
+	}
+	strokeRect(e, t, n, r) {
+		this.wrapped.strokeRect(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r));
+	}
+	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.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(e, t, n, r, i = {}) {
+		let [a, o] = this.checkAtlasFillStyle(i.useAtlas);
+		if (a) {
+			this.atlasRegistry.get({
+				font: this.font,
+				textColor: o
+			}).fillText(this, e, t, n);
+			return;
+		}
+		this.wrapped.fillText(e, this.scale_.x.pos(t), this.scale_.y.pos(n), r == null ? void 0 : this.scale_.x.dim(r));
+	}
+	measureText(e) {
+		return this.wrapped.measureText(e);
+	}
+	textDimensions(e, n = {}) {
+		let [r, i] = this.checkAtlasFillStyle(n.useAtlas);
+		return r ? this.atlasRegistry.get({
+			font: this.font,
+			textColor: i
+		}).measureText(e) : t(this.measureText(e));
+	}
+	strokeText(e, t, n, r) {
+		this.wrapped.strokeText(e, this.scale_.x.pos(t), this.scale_.y.pos(n), r == null ? void 0 : this.scale_.x.dim(r));
+	}
+	get direction() {
+		return this.wrapped.direction;
+	}
+	set direction(e) {
+		this.wrapped.direction = e;
+	}
+	get font() {
+		return this.cachedFont == null ? this.wrapped.font : this.cachedFont;
+	}
+	set font(e) {
+		e !== this.cachedFont && (this.cachedFont = e, this.wrapped.font = this.cachedFont);
+	}
+	get fontKerning() {
+		return this.wrapped.fontKerning;
+	}
+	set fontKerning(e) {
+		this.wrapped.fontKerning = e;
+	}
+	get textAlign() {
+		return this.cachedTextAlign ?? this.wrapped.textAlign;
+	}
+	set textAlign(e) {
+		e !== this.cachedTextAlign && (this.cachedTextAlign = e, this.wrapped.textAlign = e);
+	}
+	get textBaseline() {
+		return this.cachedTextBaseline ?? this.wrapped.textBaseline;
+	}
+	set textBaseline(e) {
+		e !== this.cachedTextBaseline && (this.cachedTextBaseline = 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), this.dpr = e;
+	}
+	scissor(e, t = p.ZERO) {
+		let n = new C(this.scale_);
+		return e = x(e, t), n.rect(...p.couple(c.topLeft(e)), ...u.couple(c.dims(e))), this.save(), this.clip(n.getPath()), () => this.restore();
+	}
+	setTransform(e, t, n, r, i, a) {
+		this.wrapped.setTransform(e, t, n, r, i, a);
+	}
+	transform(e, t, n, r, i, a) {
+		this.wrapped.transform(e, t, n, r, i, a);
+	}
+	translate(e, t) {
+		this.wrapped.translate(e, t);
+	}
+}, C = class {
+	scale_;
+	path;
+	constructor(e = d.XY.IDENTITY, t) {
+		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, n, r, i, a) {
+		this.path.arc(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), r, i, a);
+	}
+	arcTo(e, t, n, r, i) {
+		this.path.arcTo(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.pos(n), this.scale_.y.pos(r), this.scale_.x.dim(i));
+	}
+	bezierCurveTo(e, t, n, r, i, a) {
+		this.path.bezierCurveTo(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.pos(n), this.scale_.y.pos(r), this.scale_.x.pos(i), this.scale_.y.pos(a));
+	}
+	closePath() {
+		this.path.closePath();
+	}
+	ellipse(e, t, n, r, i, a, o, s) {
+		this.path.ellipse(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r), i, a, o, s);
+	}
+	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, n, r) {
+		this.path.quadraticCurveTo(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.pos(n), this.scale_.y.pos(r));
+	}
+	rect(e, t, n, r) {
+		this.path.rect(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r));
+	}
+	roundRect(e, t, n, r, i) {
+		let a = this.scaleRadii(i);
+		this.path.roundRect(this.scale_.x.pos(e), this.scale_.y.pos(t), this.scale_.x.dim(n), this.scale_.y.dim(r), a);
+	}
+	scaleRadii(e) {
+		return e == null ? e : typeof e == "number" ? this.scale_.x.dim(e) : Array.isArray(e) ? e.map((e) => this.scaleRadius(e)) : 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)
+		};
+	}
+	getPath() {
+		return this.path;
+	}
+}, w = "precision mediump float;\n\nvoid main(void) {\n    gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);    \n}\n", T = "attribute vec4 a_position;\n\nvoid main(void) {\n  gl_Position = a_position;\n}\n", E = (e) => /* @__PURE__ */ Error(`failed to compile webgl program: ${e}`), D = /* @__PURE__ */ Error("null shader encountered"), O = class {
+	renderCtx;
+	prog;
+	vertShader;
+	fragShader;
+	uniformLocCache = /* @__PURE__ */ new Map();
+	constructor(e, t, n) {
+		this.renderCtx = e;
+		let r = e.gl.createProgram();
+		if (r == null) throw E("failed to create program");
+		this.prog = r, this.vertShader = t, this.fragShader = n, this.compile();
+	}
+	setAsActive() {
+		return this.renderCtx.gl.useProgram(this.prog), () => this.renderCtx.gl.useProgram(null);
+	}
+	uniformXY(e, t) {
+		this.renderCtx.gl.uniform2fv(this.getUniformLoc(e), p.couple(t));
+	}
+	uniformColor(e, t) {
+		this.renderCtx.gl.uniform4fv(this.getUniformLoc(e), l.rgba1(t));
+	}
+	getUniformLoc(e) {
+		let t = this.uniformLocCache.get(e);
+		if (t != null) return t;
+		let n = this.renderCtx.gl.getUniformLocation(this.prog, e);
+		if (n == null) throw Error(`unexpected missing uniform ${e}`);
+		return this.uniformLocCache.set(e, n), n;
+	}
+	compile() {
+		let 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) {
+		let n = this.renderCtx.gl, r = n.createShader(t);
+		if (r == null) throw D;
+		if (n.shaderSource(r, e), n.compileShader(r), !n.getShaderParameter(r, n.COMPILE_STATUS)) {
+			let e = n.getShaderInfoLog(r);
+			throw n.deleteShader(r), E(e ?? "unknown");
+		}
+		n.attachShader(this.prog, r);
+	}
+}, k = new Float32Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+]), A = class extends O {
+	positionBuffer;
+	constructor(e) {
+		super(e, T, w);
+		let t = e.gl.createBuffer();
+		if (t == null) throw new s("webgl: failed to create buffer");
+		this.positionBuffer = t, e.gl.bindBuffer(e.gl.ARRAY_BUFFER, this.positionBuffer), e.gl.bufferData(e.gl.ARRAY_BUFFER, k, e.gl.STATIC_DRAW);
+	}
+	exec() {
+		let { gl: e } = this.renderCtx, t = e.getAttribLocation(this.prog, "a_position");
+		e.bindBuffer(e.ARRAY_BUFFER, this.positionBuffer);
+		let n = e.createVertexArray();
+		e.bindVertexArray(n), e.enableVertexAttribArray(t), e.vertexAttribPointer(t, 2, e.FLOAT, !1, 0, 0), this.setAsActive(), e.drawArrays(e.TRIANGLES, 0, 3);
+	}
+}, j = {
+	high: 1,
+	low: 0
+}, M = class {
+	requests = /* @__PURE__ */ new Map();
+	cleanup = /* @__PURE__ */ new Map();
+	afterRender;
+	instrumentation;
+	handleError;
+	constructor({ afterRender: e, instrumentation: t = h.Instrumentation.NOOP, handleError: n }) {
+		this.afterRender = e, this.instrumentation = t, this.handleError = n, this.start();
+	}
+	set(e) {
+		let t = this.requests.get(e.key);
+		if (t == null) this.requests.set(e.key, e);
+		else {
+			let n = j[e.priority] >= j[t.priority], r = e.canvases.length >= t.canvases.length;
+			n && r && this.requests.set(e.key, e);
+		}
+	}
+	render() {
+		let { requests: e } = this;
+		e.size !== 0 && (this.runCleanupsSync(), this.renderSync(), this.requests.clear(), this.afterRender?.());
+	}
+	runCleanupsSync() {
+		let { cleanup: e, requests: t } = this;
+		e.forEach((n, r) => {
+			let i = t.get(r);
+			i != null && (n(i), e.delete(r));
+		});
+	}
+	renderSync() {
+		let { requests: e } = this;
+		e.forEach((e) => {
+			try {
+				let t = e.render();
+				t != null && this.cleanup.set(e.key, t);
+			} catch (e) {
+				this.handleError(e, "render loop failed");
+			}
+		});
+	}
+	start() {
+		let e = () => {
+			try {
+				this.render();
+			} catch (e) {
+				this.handleError(e, "render loop failed");
+			}
+			requestAnimationFrame(e);
+		};
+		requestAnimationFrame(e);
+	}
+}, N = 2, P = 2, F = class e {
+	atlas;
+	charDims;
+	charMap;
+	static DEFAULT_CHARS = "0123456789.:-°µmsNa∞ᴇABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz%";
+	constructor(n) {
+		let { font: r, characters: i = e.DEFAULT_CHARS, textColor: a } = n;
+		this.charMap = /* @__PURE__ */ new Map();
+		let o = f.unique(Array.from(i)), s = new OffscreenCanvas(1, 1).getContext("2d");
+		s.font = r, this.charDims = t(s.measureText("0")), this.charDims.width += N, this.charDims.height += N;
+		let c = o.length, u = this.charDims.width, d = this.charDims.height, p = Math.ceil(Math.sqrt(c)), m = Math.ceil(c / p);
+		this.atlas = new OffscreenCanvas(u * p * P, d * (m + 1) * P);
+		let h = this.atlas.getContext("2d");
+		h.scale(P, P), h.font = r, h.textBaseline = "alphabetic", h.textAlign = "left", h.fillStyle = l.hex(a), h.clearRect(0, 0, this.atlas.width, this.atlas.height), o.forEach((e, t) => {
+			let n = t % p, r = Math.floor(t / p), i = n * u, a = (r + 1) * d;
+			h.fillText(e, i, a), this.charMap.set(e, t);
+		});
+	}
+	fillText(e, t, n, r) {
+		let { width: i, height: a } = this.charDims, o = Math.ceil(Math.sqrt(this.charMap.size));
+		e.textAlign === "center" && (n -= i * t.length / 2), e.textBaseline === "middle" && (r += a / 2);
+		for (let s = 0; s < t.length; s++) {
+			let c = t[s], l = this.charMap.get(c);
+			if (l === void 0) continue;
+			let u = l % o, d = Math.floor(l / o);
+			e.drawImage(this.atlas, u * i * P, d * a * P + N, i * P, a * P, n + s * i, r - a - N / P, i, a);
+		}
+	}
+	measureText(e) {
+		return {
+			width: e.length * this.charDims.width,
+			height: this.charDims.height
+		};
+	}
+}, I = class {
+	atlases;
+	constructor() {
+		this.atlases = /* @__PURE__ */ new Map();
+	}
+	get(e) {
+		let t = `${e.font}-${l.hex(e.textColor)}-${e.characters}`;
+		if (this.atlases.has(t)) return this.atlases.get(t);
+		let n = new F(e);
+		return this.atlases.set(t, n), n;
+	}
+}, L = (e) => (e.textRendering = "optimizeSpeed", e.imageSmoothingEnabled = !1, e), R = class e {
+	glCanvas;
+	upper2dCanvas;
+	lower2dCanvas;
+	gl;
+	lower2d;
+	upper2d;
+	region;
+	dpr;
+	loop;
+	clearProgram;
+	os;
+	static CONTEXT_KEY = o.B("render-context");
+	instrumentation;
+	static create(t, n, r, o, s) {
+		let c = new e(n, r, o, s, y(t, "render_context"), i(t), a(t));
+		return t.set(e.CONTEXT_KEY, c), c;
+	}
+	constructor(e, t, n, r, i, a, o) {
+		this.upper2dCanvas = n, this.lower2dCanvas = t, this.glCanvas = e, this.os = r, this.instrumentation = i, this.dpr = 1;
+		let s = this.lower2dCanvas.getContext("2d");
+		if (s == null) throw Error("Could not get 2D context");
+		let l = new I();
+		this.lower2d = L(new S(s, l, this.dpr));
+		let u = this.upper2dCanvas.getContext("2d");
+		if (u == null) throw Error("Could not get 2D context");
+		this.upper2d = L(new S(u, l, this.dpr));
+		let d = this.glCanvas.getContext("webgl2", {
+			preserveDrawingBuffer: !0,
+			powerPreference: "high-performance",
+			stencil: !1,
+			depth: !1
+		});
+		if (d == null) throw Error("Could not get WebGL context");
+		d.disable(d.DEPTH_TEST), d.disable(d.STENCIL_TEST), d.disable(d.CULL_FACE), d.disable(d.DITHER), this.gl = d, this.glCanvas.oncontextlost = () => a({
+			variant: "error",
+			message: "WebGL context lost"
+		}), this.loop = new M({
+			afterRender: () => {
+				this.gl.flush(), this.gl.finish();
+			},
+			instrumentation: this.instrumentation,
+			handleError: o
+		}), this.region = c.ZERO, this.os === "Windows" && (this.clearProgram = new A(this));
+	}
+	static useOptional(t) {
+		return t.getOptional(e.CONTEXT_KEY);
+	}
+	static use(t) {
+		return t.get(e.CONTEXT_KEY);
+	}
+	update(t) {
+		t.set(e.CONTEXT_KEY, this);
+	}
+	resize(e, t) {
+		c.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, c.width(e) * t, c.height(e) * t));
+	}
+	resizeCanvas(e) {
+		e.width = c.width(this.region) * this.dpr, e.height = c.height(this.region) * this.dpr;
+	}
+	get aspect() {
+		return c.aspect(this.region);
+	}
+	scaleRegion(e) {
+		return new d.XY(d.Scale.scale(0, 1).scale(c.width(e)).translate(c.left(e)).reBound(c.width(this.region)).scale(-1, 1), d.Scale.scale(0, 1).scale(c.height(e)).invert().translate(c.top(e)).reBound(c.height(this.region)).scale(-1, 1).invert());
+	}
+	scissor(e, t = p.ZERO, n) {
+		let r = [];
+		return n.includes("upper2d") && r.push(this.upper2d.scissor(e, t)), n.includes("lower2d") && r.push(this.lower2d.scissor(e, t)), n.includes("gl") && r.push(this.scissorGL(e, t)), () => r.forEach((e) => e());
+	}
+	scissorGL(e, t = p.ZERO) {
+		return this.gl.enable(this.gl.SCISSOR_TEST), e = x(e, t), this.gl.scissor(c.left(e) * this.dpr, (c.height(this.region) - c.bottom(e)) * this.dpr, c.width(e) * this.dpr, c.height(e) * this.dpr), () => this.gl.disable(this.gl.SCISSOR_TEST);
+	}
+	erase(e, t = p.ZERO, ...n) {
+		t = p.construct(t), n.length === 0 && (n = [
+			"upper2d",
+			"lower2d",
+			"gl"
+		]), n.includes("upper2d") && this.eraseCanvas(this.upper2d, e, t), n.includes("lower2d") && this.eraseCanvas(this.lower2d, e, t), n.includes("gl") && this.eraseGL(e, t);
+	}
+	eraseGL(e, t = p.ZERO) {
+		let { gl: n } = this, r = this.scissorGL(x(e, t));
+		n.clearColor(...l.rgba1(l.ZERO)), n.clear(n.COLOR_BUFFER_BIT), this.os === "Windows" && this.clearProgram?.exec(), r();
+	}
+	eraseCanvas(e, t, n = p.ZERO) {
+		let r = x(t, n);
+		e.clearRect(...p.couple(c.topLeft(r)), ...u.couple(c.dims(r)));
+	}
+}, z = "pluto-vis-renderer", B = (e, t) => {
+	e.set(z, t, !1);
+}, V = (e) => e.get(z), H = (e) => e.getOptional(z), U = (e, t) => V(e)(t), W = /* @__PURE__ */ e({
+	Context: () => R,
+	GLProgram: () => O,
+	Loop: () => M,
+	control: () => B,
+	request: () => U,
+	useOptionalRequestor: () => H,
+	useRequestor: () => V
+}), G = m.object({
+	region: c.box,
+	enabled: m.boolean().default(!1)
+}), K = [
+	"gl",
+	"lower2d",
+	"upper2d"
+], q = class extends n {
+	static TYPE = "eraser";
+	schema = G;
+	afterUpdate(e) {
+		this.deleted || (this.internal.renderCtx = R.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: K
+		});
+	}
+	render() {
+		this.deleted || !this.state.enabled || this.internal.renderCtx.erase(this.state.region, p.construct(0), ...K);
+	}
+}, J = { [q.TYPE]: q };
+//#endregion
+export { B as a, V as c, v as d, b as f, W as i, R as l, y as m, J as n, U as o, g as p, G as r, H as s, q as t, O as u };