@weasel-js/core 1.6.1 → 1.7.1

package/dist/renderer/draw.js

@@ -0,0 +1,1109 @@
+import { createPaintResources as e } from "./paintResources.js";
+import { BATCH_TEXTURE_SLOTS as t, PAINT_MODE_CONIC as n, PAINT_MODE_PLAIN as r, PAINT_MODE_RADIAL as i } from "./shaders/batchFill.js";
+import { resolveColor as a } from "./math/color.js";
+import { mat3 as o } from "./math/mat3.js";
+import { IDENTITY_COLOR_MATRIX as s } from "./state/GroupState.js";
+import { getTexture as c } from "./textures/registerTexture.js";
+import { getPaintKind as l } from "../core/paintKinds.js";
+import { SPRITE_STRIDE as u } from "./DrawCommand.js";
+import { patternTileSpace as d } from "./math/patternSpace.js";
+import { getMesh as f } from "./cache/cache.js";
+import { resolveStrokeWidth as p } from "../features/paths/tessellate/stroke.js";
+import { outlineMesh as m } from "./cache/outlineMeshCache.js";
+import { outlineStrokeMesh as h, quantizeEmWidth as g } from "./cache/outlineStrokeMeshCache.js";
+import { resolveMarkerSize as _ } from "../core/markerInset.js";
+import { quantizeStrokeScale as v, strokeMesh as y } from "./cache/strokeMeshCache.js";
+import { cachedMarkerCommands as b } from "./cache/markerCommandCache.js";
+import { COMPOSITE_PROGRAM_ID as ee } from "./effects/composite.js";
+import { SYNTHETIC_ITALIC_RADIANS as x } from "./syntheticItalic.js";
+import { GLYPH_MODE_MSDF as S, GLYPH_MODE_R8 as te, dynamicPageTextureId as C, ensureFontTexture as ne, glyphFieldScale as re, syncDynamicPageTexture as ie, textureCacheKey as ae } from "@weasel-js/font";
+import { cachedLayoutRuns as oe, resolveTextStyle as se, verticalAlignOffset as ce } from "@weasel-js/text";
+import { tessellate as le } from "@weasel-js/geom/tessellate";
+//#region src/renderer/draw.ts
+function w(e, t, n) {
+	e.gl.drawElements(e.gl.TRIANGLES, t, n, 0), e.stats && e.stats.drawCalls++;
+}
+var ue = /* @__PURE__ */ new WeakMap(), de = /* @__PURE__ */ new WeakMap();
+function T(e, t) {
+	let n = ue.get(e);
+	n || (n = /* @__PURE__ */ new WeakMap(), ue.set(e, n));
+	let r = n.get(t);
+	return r || (r = {}, n.set(t, r)), r;
+}
+function E(e, t) {
+	if (e === void 0 || e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+function fe(e, t, n, r, i, a) {
+	let o = t.uniform("u_color");
+	if (o === void 0) return;
+	let s = T(e, t), c = s.color;
+	(c === void 0 || c[0] !== n || c[1] !== r || c[2] !== i || c[3] !== a) && (e.gl.uniform4f(o, n, r, i, a), s.color = [
+		n,
+		r,
+		i,
+		a
+	]);
+}
+function D(e, t, n) {
+	let r = t.uniform("u_alpha");
+	if (r === void 0) return;
+	let i = T(e, t);
+	i.alpha !== n && (e.gl.uniform1f(r, n), i.alpha = n);
+}
+var O = o.identity();
+function pe(e) {
+	let t = de.get(e);
+	return t || (t = o.screenToClip(e.widthCss, e.heightCss), de.set(e, t)), t;
+}
+var k = /* @__PURE__ */ new Float32Array(16);
+function A(e, t, n = e.state.colorMatrix) {
+	let r = e.gl, i = T(e, t), a = t.uniform("u_colorMatrix");
+	if (a !== void 0) {
+		for (let e = 0; e < 4; e++) for (let t = 0; t < 4; t++) k[t * 4 + e] = n[e * 5 + t];
+		E(i.colorMatrix, k) || (r.uniformMatrix4fv(a, !1, k), i.colorMatrix = Float32Array.from(k));
+	}
+	let o = t.uniform("u_colorBias");
+	if (o !== void 0) {
+		let e = [
+			n[4],
+			n[9],
+			n[14],
+			n[19]
+		];
+		E(i.colorBias, e) || (r.uniform4f(o, e[0], e[1], e[2], e[3]), i.colorBias = Float32Array.from(e));
+	}
+}
+function me(e, t) {
+	return e.flattenTolerance === void 0 ? f(t) : le(t, { flattenTolerance: e.flattenTolerance });
+}
+function he(e, t) {
+	return e.flattenTolerance === void 0 ? e.meshCache.handleFor(t) : e.meshCache.uploadTransient(t);
+}
+function ge(e, t) {
+	return he(e, me(e, t));
+}
+function j(e, t) {
+	switch (t.kind) {
+		case "group": return Oe(e, t);
+		case "path": return ke(e, t);
+		case "text": return bt(e, t);
+		case "image": return Lt(e, t);
+		case "sprites": return Rt(e, t);
+		case "shader": return H(e), we(e, t);
+	}
+}
+var _e = /* @__PURE__ */ new Set();
+function ve(e, t) {
+	let n = `${e}:${t}`;
+	_e.has(n) || (_e.add(n), (typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel drawShader: uniform "${t}" not found in program "${e}". Check spelling, ensure it's used in the shader (unused uniforms are optimized away by the driver).`));
+}
+function ye(e, t, n, r, i) {
+	if (typeof n == "object" && n && !Array.isArray(n) && !(n instanceof Float32Array) && "id" in n && typeof n.id == "string") {
+		let a = n, o = c(a.id);
+		if (!o) {
+			(typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel setUniform: TextureHandle "${a.id}" not registered`);
+			return;
+		}
+		let s = i.value++;
+		r.upload(a.id, o.source), r.bind(a.id, s), e.uniform1i(t, s);
+		return;
+	}
+	if (n instanceof Float32Array) {
+		if (n.length === 9) e.uniformMatrix3fv(t, !1, n);
+		else if (n.length === 16) e.uniformMatrix4fv(t, !1, n);
+		else if (typeof process > "u" || process.env.NODE_ENV !== "production") throw TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${n.length}`);
+		return;
+	}
+	if (Array.isArray(n)) {
+		let r = n;
+		switch (r.length) {
+			case 2:
+				e.uniform2fv(t, r);
+				break;
+			case 3:
+				e.uniform3fv(t, r);
+				break;
+			case 4:
+				e.uniform4fv(t, r);
+				break;
+			default: if (typeof process > "u" || process.env.NODE_ENV !== "production") throw TypeError(`weasel setUniform: array length ${r.length} not supported`);
+		}
+		return;
+	}
+	if (typeof n == "number") {
+		e.uniform1f(t, n);
+		return;
+	}
+}
+var be = {
+	float: {
+		fn: "uniform1fv",
+		n: 1
+	},
+	vec2: {
+		fn: "uniform2fv",
+		n: 2
+	},
+	vec3: {
+		fn: "uniform3fv",
+		n: 3
+	},
+	vec4: {
+		fn: "uniform4fv",
+		n: 4
+	},
+	int: {
+		fn: "uniform1iv",
+		n: 1
+	},
+	ivec2: {
+		fn: "uniform2iv",
+		n: 2
+	},
+	ivec3: {
+		fn: "uniform3iv",
+		n: 3
+	},
+	ivec4: {
+		fn: "uniform4iv",
+		n: 4
+	},
+	bool: {
+		fn: "uniform1iv",
+		n: 1
+	},
+	bvec2: {
+		fn: "uniform2iv",
+		n: 2
+	},
+	bvec3: {
+		fn: "uniform3iv",
+		n: 3
+	},
+	bvec4: {
+		fn: "uniform4iv",
+		n: 4
+	},
+	uint: {
+		fn: "uniform1uiv",
+		n: 1
+	},
+	uvec2: {
+		fn: "uniform2uiv",
+		n: 2
+	},
+	uvec3: {
+		fn: "uniform3uiv",
+		n: 3
+	},
+	uvec4: {
+		fn: "uniform4uiv",
+		n: 4
+	},
+	mat2: {
+		fn: "uniformMatrix2fv",
+		n: 4,
+		matrix: !0
+	},
+	mat3: {
+		fn: "uniformMatrix3fv",
+		n: 9,
+		matrix: !0
+	},
+	mat4: {
+		fn: "uniformMatrix4fv",
+		n: 16,
+		matrix: !0
+	},
+	mat2x2: {
+		fn: "uniformMatrix2fv",
+		n: 4,
+		matrix: !0
+	},
+	mat3x3: {
+		fn: "uniformMatrix3fv",
+		n: 9,
+		matrix: !0
+	},
+	mat4x4: {
+		fn: "uniformMatrix4fv",
+		n: 16,
+		matrix: !0
+	},
+	mat2x3: {
+		fn: "uniformMatrix2x3fv",
+		n: 6,
+		matrix: !0
+	},
+	mat2x4: {
+		fn: "uniformMatrix2x4fv",
+		n: 8,
+		matrix: !0
+	},
+	mat3x2: {
+		fn: "uniformMatrix3x2fv",
+		n: 6,
+		matrix: !0
+	},
+	mat3x4: {
+		fn: "uniformMatrix3x4fv",
+		n: 12,
+		matrix: !0
+	},
+	mat4x2: {
+		fn: "uniformMatrix4x2fv",
+		n: 8,
+		matrix: !0
+	},
+	mat4x3: {
+		fn: "uniformMatrix4x3fv",
+		n: 12,
+		matrix: !0
+	}
+};
+function xe(e) {
+	return Array.isArray(e) || e instanceof Float32Array || e instanceof Int32Array || e instanceof Uint32Array;
+}
+function Se(e, t, n, r) {
+	let i = typeof process < "u" ? process.env.NODE_ENV !== "production" : !0, a = be[n.type];
+	if (!a) {
+		i && console.warn(`weasel setUniform: array uniform "${t}" has type ${n.type}, which cannot be written as a whole`);
+		return;
+	}
+	if (r.length % a.n !== 0 || r.length > a.n * n.size) {
+		if (i) throw TypeError(`weasel setUniform: "${t}" is ${n.type}[${n.size}], so its value must hold a multiple of ${a.n} numbers, at most ${a.n * n.size}; got ${r.length}`);
+		return;
+	}
+	if (r.length === 0) return;
+	let o = e[a.fn];
+	a.matrix ? o.call(e, n.location, !1, r) : o.call(e, n.location, r);
+}
+function Ce(e, t, n, r, i, a) {
+	for (let [o, s] of Object.entries(r)) {
+		let r = t.uniformArray(o);
+		if (r && xe(s)) {
+			Se(e, o, r, s);
+			continue;
+		}
+		let c = t.uniform(o);
+		if (c === void 0) {
+			ve(n, o);
+			continue;
+		}
+		ye(e, c, s, i, a);
+	}
+}
+function we(e, t) {
+	let { gl: n, programRegistry: r, quadVbo: i, quadIbo: a, textureCache: s } = e, c = r.get(t.program.id);
+	if (!c) {
+		console.warn(`weasel drawShader: program "${t.program.id}" not compiled on this renderer. Call renderer.registerProgram(handle) after the module-level registerProgram().`);
+		return;
+	}
+	if (!i || !a) {
+		console.warn("weasel drawShader: quad geometry not initialized");
+		return;
+	}
+	n.useProgram(c.handle);
+	let l = c.attribute("a_position"), u = c.attribute("a_uv");
+	n.bindBuffer(n.ARRAY_BUFFER, i), l !== void 0 && (n.enableVertexAttribArray(l), n.vertexAttribPointer(l, 2, n.FLOAT, !1, 16, 0)), u !== void 0 && (n.enableVertexAttribArray(u), n.vertexAttribPointer(u, 2, n.FLOAT, !1, 16, 8)), n.bindBuffer(n.ELEMENT_ARRAY_BUFFER, a);
+	let d = o.screenToClip(e.widthCss, e.heightCss), f = c.uniform("u_proj");
+	f !== void 0 && n.uniformMatrix3fv(f, !1, d);
+	let p = c.uniform("u_bounds");
+	p !== void 0 && n.uniform4f(p, t.bounds.x, t.bounds.y, t.bounds.w, t.bounds.h);
+	let m = c.uniform("u_view");
+	m !== void 0 && n.uniformMatrix3fv(m, !1, e.state.transform), Ce(n, c, t.program.id, t.uniforms, s, { value: 1 }), Y(e), w(e, 6, e.gl.UNSIGNED_SHORT), l !== void 0 && n.disableVertexAttribArray(l), u !== void 0 && n.disableVertexAttribArray(u), n.bindBuffer(n.ARRAY_BUFFER, null), n.bindBuffer(n.ELEMENT_ARRAY_BUFFER, null);
+}
+function Te(e, t, n, r, i) {
+	let a = e.gl;
+	H(e);
+	let o = e.renderTarget ?? null, s = e.clipDepth, c = a.isEnabled(a.SCISSOR_TEST), l = n.acquire(r, i), u = e.state.pushIsolated({ transform: t.transform });
+	e.clipDepth = 0, a.bindFramebuffer(a.FRAMEBUFFER, l.fbo), e.renderTarget = l, a.viewport(0, 0, r, i), a.disable(a.SCISSOR_TEST), a.stencilMask(255), a.clear(a.COLOR_BUFFER_BIT | a.STENCIL_BUFFER_BIT);
+	for (let n of t.children) j(e, n);
+	H(e), a.disable(a.BLEND);
+	for (let o of t.effects) {
+		let t = e.ensureProgram?.(o.program.id) ?? null;
+		if (!t) {
+			ve(o.program.id, "(program)");
+			continue;
+		}
+		let s = n.acquire(r, i);
+		a.bindFramebuffer(a.FRAMEBUFFER, s.fbo), a.viewport(0, 0, r, i), a.clear(a.COLOR_BUFFER_BIT), De(e, t, l.texture, r, i, o.uniforms, void 0, o.program.id), n.release(l), l = s;
+	}
+	a.enable(a.BLEND), e.state.pop(), e.clipDepth = s, e.renderTarget = o, Ee(e, r, i, c);
+	let d = e.ensureProgram?.(ee) ?? null;
+	d && (Y(e), De(e, d, l.texture, r, i, void 0, {
+		alpha: u.alpha,
+		colorMatrix: u.colorMatrix
+	})), n.release(l);
+}
+function Ee(e, t, n, r) {
+	let i = e.gl, a = e.renderTarget ?? null;
+	i.bindFramebuffer(i.FRAMEBUFFER, a ? a.fbo : null), a ? i.viewport(0, 0, t, n) : (e.restoreTargetRect?.(), r && i.enable(i.SCISSOR_TEST));
+}
+function De(e, t, n, r, i, a, o, s) {
+	let c = e.gl;
+	c.useProgram(t.handle);
+	let l = t.attribute("a_position"), u = t.attribute("a_uv");
+	c.bindBuffer(c.ARRAY_BUFFER, e.quadVbo), c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, e.quadIbo), l !== void 0 && l >= 0 && (c.enableVertexAttribArray(l), c.vertexAttribPointer(l, 2, c.FLOAT, !1, 16, 0)), u !== void 0 && u >= 0 && (c.enableVertexAttribArray(u), c.vertexAttribPointer(u, 2, c.FLOAT, !1, 16, 8)), c.activeTexture(c.TEXTURE0), c.bindTexture(c.TEXTURE_2D, n);
+	let d = t.uniform("u_source");
+	d !== void 0 && c.uniform1i(d, 0);
+	let f = t.uniform("u_resolution");
+	f !== void 0 && c.uniform2f(f, r, i);
+	let p = t.uniform("u_texel");
+	if (p !== void 0 && c.uniform2f(p, 1 / r, 1 / i), o) {
+		let n = t.uniform("u_alpha");
+		n !== void 0 && c.uniform1f(n, o.alpha), A(e, t, o.colorMatrix);
+	}
+	a && Ce(c, t, s ?? "effect", a, e.textureCache, { value: 1 }), w(e, 6, e.gl.UNSIGNED_SHORT), l !== void 0 && l >= 0 && c.disableVertexAttribArray(l), u !== void 0 && u >= 0 && c.disableVertexAttribArray(u), c.bindBuffer(c.ARRAY_BUFFER, null), c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, null);
+}
+function Oe(e, t) {
+	if (t.effects && t.effects.length > 0 && e.effectTargets && e.deviceWidth && e.deviceHeight) {
+		Te(e, t, e.effectTargets, e.deviceWidth, e.deviceHeight);
+		return;
+	}
+	if (e.state.push({
+		transform: t.transform,
+		alpha: t.alpha,
+		colorMatrix: t.colorMatrix
+	}), t.clip) {
+		let n = e.clipDepth + 1;
+		if (n > 7) throw e.state.pop(), Error("weasel: clip nesting depth exceeded (max 7). You can't nest more than 7 levels of clipped containers in a single draw tree. Flatten the hierarchy or compose poses outside the scene graph.");
+		lt(e, t.clip, n), e.clipDepth = n;
+	}
+	for (let n of t.children) j(e, n);
+	t.clip && (ut(e, t.clip, e.clipDepth - 1), --e.clipDepth), e.state.pop();
+}
+function ke(e, t) {
+	t.fill && Ae(e, t), t.stroke?.paint && pt(e, t);
+}
+function Ae(e, t) {
+	let n = t.fill, r = n.fill === void 0 || n.fill === "solid", i = !!(t.vertexColors && t.vertexColors.length > 0), a = n, o = z(e, n, i);
+	if (o === null) return;
+	if (o !== void 0 && t.path.kind === "rect") {
+		o.kind === "ramp" ? Je(e, t.path, o) : Ve(e, t.path, o);
+		return;
+	}
+	let s = me(e, t.path);
+	if (V(e, s, o)) return;
+	let c = he(e, s);
+	r && i ? Xe(e, t, a, c) : c.requiresStencil ? dt(e, n, c) : q(e, n, c);
+}
+var je = new Int32Array(Array.from({ length: t }, (e, t) => t)), M = new Float32Array(2 * t);
+function Me(e) {
+	return e === s || E(s, e);
+}
+function N(e, t, n, r, i = 0) {
+	if (t.clipDepth !== e.clipDepth || t.synthBold !== i || !t.foldsAlpha && t.alpha !== e.state.alpha || n !== void 0 && Ne(t, n, r) < 0) return !1;
+	let a = e.state.colorMatrix;
+	return t.colorMatrix === a || E(t.colorMatrix, a);
+}
+function Ne(e, t, n) {
+	for (let r = 0; r < e.textures.length; r++) {
+		let i = e.textures[r];
+		if (i.kind === "bitmap" && i.image === t) return i.sampling === n ? r + 1 : -1;
+	}
+	return P(e);
+}
+function Pe(e) {
+	for (let t = 0; t < e.textures.length; t++) if (e.textures[t].kind === "ramps") return t + 1;
+	return P(e);
+}
+function Fe(e, t) {
+	for (let n = 0; n < e.textures.length; n++) {
+		let r = e.textures[n];
+		if (r.kind === "atlas" && r.id === t) return n + 1;
+	}
+	return P(e);
+}
+function P(e) {
+	return e.textures.length + 1 < t ? e.textures.length + 1 : -1;
+}
+var Ie = 256;
+function Le(e) {
+	return !e.requiresStencil && e.vertices.length >> 1 <= Ie;
+}
+function F(e, t) {
+	return e.batchState !== void 0 && !N(e, e.batchState) && H(e), e.drawBatch.wouldOverflow(t) && H(e), I(e);
+}
+function I(e) {
+	if (e.batchState === void 0) {
+		let t = e.state.colorMatrix, n = Me(t);
+		e.batchState = {
+			alpha: n ? 1 : e.state.alpha,
+			colorMatrix: t,
+			clipDepth: e.clipDepth,
+			synthBold: 0,
+			foldsAlpha: n,
+			textures: []
+		};
+	}
+	return e.batchState;
+}
+function L(e, t, n) {
+	e.batchState !== void 0 && !N(e, e.batchState, t, n) && H(e), e.drawBatch.wouldOverflow(4) && H(e);
+	let r = I(e), i = Ne(r, t, n);
+	return i > r.textures.length && (r.textures.push({
+		kind: "bitmap",
+		image: t,
+		sampling: n
+	}), i = r.textures.length), {
+		staged: r,
+		slot: i
+	};
+}
+function Re(e, t, n, r) {
+	e.batchState !== void 0 && (!N(e, e.batchState, void 0, void 0, r) || Fe(e.batchState, t) < 0) && H(e), e.drawBatch.wouldOverflow(4) && H(e);
+	let i = I(e);
+	i.synthBold = r;
+	let a = Fe(i, t);
+	return a > i.textures.length && (i.textures.push({
+		kind: "atlas",
+		id: t,
+		fieldScale: n
+	}), a = i.textures.length), {
+		staged: i,
+		slot: a
+	};
+}
+function ze(e, t, n, r) {
+	e.gradRamps.wouldReshape(t, n) && H(e), e.batchState !== void 0 && (!N(e, e.batchState) || Pe(e.batchState) < 0) && H(e), e.drawBatch.wouldOverflow(r) && H(e);
+	let i = I(e), a = Pe(i);
+	return a > i.textures.length && (i.textures.push({ kind: "ramps" }), a = i.textures.length), {
+		staged: i,
+		slot: a,
+		rowV: e.gradRamps.rowV(e.gradRamps.upload(t, n))
+	};
+}
+function R(e, t, n) {
+	return (n ?? 1) * (t.foldsAlpha ? e.state.alpha : 1);
+}
+function Be(e, t, n) {
+	let [r, i, o, s] = a(n.color);
+	return [
+		r,
+		i,
+		o,
+		s * R(e, t, n.opacity)
+	];
+}
+function Ve(e, t, n) {
+	let [r, i, a, o] = Be(e, F(e, 4), n);
+	e.drawBatch.pushRect(t.x, t.y, t.width, t.height, e.state.transform, r, i, a, o);
+}
+function He(e, t, n) {
+	let [r, i, a, o] = Be(e, F(e, t.vertices.length >> 1), n);
+	e.drawBatch.pushMesh(t, e.state.transform, r, i, a, o);
+}
+function z(e, t, a) {
+	if (a) return;
+	let o = t.fill ?? "solid";
+	if (o === "solid") {
+		let e = t;
+		return {
+			kind: "solid",
+			color: e.color,
+			opacity: e.opacity
+		};
+	}
+	if (o !== "linear-gradient" && o !== "radial-gradient" && o !== "conic-gradient") return;
+	let s = t, c = Ue(e, s.units);
+	return c ? s.fill === "linear-gradient" ? B(s, r, We(c, s)) : s.fill === "radial-gradient" ? B(s, i, Ge(c, s)) : B(s, n, Ke(c, s)) : null;
+}
+function B(e, t, n) {
+	return {
+		kind: "ramp",
+		stops: e.stops,
+		space: e.interpolate ?? "rgb",
+		opacity: e.opacity,
+		mode: t,
+		uv: n
+	};
+}
+function Ue(e, t) {
+	let n = J(e, t);
+	return n && o.multiply(n, e.state.transform);
+}
+function We(e, t) {
+	let n = t.to.x - t.from.x, r = t.to.y - t.from.y, i = Math.hypot(n, r) || 1, a = 1 / (i * i);
+	return {
+		ux: (e[0] * n + e[1] * r) * a,
+		uy: (e[3] * n + e[4] * r) * a,
+		u0: ((e[6] - t.from.x) * n + (e[7] - t.from.y) * r) * a,
+		vx: 0,
+		vy: 0,
+		v0: 0
+	};
+}
+function Ge(e, t) {
+	let n = 1 / Math.max(t.radius, 1e-4);
+	return {
+		ux: e[0] * n,
+		uy: e[3] * n,
+		u0: (e[6] - t.center.x) * n,
+		vx: e[1] * n,
+		vy: e[4] * n,
+		v0: (e[7] - t.center.y) * n
+	};
+}
+function Ke(e, t) {
+	let n = Math.cos(t.angle), r = Math.sin(t.angle), i = e[6] - t.center.x, a = e[7] - t.center.y;
+	return {
+		ux: n * e[0] + r * e[1],
+		uy: n * e[3] + r * e[4],
+		u0: n * i + r * a,
+		vx: n * e[1] - r * e[0],
+		vy: n * e[4] - r * e[3],
+		v0: n * a - r * i
+	};
+}
+function qe(e, t) {
+	return e.mode === r ? {
+		uv: {
+			...e.uv,
+			v0: t
+		},
+		post: 1
+	} : {
+		uv: e.uv,
+		post: t
+	};
+}
+function Je(e, t, n) {
+	let { staged: r, slot: i, rowV: a } = ze(e, n.stops, n.space, 4), { uv: o, post: s } = qe(n, a);
+	e.drawBatch.pushGradientRect(t.x, t.y, t.width, t.height, e.state.transform, o, s, i, n.mode, 1, 1, 1, R(e, r, n.opacity));
+}
+function Ye(e, t, n) {
+	let { staged: r, slot: i, rowV: a } = ze(e, n.stops, n.space, t.vertices.length >> 1), { uv: o, post: s } = qe(n, a);
+	e.drawBatch.pushGradientMesh(t, e.state.transform, o, s, i, n.mode, 1, 1, 1, R(e, r, n.opacity));
+}
+function V(e, t, n) {
+	return n !== void 0 && Le(t) ? (n.kind === "ramp" ? Ye(e, t, n) : He(e, t, n), !0) : (H(e), !1);
+}
+function H(e) {
+	let t = e.drawBatch, n = e.batchState;
+	if (t.length === 0 || n === void 0) return;
+	let r = e.gl, i = e.batchFill;
+	r.useProgram(i.handle);
+	let a = t.uploadAndBind();
+	W(e, i, O), fe(e, i, 1, 1, 1, 1), D(e, i, n.alpha), r.uniform1f(i.uniform("u_synthBold"), n.synthBold), A(e, i, n.colorMatrix), r.activeTexture(r.TEXTURE0), r.bindTexture(r.TEXTURE_2D, e.whiteTexture);
+	for (let t = 0; t < n.textures.length; t++) {
+		let i = n.textures[t];
+		if (i.kind === "atlas") {
+			e.textureCache.bind(i.id, t + 1), M[2 * (t + 1)] = i.fieldScale[0], M[2 * (t + 1) + 1] = i.fieldScale[1];
+			continue;
+		}
+		if (i.kind === "ramps") {
+			e.gradRamps.bind(t + 1);
+			continue;
+		}
+		e.imageCache.bind(i.image, t + 1), e.imageCache.setMagFilter(i.image, i.sampling === "nearest" ? r.NEAREST : r.LINEAR);
+	}
+	r.uniform1iv(i.uniform("u_samplers"), je), r.uniform2fv(i.uniform("u_fieldScale"), M), Y(e, n.clipDepth), w(e, a, e.gl.UNSIGNED_INT), r.activeTexture(r.TEXTURE0), r.bindVertexArray(null), t.reset(), e.batchState = void 0;
+}
+function U(e, t) {
+	let n = t.anchorA, r = t.anchorB, i = t.anchorT;
+	if (!n || !r || !i) return new Float32Array(e);
+	let a = n.length, o = new Float32Array(a * 4);
+	for (let t = 0; t < a; t++) {
+		let a = n[t] * 4, s = r[t] * 4, c = i[t];
+		o[t * 4 + 0] = e[a + 0] + (e[s + 0] - e[a + 0]) * c, o[t * 4 + 1] = e[a + 1] + (e[s + 1] - e[a + 1]) * c, o[t * 4 + 2] = e[a + 2] + (e[s + 2] - e[a + 2]) * c, o[t * 4 + 3] = e[a + 3] + (e[s + 3] - e[a + 3]) * c;
+	}
+	return o;
+}
+function Xe(e, t, n, r) {
+	let i = e.gl, a = e.pathFillVColor;
+	i.useProgram(a.handle), i.bindVertexArray(r.vao), W(e, a), G(e, a, n.color, n.opacity), A(e, a);
+	let o = U(t.vertexColors, r), s = i.createBuffer();
+	if (!s) throw Error("drawPathFillVColor: createBuffer (color VBO) returned null");
+	i.bindBuffer(i.ARRAY_BUFFER, s), i.bufferData(i.ARRAY_BUFFER, o, i.DYNAMIC_DRAW);
+	let c = a.attribute("a_vertexColor");
+	c !== void 0 && (i.enableVertexAttribArray(c), i.vertexAttribPointer(c, 4, i.FLOAT, !1, 0, 0)), Y(e), w(e, r.indexCount, e.gl.UNSIGNED_INT), i.bindVertexArray(null), i.deleteBuffer(s);
+}
+function W(e, t, n = e.state.transform, r = pe(e)) {
+	let i = e.gl, a = T(e, t);
+	E(a.proj, r) || (i.uniformMatrix3fv(t.uniform("u_proj"), !1, r), a.proj = Float32Array.from(r)), E(a.model, n) || (i.uniformMatrix3fv(t.uniform("u_model"), !1, n), a.model = Float32Array.from(n));
+}
+function G(e, t, n, r) {
+	let [i, o, s, c] = a(n);
+	fe(e, t, i, o, s, c * (r ?? 1)), D(e, t, e.state.alpha);
+}
+function K(e, t) {
+	let n = t.fill ?? "solid";
+	if (n === "solid") return tt(e, t);
+	if (n === "pattern") return nt(e, t);
+	if (n === "linear-gradient" || n === "radial-gradient" || n === "conic-gradient") return ot(e, t);
+	let r = l(n)?.bind;
+	return r ? r(Ze(e), t) : null;
+}
+function Ze(e) {
+	let t = Qe.get(e);
+	if (t) return t;
+	let n = {
+		gl: e.gl,
+		get alpha() {
+			return e.state.alpha;
+		},
+		program: (t) => e.ensureProgram?.(t) ?? e.programRegistry.get(t) ?? null,
+		setProjAndModel: (t) => W(e, t),
+		spaceInverse: (t) => J(e, t),
+		spaceToDevice: (t) => at(e, t),
+		get maxTextureSize() {
+			return e.imageCache.maxTextureSide;
+		},
+		resources: e.paintResources ?? et(e.gl),
+		bindRamp: (t, n, r) => {
+			let i = e.gradRamps.upload(t, r);
+			return e.gradRamps.bind(n), e.gradRamps.rowV(i);
+		}
+	};
+	return Qe.set(e, n), n;
+}
+var Qe = /* @__PURE__ */ new WeakMap(), $e = /* @__PURE__ */ new WeakMap();
+function et(t) {
+	let n = $e.get(t);
+	return n || (n = e(), $e.set(t, n)), n;
+}
+function q(e, t, n) {
+	if (!K(e, t)) return;
+	let r = e.gl;
+	r.bindVertexArray(n.vao), Y(e), w(e, n.indexCount, e.gl.UNSIGNED_INT), r.bindVertexArray(null);
+}
+function tt(e, t) {
+	let n = e.pathFill;
+	return e.gl.useProgram(n.handle), W(e, n), G(e, n, t.color, t.opacity), A(e, n), n;
+}
+function nt(e, t) {
+	return rt(e, e.patternFill, t, e.state.transform);
+}
+function rt(e, t, n, r) {
+	let i = n.pattern, a = c(i.id);
+	if (!a) return (typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel: pattern TextureHandle "${i.id}" not registered`), null;
+	let o = J(e, n.units);
+	if (!o) return null;
+	let s = d(o, n.origin ?? {
+		x: 0,
+		y: 0
+	}, n.transform);
+	if (!s) return null;
+	e.textureCache.upload(i.id, a.source, "repeat");
+	let l = e.gl;
+	l.useProgram(t.handle), W(e, t, r), A(e, t), l.uniformMatrix3fv(t.uniform("u_worldInv"), !1, s);
+	let [u, f] = it(a.source);
+	return l.uniform2f(t.uniform("u_tileSize"), u, f), e.textureCache.bind(i.id, 0), l.uniform1i(t.uniform("u_sampler"), 0), l.uniform1f(t.uniform("u_opacity"), n.opacity ?? 1), D(e, t, e.state.alpha), t;
+}
+function it(e) {
+	let t = "naturalWidth" in e ? e.naturalWidth : e.width, n = "naturalHeight" in e ? e.naturalHeight : e.height;
+	return [t || 1, n || 1];
+}
+function J(e, t) {
+	return t === "local" ? o.invert(e.state.transform) : t === "world" && e.viewMatrix ? o.invert(e.viewMatrix) : o.identity();
+}
+function at(e, t) {
+	let n = J(e, t), r = n && o.invert(n);
+	if (!r) return null;
+	let i = e.deviceWidth && e.widthCss > 0 ? e.deviceWidth / e.widthCss : 1;
+	return o.multiply(o.scaled(o.identity(), i, i), r);
+}
+function ot(e, t) {
+	return st(e, e.gradFill, t, e.state.transform);
+}
+function st(e, t, n, r) {
+	let i = J(e, n.units);
+	if (!i) return null;
+	let a = e.gl, o = e.gradRamps.upload(n.stops, n.interpolate ?? "rgb");
+	if (a.useProgram(t.handle), W(e, t, r), a.uniformMatrix3fv(t.uniform("u_worldInv"), !1, i), A(e, t), e.gradRamps.bind(0), a.uniform1i(t.uniform("u_ramp"), 0), a.uniform1f(t.uniform("u_rampV"), e.gradRamps.rowV(o)), D(e, t, e.state.alpha), a.uniform1f(t.uniform("u_opacity"), n.opacity ?? 1), n.fill === "linear-gradient") {
+		a.uniform1i(t.uniform("u_gradKind"), 0);
+		let e = n.to.x - n.from.x, r = n.to.y - n.from.y, i = Math.hypot(e, r) || 1;
+		a.uniform2f(t.uniform("u_gradP0"), n.from.x, n.from.y), a.uniform2f(t.uniform("u_gradDir"), e / i, r / i), a.uniform1f(t.uniform("u_gradLen"), i), a.uniform1f(t.uniform("u_gradRadius"), 0), a.uniform1f(t.uniform("u_gradAngle"), 0);
+	} else n.fill === "radial-gradient" ? (a.uniform1i(t.uniform("u_gradKind"), 1), a.uniform2f(t.uniform("u_gradP0"), n.center.x, n.center.y), a.uniform2f(t.uniform("u_gradDir"), 0, 0), a.uniform1f(t.uniform("u_gradLen"), 0), a.uniform1f(t.uniform("u_gradRadius"), n.radius), a.uniform1f(t.uniform("u_gradAngle"), 0)) : (a.uniform1i(t.uniform("u_gradKind"), 2), a.uniform2f(t.uniform("u_gradP0"), n.center.x, n.center.y), a.uniform2f(t.uniform("u_gradDir"), 0, 0), a.uniform1f(t.uniform("u_gradLen"), 0), a.uniform1f(t.uniform("u_gradRadius"), 0), a.uniform1f(t.uniform("u_gradAngle"), n.angle));
+	return t;
+}
+function Y(e, t = e.clipDepth) {
+	let n = e.gl;
+	if (t === 0) {
+		n.disable(n.STENCIL_TEST);
+		return;
+	}
+	let r = X(t);
+	n.enable(n.STENCIL_TEST), n.stencilFunc(n.EQUAL, r, r), n.stencilOp(n.KEEP, n.KEEP, n.KEEP);
+}
+function X(e) {
+	return e === 0 ? 0 : (1 << e + 1) - 1 & 254;
+}
+function ct(e, t) {
+	let n = e.gl, r = ge(e, t);
+	n.useProgram(e.pathFill.handle), n.bindVertexArray(r.vao), W(e, e.pathFill), w(e, r.indexCount, e.gl.UNSIGNED_INT), n.bindVertexArray(null);
+}
+function lt(e, t, n) {
+	H(e);
+	let r = e.gl, i = X(n - 1), a = 1 << n, o = i | a;
+	r.enable(r.STENCIL_TEST), r.colorMask(!1, !1, !1, !1), r.stencilMask(a), r.stencilFunc(r.EQUAL, o, i), r.stencilOp(r.KEEP, r.KEEP, r.REPLACE), ct(e, t), r.colorMask(!0, !0, !0, !0), r.stencilMask(255);
+}
+function ut(e, t, n) {
+	H(e);
+	let r = e.gl;
+	r.enable(r.STENCIL_TEST);
+	let i = 1 << n + 1, a = X(n) | i;
+	r.colorMask(!1, !1, !1, !1), r.stencilMask(i), r.stencilFunc(r.EQUAL, a, a), r.stencilOp(r.KEEP, r.KEEP, r.ZERO), ct(e, t), r.colorMask(!0, !0, !0, !0), r.stencilMask(255);
+}
+function dt(e, t, n) {
+	let r = e.gl;
+	r.useProgram(e.pathFill.handle), r.bindVertexArray(n.vao), W(e, e.pathFill), r.enable(r.STENCIL_TEST), r.colorMask(!1, !1, !1, !1), r.stencilMask(1), r.stencilFunc(r.ALWAYS, 0, 1), r.stencilOp(r.KEEP, r.KEEP, r.INVERT), w(e, n.indexCount, e.gl.UNSIGNED_INT);
+	let i = X(e.clipDepth);
+	r.colorMask(!0, !0, !0, !0), r.stencilFunc(r.EQUAL, i | 1, i | 1), r.stencilOp(r.KEEP, r.KEEP, r.KEEP), K(e, t) && w(e, n.indexCount, e.gl.UNSIGNED_INT), r.stencilMask(1), r.clear(r.STENCIL_BUFFER_BIT), r.disable(r.STENCIL_TEST), r.bindVertexArray(null);
+}
+function ft(e, t) {
+	let n = t.stroke, { markerStart: r, markerMid: i, markerEnd: a } = n;
+	if (typeof n.width != "object" && !Z(r) && !Z(i) && !Z(a)) return t;
+	let s = o.meanScaleOf(e.state.transform), c = { ...n };
+	return typeof n.width == "object" && (c.width = p(n.width, v(n.width.px, s))), Z(r) && (c.markerStart = Q(r, s)), Z(i) && (c.markerMid = Q(i, s)), Z(a) && (c.markerEnd = Q(a, s)), {
+		...t,
+		stroke: c
+	};
+}
+function Z(e) {
+	return typeof e == "object" && typeof e.size == "object";
+}
+function Q(e, t) {
+	return {
+		...e,
+		size: _(e, 0, v(e.size.px, t))
+	};
+}
+function pt(e, t) {
+	let n = ft(e, t), r = n.stroke, i = r.align ?? "center";
+	n.path.kind === "polygon" && i !== "center" ? (H(e), _t(e, n, i)) : mt(e, n);
+	let a = p(r.width ?? 1, 1);
+	for (let i of b(n.path, t.stroke, r, a, e.flattenTolerance)) ke(e, i);
+}
+function mt(e, t) {
+	let n = t.stroke, r = n.paint, i = r.fill === void 0 || r.fill === "solid", a = r, o = y(t.path, n, e.flattenTolerance);
+	if (o.indices.length === 0) return;
+	let s = !!(n.vertexColors && n.vertexColors.length > 0), c = z(e, r, s);
+	if (c === null || V(e, o, c)) return;
+	let l = s ? e.meshCache.uploadTransient(o) : e.meshCache.uploadRecurring(o);
+	if (!i && !s) {
+		q(e, r, l);
+		return;
+	}
+	let u = e.gl;
+	if (s) {
+		let t = e.pathFillVColor;
+		u.useProgram(t.handle), u.bindVertexArray(l.vao), W(e, t), G(e, t, i ? a.color : "#ffffff", r.opacity), A(e, t);
+		let o = U(n.vertexColors, l), s = u.createBuffer();
+		if (!s) throw Error("drawPathStrokeUnclipped: createBuffer (color VBO) returned null");
+		u.bindBuffer(u.ARRAY_BUFFER, s), u.bufferData(u.ARRAY_BUFFER, o, u.DYNAMIC_DRAW);
+		let c = t.attribute("a_vertexColor");
+		c !== void 0 && (u.enableVertexAttribArray(c), u.vertexAttribPointer(c, 4, u.FLOAT, !1, 0, 0)), Y(e), w(e, l.indexCount, e.gl.UNSIGNED_INT), u.bindVertexArray(null), u.deleteBuffer(s);
+		return;
+	}
+	u.useProgram(e.pathFill.handle), u.bindVertexArray(l.vao), W(e, e.pathFill), G(e, e.pathFill, a.color, a.opacity), A(e, e.pathFill), Y(e), w(e, l.indexCount, e.gl.UNSIGNED_INT), u.bindVertexArray(null);
+}
+var ht = /* @__PURE__ */ new WeakMap();
+function gt(e) {
+	let t = ht.get(e);
+	return t === void 0 && (t = e.map((e) => e * 2), ht.set(e, t)), t;
+}
+function _t(e, t, n) {
+	let r = t.stroke, i = r.paint, a = i.fill === void 0 || i.fill === "solid", o = i, s = {
+		...r,
+		width: p(r.width ?? 1, 1) * 2,
+		...r.vertexWidths ? { vertexWidths: gt(r.vertexWidths) } : {},
+		align: "center"
+	}, c = !!(r.vertexColors && r.vertexColors.length > 0), l = ge(e, t.path), u = y(t.path, s, e.flattenTolerance);
+	if (u.indices.length === 0) return;
+	let d = c ? e.meshCache.uploadTransient(u) : e.meshCache.uploadRecurring(u), f = e.gl, m = c ? e.pathFillVColor : e.pathFill;
+	f.useProgram(m.handle), W(e, m), f.enable(f.STENCIL_TEST), f.colorMask(!1, !1, !1, !1), f.stencilMask(1), f.stencilFunc(f.ALWAYS, 1, 1), f.stencilOp(f.KEEP, f.KEEP, f.REPLACE), f.bindVertexArray(l.vao), w(e, l.indexCount, e.gl.UNSIGNED_INT);
+	let h = X(e.clipDepth);
+	f.colorMask(!0, !0, !0, !0), n === "inner" ? f.stencilFunc(f.EQUAL, h | 1, h | 1) : f.stencilFunc(f.EQUAL, h, h | 1), f.stencilOp(f.KEEP, f.KEEP, f.KEEP);
+	let g = m;
+	if (c ? (G(e, m, a ? o.color : "#ffffff", i.opacity), A(e, m)) : g = K(e, i), !g) {
+		f.stencilMask(1), f.clear(f.STENCIL_BUFFER_BIT), f.disable(f.STENCIL_TEST), f.bindVertexArray(null);
+		return;
+	}
+	f.bindVertexArray(d.vao);
+	let _ = null;
+	if (c) {
+		let e = U(r.vertexColors, d);
+		if (_ = f.createBuffer(), !_) throw Error("drawPathStrokeStenciled: createBuffer (color VBO) returned null");
+		f.bindBuffer(f.ARRAY_BUFFER, _), f.bufferData(f.ARRAY_BUFFER, e, f.DYNAMIC_DRAW);
+		let t = g.attribute("a_vertexColor");
+		t !== void 0 && (f.enableVertexAttribArray(t), f.vertexAttribPointer(t, 4, f.FLOAT, !1, 0, 0));
+	}
+	w(e, d.indexCount, e.gl.UNSIGNED_INT), f.stencilMask(1), f.clear(f.STENCIL_BUFFER_BIT), f.disable(f.STENCIL_TEST), f.bindVertexArray(null), _ && f.deleteBuffer(_);
+}
+var vt = 48;
+function yt(e) {
+	let t = Math.hypot(e[0], e[1]), n = Math.hypot(e[3], e[4]);
+	return Math.sqrt(t * n) || 1;
+}
+function bt(e, t) {
+	let n = se(t.style), r = n.lineHeight, i = t.align ?? n.align, a = t.maxWidth ?? Infinity, o = e.textOutlineMinScreenSize ?? vt, s = Number.isFinite(o) ? o / yt(e.state.transform) : void 0, c = oe(t.runs, {
+		maxWidth: a,
+		alignWidth: t.width,
+		lineHeight: r,
+		align: i,
+		justify: t.justify,
+		outlineMinSize: s
+	});
+	if (c.groups.length === 0 && c.decorations.length === 0) return;
+	let l = t.x, u = t.y + ce(t.verticalAlign, t.height, c.bounds.height);
+	for (let t of c.groups) t.source === "outline" ? xt(e, t, l, u) : kt(e, t, l, u);
+	Et(e, c.decorations, l, u);
+}
+function xt(e, t, n, r) {
+	let i = t.fill;
+	if (i !== null) {
+		let a = Ct(t, n, r);
+		a && St(e, i, a);
+	}
+	let a = t.stroke?.paint;
+	if (!a) return;
+	let s = wt(t, n, r, o.meanScaleOf(e.state.transform));
+	s && St(e, a, s);
+}
+function St(e, t, n) {
+	let r = z(e, t, !1);
+	r !== null && (V(e, n, r) || q(e, t, e.meshCache.uploadTransient(n)));
+}
+function Ct(e, t, n) {
+	return Tt(e, t, n, (e) => m(e.key, e.d));
+}
+function wt(e, t, n, r) {
+	let i = e.stroke;
+	if (!i) return null;
+	let a = p(i.width ?? 1, r);
+	return a > 0 ? Tt(e, t, n, (e) => e.scale > 0 ? h(e.key, e.d, g(a / e.scale), i) : null) : null;
+}
+function Tt(e, t, n, r) {
+	let i = [], a = 0, o = 0;
+	for (let t of e.glyphs) {
+		let e = r(t);
+		e && e.indices.length !== 0 && (i.push({
+			mesh: e,
+			glyph: t
+		}), a += e.vertices.length, o += e.indices.length);
+	}
+	if (i.length === 0) return null;
+	let s = e.synthetic.italic ? Math.tan(x) : 0, c = new Float32Array(a), l = new Uint32Array(o), u = 0, d = 0, f = 0;
+	for (let { mesh: e, glyph: r } of i) {
+		let { x: i, baselineY: a, scale: o } = r;
+		for (let r = 0; r < e.vertices.length; r += 2) {
+			let l = e.vertices[r], d = e.vertices[r + 1];
+			c[u++] = i + t + (l - d * s) * o, c[u++] = a + n + d * o;
+		}
+		for (let t = 0; t < e.indices.length; t++) l[d++] = f + e.indices[t];
+		f += e.vertices.length / 2;
+	}
+	return {
+		vertices: c,
+		indices: l
+	};
+}
+function Et(e, t, n, r) {
+	for (let i of t) {
+		if (At(i.fill) !== null) {
+			St(e, i.fill, Dt(i.x0 + n, i.y0 + r, i.x1 + n, i.y1 + r));
+			continue;
+		}
+		let [t, o, s, c] = "color" in i.fill ? a(i.fill.color) : [
+			0,
+			0,
+			0,
+			1
+		], l = F(e, 4);
+		e.drawBatch.pushRect(i.x0 + n, i.y0 + r, i.x1 - i.x0, i.y1 - i.y0, e.state.transform, t, o, s, c * (l.foldsAlpha ? e.state.alpha : 1));
+	}
+}
+function Dt(e, t, n, r) {
+	return {
+		vertices: new Float32Array([
+			e,
+			t,
+			n,
+			t,
+			n,
+			r,
+			e,
+			r
+		]),
+		indices: new Uint32Array([
+			0,
+			1,
+			2,
+			0,
+			2,
+			3
+		])
+	};
+}
+var Ot = .08;
+function kt(e, t, n, r) {
+	if (t.source === "canvas") {
+		if (!ie(e.textureCache, t.page)) return;
+	} else if (!ne(t.family, t.weight, t.style, e.textureCache)) return;
+	if (t.quads.length === 0) return;
+	let i = t.source === "canvas" ? C(t.page) : ae(t.family, t.weight, t.style), o = t.source === "canvas" ? te : S, s = re(t.source === "canvas" ? "canvas" : "atlas", t.family, t.weight, t.style);
+	if (!s) return;
+	let c = t.synthetic.bold ? Ot : 0, l = t.synthetic.italic ? Math.tan(x) : 0, u = At(t.fill);
+	if (u !== null) {
+		jt(e, t, n, r, u, i, o, c, l, s);
+		return;
+	}
+	let d = t.fill !== null && "color" in t.fill ? a(t.fill.color) : [
+		0,
+		0,
+		0,
+		1
+	], f = e.drawBatch, p = e.state.transform, { staged: m, slot: h } = Re(e, i, s, c), g = d[3] * (m.foldsAlpha ? e.state.alpha : 1);
+	for (let a of t.quads) f.wouldOverflow(4) && (H(e), {staged: m, slot: h} = Re(e, i, s, c), g = d[3] * (m.foldsAlpha ? e.state.alpha : 1)), f.pushGlyph(a.x0 + n, a.y0 + r, a.x1 + n, a.y1 + r, a.baselineY + r, l, p, a.u0, a.v0, a.u1, a.v1, d[0], d[1], d[2], g, h, o);
+}
+function At(e) {
+	let t = e?.fill ?? "solid";
+	return t === "pattern" ? "pattern" : t === "linear-gradient" || t === "radial-gradient" || t === "conic-gradient" ? "gradient" : t === "solid" ? null : "texture";
+}
+var $ = 1;
+function jt(e, t, n, r, i, a, o, s, c, l) {
+	let u = e.glyphPaintProgram?.(i);
+	if (!u) return;
+	H(e);
+	let d = t.fill, f = e.state.transform, p;
+	if (i === "pattern") p = rt(e, u, d, O);
+	else if (i === "gradient") p = st(e, u, d, O);
+	else {
+		let i = Ft(e, d, Nt(t, n, r, c, f));
+		p = i && It(e, u, i);
+	}
+	if (!p) return;
+	let m = e.gl;
+	e.textureCache.bind(a, $), m.uniform1i(u.uniform("u_atlas"), $), m.uniform1f(u.uniform("u_synthBold"), s), m.uniform2f(u.uniform("u_fieldScale"), l[0], l[1]), Y(e);
+	let h = e.drawBatch;
+	for (let i of t.quads) h.wouldOverflow(4) && Mt(e), h.pushGlyph(i.x0 + n, i.y0 + r, i.x1 + n, i.y1 + r, i.baselineY + r, c, f, i.u0, i.v0, i.u1, i.v1, 1, 1, 1, 1, $, o);
+	Mt(e), m.activeTexture(m.TEXTURE0), m.bindVertexArray(null);
+}
+function Mt(e) {
+	let t = e.drawBatch;
+	t.length !== 0 && (w(e, t.uploadAndBind(), e.gl.UNSIGNED_INT), t.reset());
+}
+function Nt(e, t, n, r, i) {
+	let a = {
+		x0: Infinity,
+		y0: Infinity,
+		x1: -Infinity,
+		y1: -Infinity
+	}, o = (e, t) => {
+		let n = i[0] * e + i[3] * t + i[6], r = i[1] * e + i[4] * t + i[7];
+		n < a.x0 && (a.x0 = n), n > a.x1 && (a.x1 = n), r < a.y0 && (a.y0 = r), r > a.y1 && (a.y1 = r);
+	};
+	for (let i of e.quads) {
+		let e = i.x0 + t, a = i.x1 + t, s = i.y0 + n, c = i.y1 + n, l = i.baselineY + n, u = (l - s) * r, d = (l - c) * r;
+		o(e + u, s), o(a + u, s), o(a + d, c), o(e + d, c);
+	}
+	return a;
+}
+var Pt = {
+	vertices: new Float32Array([
+		0,
+		0,
+		1,
+		0,
+		1,
+		1,
+		0,
+		1
+	]),
+	indices: new Uint32Array([
+		0,
+		1,
+		2,
+		0,
+		2,
+		3
+	])
+};
+function Ft(e, t, n) {
+	let r = e.paintScratch, i = l(t.fill)?.bind;
+	if (!r || !i) return null;
+	let a = e.deviceWidth && e.widthCss > 0 ? e.deviceWidth / e.widthCss : 1, o = e.deviceWidth ?? Math.round(e.widthCss), s = e.deviceHeight ?? Math.round(e.heightCss), c = Math.max(0, Math.floor(n.x0 * a)), u = Math.max(0, Math.floor(n.y0 * a)), d = e.imageCache.maxTextureSide, f = Math.min(d, Math.min(o, Math.ceil(n.x1 * a)) - c), p = Math.min(d, Math.min(s, Math.ceil(n.y1 * a)) - u);
+	if (!(f > 0 && p > 0)) return null;
+	let m = c / a, h = u / a, g = f / a, _ = p / a, v = new Float32Array([
+		g,
+		0,
+		0,
+		0,
+		_,
+		0,
+		m,
+		h,
+		1
+	]), y = new Float32Array([
+		2 / g,
+		0,
+		0,
+		0,
+		2 / _,
+		0,
+		-1 - 2 * m / g,
+		-1 - 2 * h / _,
+		1
+	]), b = Ze(e), ee = {
+		...b,
+		alpha: e.state.alpha,
+		maxTextureSize: b.maxTextureSize,
+		setProjAndModel: (t) => W(e, t, v, y)
+	}, x = e.gl, S = r.acquire(f, p), te = x.isEnabled(x.SCISSOR_TEST);
+	x.activeTexture(x.TEXTURE0), x.bindTexture(x.TEXTURE_2D, null), x.bindFramebuffer(x.FRAMEBUFFER, S.fbo), x.viewport(0, 0, f, p), x.disable(x.SCISSOR_TEST), x.disable(x.STENCIL_TEST), x.clear(x.COLOR_BUFFER_BIT), x.disable(x.BLEND);
+	let C = i(ee, t);
+	return C && (x.bindVertexArray(e.meshCache.uploadRecurring(Pt).vao), w(e, Pt.indices.length, x.UNSIGNED_INT), x.bindVertexArray(null)), x.enable(x.BLEND), Ee(e, o, s, te), C ? {
+		texture: S.texture,
+		uvFromScreen: new Float32Array([
+			a / S.width,
+			0,
+			0,
+			0,
+			a / S.height,
+			0,
+			-c / S.width,
+			-u / S.height,
+			1
+		])
+	} : null;
+}
+function It(e, t, n) {
+	let r = e.gl;
+	return r.useProgram(t.handle), W(e, t, O), r.uniformMatrix3fv(t.uniform("u_worldInv"), !1, n.uvFromScreen), r.activeTexture(r.TEXTURE0), r.bindTexture(r.TEXTURE_2D, n.texture), r.uniform1i(t.uniform("u_sampler"), 0), t;
+}
+function Lt(e, t) {
+	e.imageCache.upload(t.image, t.image);
+	let { staged: n, slot: r } = L(e, t.image, t.sampling ?? "linear"), i = t.source, a = 0, o = 0, s = 1, c = 1;
+	if (i) {
+		let e = t.image.width, n = t.image.height;
+		a = i.x / e, s = (i.x + i.w) / e, o = i.y / n, c = (i.y + i.h) / n;
+	}
+	if (t.flipX) {
+		let e = a;
+		a = s, s = e;
+	}
+	if (t.flipY) {
+		let e = o;
+		o = c, c = e;
+	}
+	e.drawBatch.pushQuad(t.x, t.y, t.w, t.h, e.state.transform, a, o, s, c, (t.opacity ?? 1) * (n.foldsAlpha ? e.state.alpha : 1), r);
+}
+function Rt(e, t) {
+	let n = t.sprites, r = Math.floor(n.length / u);
+	if (r === 0) return;
+	e.imageCache.upload(t.image, t.image);
+	let i = t.sampling ?? "linear", { staged: a, slot: o } = L(e, t.image, i), s = e.drawBatch, c = e.state.transform, l = a.foldsAlpha ? e.state.alpha : 1, d = t.image.width, f = t.image.height;
+	for (let p = 0, m = 0; p < r; p++, m += u) {
+		s.wouldOverflow(4) && (H(e), {staged: a, slot: o} = L(e, t.image, i), l = a.foldsAlpha ? e.state.alpha : 1);
+		let r = n[m + 4], u = n[m + 5], p = n[m + 6], h = n[m + 7];
+		s.pushQuad(n[m], n[m + 1], n[m + 2], n[m + 3], c, r / d, u / f, (r + p) / d, (u + h) / f, n[m + 8] * l, o);
+	}
+}
+//#endregion
+export { vt as OUTLINE_MIN_SCREEN_PX, j as dispatch, Oe as drawGroup, H as flushBatch, f as getMesh, o as mat3, ut as popClip, lt as pushClip, ye as setUniform, V as tryStageFill };
+
+//# sourceMappingURL=draw.js.map