@weasel-js/core 1.9.4 → 1.10.0

package/dist/renderer/draw/clip.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clip.js","names":["enterGroupClip","pending","ctx","n","clip","enterClip","transform","rect","axisAlignedClipRect","path","depth","pushClip","leaveClip","entry","popClip","syncBatchClip","materializeClips","intersectClipRects","runClipDepth","stack","i","enterUncut","cut","leaveUncut","retryUncut","fn","a","b","flushForOwnDraw","flushBatch","rasterizePathToStencil","gl","handle","fillMeshHandle","setProjAndModel","model","drawTriangles","ancestors","ancestorMask","newDepth","newBit","ref","oldDepth","oldBit"],"sources":["../../../src/renderer/draw/clip.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport type { GlMat3 } from '../math/mat3';\nimport { axisAlignedClipRect, intersectClipRects, type ClipRect } from '../batchClip';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { fillMeshHandle } from './mesh';\nimport { setProjAndModel } from './uniforms';\nimport { ancestorMask } from './stencil';\nimport { flushBatch } from './flushBatch';\n\n/** `enterClip` for a group command, refusing one past the stencil's budget. */\nexport function enterGroupClip(ctx: DrawContext, clip: Path): void {\n  const pending = ctx.clipStack.reduce((n, e) => n + (e.depth === 0 ? 1 : 0), 0);\n  if (ctx.clipDepth + pending + 1 > 7) {\n    throw new Error(\n      'weasel: clip nesting depth exceeded (max 7). You can\\'t nest more than 7 levels ' +\n      'of clipped containers in a single draw tree. Flatten the hierarchy or compose ' +\n      'poses outside the scene graph.',\n    );\n  }\n  enterClip(ctx, clip);\n}\n\n/**\n * Push a group's clip.\n *\n * A clip only the stencil can express takes its bit now. An axis-aligned rect\n * takes none: staged geometry is cut to it on the CPU (`batchClip.ts`), so\n * content inside it joins the run outside it instead of costing a flush on\n * the way in and another on the way out. It takes a bit only if something that\n * draws for itself turns up inside it — see `flushForOwnDraw`.\n */\nfunction enterClip(ctx: DrawContext, path: Path): void {\n  const transform = ctx.state.transform;\n  const rect = axisAlignedClipRect(path, transform);\n  if (rect === null) {\n    // Bits nest in stack order, so any rect clip still without one takes it\n    // first.\n    materializeClips(ctx);\n    const depth = ctx.clipDepth + 1;\n    pushClip(ctx, path, depth);\n    ctx.clipDepth = depth;\n    ctx.clipStack.push({ path, transform, rect: null, depth });\n  } else {\n    ctx.clipStack.push({ path, transform, rect, depth: 0 });\n  }\n  syncBatchClip(ctx);\n}\n\nexport function leaveClip(ctx: DrawContext): void {\n  const entry = ctx.clipStack.pop()!;\n  if (entry.depth > 0) {\n    popClip(ctx, entry.path, entry.depth - 1, entry.transform);\n    ctx.clipDepth = entry.depth - 1;\n  }\n  syncBatchClip(ctx);\n}\n\n/** Give every rect clip on the stack its stencil bit, for a draw the CPU cut\n *  cannot reach. */\nfunction materializeClips(ctx: DrawContext): void {\n  for (const entry of ctx.clipStack) {\n    if (entry.depth !== 0) continue;\n    const depth = ctx.clipDepth + 1;\n    pushClip(ctx, entry.path, depth, entry.transform);\n    entry.depth = depth;\n    ctx.clipDepth = depth;\n  }\n}\n\nfunction syncBatchClip(ctx: DrawContext): void {\n  let rect: ClipRect | null = null;\n  for (const entry of ctx.clipStack) {\n    if (entry.rect) rect = rect ? intersectClipRects(rect, entry.rect) : entry.rect;\n  }\n  ctx.drawBatch.clip = rect;\n}\n\n/**\n * The clip depth a run is staged and drawn at: the innermost clip only the\n * stencil can express. Rect clips are left out whether or not they hold a bit,\n * because the CPU cut already applies them — which is what lets a run cross\n * them.\n */\nexport function runClipDepth(ctx: DrawContext): number {\n  const stack = ctx.clipStack;\n  if (stack.length === 0 || ctx.uncut) return ctx.clipDepth;\n  for (let i = stack.length - 1; i >= 0; i--) {\n    if (stack[i].rect === null) return stack[i].depth;\n  }\n  // Only rect clips: whatever depth held before the first of them took a bit.\n  for (const entry of stack) if (entry.depth > 0) return entry.depth - 1;\n  return ctx.clipDepth;\n}\n\n/**\n * Put the rect clips on the stencil and stop cutting, for an item the batch\n * refused to cut — one with a slanted edge across a clip (see\n * `DrawBatch.clipQuad`). Staged again between this and `leaveUncut`, the item\n * sees the full stencil depth and lands in a run of its own under every clip.\n * Returns the cut to hand back.\n *\n * A pair rather than a callback: the staging paths are hot, and a closure\n * over their arguments would cost an allocation on every call, refused or not.\n */\nexport function enterUncut(ctx: DrawContext): ClipRect | null {\n  materializeClips(ctx);\n  const cut = ctx.drawBatch.clip;\n  ctx.drawBatch.clip = null;\n  ctx.uncut = true;\n  return cut;\n}\n\nexport function leaveUncut(ctx: DrawContext, cut: ClipRect | null): void {\n  ctx.drawBatch.clip = cut;\n  ctx.uncut = false;\n}\n\n/** `fn(ctx, a, b)` again, uncut — for the stage-and-push helpers, which pass\n *  themselves. */\nexport function retryUncut<A, B>(\n  ctx: DrawContext, a: A, b: B, fn: (ctx: DrawContext, a: A, b: B) => void,\n): void {\n  const cut = enterUncut(ctx);\n  fn(ctx, a, b);\n  leaveUncut(ctx, cut);\n}\n\n/**\n * Drain the run before a draw that does not go through it, and give that draw\n * the stencil it tests against. Every such draw starts here or behind a\n * `tryStageFill` that returned `false`, which ends the same way.\n */\nexport function flushForOwnDraw(ctx: DrawContext): void {\n  flushBatch(ctx);\n  if (ctx.clipStack.length > 0) materializeClips(ctx);\n}\n\n/**\n * Rasterize a path into the stencil buffer using the pathFill shader geometry.\n * The caller is responsible for setting stencilFunc / stencilOp / stencilMask\n * and colorMask before calling.\n */\nfunction rasterizePathToStencil(ctx: DrawContext, path: Path, model: GlMat3): void {\n  const gl = ctx.gl;\n  const handle = fillMeshHandle(ctx, path);\n  gl.useProgram(ctx.pathFill.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, ctx.pathFill, model);\n  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  gl.bindVertexArray(null);\n}\n\n/**\n * Push a clip level. Rasterizes the clip path into the stencil buffer,\n * setting bit `newDepth` where (a) the path's fragment passes AND (b) all\n * ancestor clip bits are already set.\n *\n * Invariant: restores stencilMask(0xFF) on exit so callers (draw functions)\n * can rely on an unnarrowed mask after clip ops complete.\n */\nexport function pushClip(\n  ctx: DrawContext, path: Path, newDepth: number, model: GlMat3 = ctx.state.transform,\n): void {\n  // First, not last: a run staged outside the clip would otherwise draw under\n  // a mask it never had.\n  flushBatch(ctx);\n  const gl = ctx.gl;\n  const ancestors = ancestorMask(newDepth - 1);\n  const newBit = 1 << newDepth;\n  const ref = ancestors | newBit;\n\n  gl.enable(gl.STENCIL_TEST);\n  gl.colorMask(false, false, false, false);\n  if (fillMeshHandle(ctx, path).requiresStencil) {\n    // Fans, one per contour: their union is not the path. Parity goes on\n    // bit 0, the clip bit is written where parity is odd, and drawing the\n    // fans a third time returns bit 0 to zero.\n    gl.stencilMask(0x01);\n    gl.stencilFunc(gl.ALWAYS, 0, 0x01);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);\n    rasterizePathToStencil(ctx, path, model);\n    gl.stencilMask(newBit);\n    gl.stencilFunc(gl.EQUAL, ref | 0x01, ancestors | 0x01);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);\n    rasterizePathToStencil(ctx, path, model);\n    gl.stencilMask(0x01);\n    gl.stencilFunc(gl.ALWAYS, 0, 0x01);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);\n    rasterizePathToStencil(ctx, path, model);\n  } else {\n    gl.stencilMask(newBit);\n    gl.stencilFunc(gl.EQUAL, ref, ancestors);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);\n    rasterizePathToStencil(ctx, path, model);\n  }\n\n  gl.colorMask(true, true, true, true);\n  // Restore full mask so subsequent draw functions don't inherit a narrowed mask.\n  gl.stencilMask(0xFF);\n}\n\n/**\n * Pop a clip level. Rasterizes the same path again, clearing bit\n * `oldDepth + 1` where it was set during the matching push.\n *\n * Must re-enable STENCIL_TEST because child draw functions (drawPathFillStencil,\n * drawPathStrokeStenciled) call gl.disable(STENCIL_TEST) at their end. If\n * one of those was the last child before popClip runs, the test would be off\n * and rasterizePathToStencil would write nothing.\n *\n * Invariant: restores stencilMask(0xFF) on exit so callers are not left with\n * a narrowed mask.\n */\nexport function popClip(\n  ctx: DrawContext, path: Path, oldDepth: number, model: GlMat3 = ctx.state.transform,\n): void {\n  // First, not last: past here the mask is gone, and these pixels belonged\n  // inside it. A run staged below this bit does not test it, so it lives on.\n  if (ctx.batchState !== undefined && ctx.batchState.clipDepth > oldDepth) flushBatch(ctx);\n  const gl = ctx.gl;\n  // Re-enable stencil: child draw functions (evenodd/stenciled-stroke) disable\n  // it at their end; we must set it before writing the clear pass.\n  gl.enable(gl.STENCIL_TEST);\n\n  const oldBit = 1 << (oldDepth + 1);\n  const ref = ancestorMask(oldDepth) | oldBit;\n\n  gl.colorMask(false, false, false, false);\n  gl.stencilMask(oldBit);\n  gl.stencilFunc(gl.EQUAL, ref, ref);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.ZERO);\n\n  rasterizePathToStencil(ctx, path, model);\n\n  gl.colorMask(true, true, true, true);\n  // Restore full mask so subsequent draw functions don't inherit a narrowed mask.\n  gl.stencilMask(0xFF);\n}\n"],"mappings":"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"}

package/dist/renderer/draw/customShader.js

@@ -1,230 +0,0 @@
-import { getTexture as e } from "../textures/registerTexture.js";
-import { mat3 as t } from "../math/mat3.js";
-import { drawTriangles as n } from "./drawTriangles.js";
-import { applyClipTest as r } from "./stencil.js";
-//#region src/renderer/draw/customShader.ts
-var i = /* @__PURE__ */ new Set();
-function a(e, t) {
-	let n = `${e}:${t}`;
-	i.has(n) || (i.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 o(t, n, r, i, a) {
-	if (typeof r == "object" && r && !Array.isArray(r) && !(r instanceof Float32Array) && "id" in r && typeof r.id == "string") {
-		let o = r, s = e(o.id);
-		if (!s) {
-			(typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel setUniform: TextureHandle "${o.id}" not registered`);
-			return;
-		}
-		let c = a.value++;
-		t.activeTexture(t.TEXTURE0 + c), i.uploadRegistered(o.id, s.source), i.bind(o.id, c), t.uniform1i(n, c);
-		return;
-	}
-	if (r instanceof Float64Array && (r = Float32Array.from(r)), r instanceof Float32Array) {
-		if (r.length === 9) t.uniformMatrix3fv(n, !1, r);
-		else if (r.length === 16) t.uniformMatrix4fv(n, !1, r);
-		else if (typeof process > "u" || process.env.NODE_ENV !== "production") throw TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${r.length}`);
-		return;
-	}
-	if (Array.isArray(r)) {
-		let e = r;
-		switch (e.length) {
-			case 2:
-				t.uniform2fv(n, e);
-				break;
-			case 3:
-				t.uniform3fv(n, e);
-				break;
-			case 4:
-				t.uniform4fv(n, e);
-				break;
-			default: if (typeof process > "u" || process.env.NODE_ENV !== "production") throw TypeError(`weasel setUniform: array length ${e.length} not supported`);
-		}
-		return;
-	}
-	if (typeof r == "number") {
-		t.uniform1f(n, r);
-		return;
-	}
-}
-var s = {
-	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 c(e) {
-	return Array.isArray(e) || e instanceof Float32Array || e instanceof Int32Array || e instanceof Uint32Array;
-}
-function l(e, t, n, r) {
-	let i = typeof process < "u" ? process.env.NODE_ENV !== "production" : !0, a = s[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 u(e, t, n, r, i, s) {
-	for (let [u, d] of Object.entries(r)) {
-		let r = t.uniformArray(u);
-		if (r && c(d)) {
-			l(e, u, r, d);
-			continue;
-		}
-		let f = t.uniform(u);
-		if (f === void 0) {
-			a(n, u);
-			continue;
-		}
-		o(e, f, d, i, s);
-	}
-}
-function d(e, i) {
-	let { gl: a, programRegistry: o, quadVbo: s, quadIbo: c, textureCache: l } = e, d = o.get(i.program.id);
-	if (!d) {
-		console.warn(`weasel drawShader: program "${i.program.id}" not compiled on this renderer. Call renderer.registerProgram(handle) after the module-level registerProgram().`);
-		return;
-	}
-	if (!s || !c) {
-		console.warn("weasel drawShader: quad geometry not initialized");
-		return;
-	}
-	a.useProgram(d.handle);
-	let f = d.attribute("a_position"), p = d.attribute("a_uv");
-	a.bindBuffer(a.ARRAY_BUFFER, s), f !== void 0 && (a.enableVertexAttribArray(f), a.vertexAttribPointer(f, 2, a.FLOAT, !1, 16, 0)), p !== void 0 && (a.enableVertexAttribArray(p), a.vertexAttribPointer(p, 2, a.FLOAT, !1, 16, 8)), a.bindBuffer(a.ELEMENT_ARRAY_BUFFER, c);
-	let m = t.screenToClip(e.widthCss, e.heightCss), h = d.uniform("u_proj");
-	h !== void 0 && a.uniformMatrix3fv(h, !1, t.toUniform(m));
-	let g = d.uniform("u_bounds");
-	g !== void 0 && a.uniform4f(g, i.bounds.x, i.bounds.y, i.bounds.w, i.bounds.h);
-	let _ = d.uniform("u_view");
-	_ !== void 0 && a.uniformMatrix3fv(_, !1, t.toUniform(e.state.transform)), u(a, d, i.program.id, i.uniforms, l, { value: 1 }), r(e), n(e, 6, e.gl.UNSIGNED_SHORT), f !== void 0 && a.disableVertexAttribArray(f), p !== void 0 && a.disableVertexAttribArray(p), a.bindBuffer(a.ARRAY_BUFFER, null), a.bindBuffer(a.ELEMENT_ARRAY_BUFFER, null);
-}
-//#endregion
-export { d as drawShader, o as setUniform, u as setUniforms, a as warnOnceUniform };
-
-//# sourceMappingURL=customShader.js.map

package/dist/renderer/draw/customShader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"customShader.js","names":["warnedUniforms","warnOnceUniform","key","programId","name","setUniform","value","handle","entry","getTexture","unit","gl","textureCache","loc","arr","ARRAY_UPLOADS","isArrayValue","setUniformArray","isDev","upload","fn","setUniforms","uniforms","program","nextTexUnit","drawShader","ctx","programRegistry","cmd","quadVbo","quadIbo","aPosLoc","aUvLoc","proj","mat3","uProj","uBounds","uView","applyClipTest","drawTriangles"],"sources":["../../../src/renderer/draw/customShader.ts"],"sourcesContent":["import type { ShaderDrawCommand } from '../DrawCommand';\nimport { getTexture, type TextureHandle } from '../textures/registerTexture';\nimport type { ShaderUniform } from '../shaders/registerProgram';\nimport type { GLTextureCache } from '../cache/GLTextureCache';\nimport type { ShaderProgram, UniformArray } from '../shaders/ShaderProgram';\nimport { mat3 } from '../math/mat3';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { applyClipTest } from './stencil';\n\nconst warnedUniforms = new Set<string>();\n\nexport function warnOnceUniform(programId: string, name: string): void {\n  const key = `${programId}:${name}`;\n  if (warnedUniforms.has(key)) return;\n  warnedUniforms.add(key);\n  const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n  if (isDev) {\n    console.warn(`weasel drawShader: uniform \"${name}\" not found in program \"${programId}\". ` +\n      `Check spelling, ensure it's used in the shader (unused uniforms are optimized away by the driver).`);\n  }\n}\n\n/**\n * Bind a single ShaderUniform value to a GL uniform location.\n *\n * Type detection order:\n *   1. TextureHandle (object with string `.id`) — bind to next tex unit, set sampler.\n *   2. Float32Array — length 9 → mat3, length 16 → mat4. Other lengths throw in dev.\n *   3. Array — uniform2fv / uniform3fv / uniform4fv based on length.\n *   4. number — uniform1f.\n */\nexport function setUniform(\n  gl: WebGL2RenderingContext,\n  loc: WebGLUniformLocation,\n  value: ShaderUniform,\n  textureCache: GLTextureCache,\n  nextTexUnit: { value: number },\n): void {\n  if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Float32Array)\n      && 'id' in value && typeof (value as TextureHandle).id === 'string') {\n    const handle = value as TextureHandle;\n    const entry = getTexture(handle.id);\n    if (!entry) {\n      const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n      if (isDev) console.warn(`weasel setUniform: TextureHandle \"${handle.id}\" not registered`);\n      return;\n    }\n    const unit = nextTexUnit.value++;\n    // An upload binds and unbinds on the active unit, so it has to be this\n    // uniform's own unit and not one an earlier sampler already holds.\n    gl.activeTexture(gl.TEXTURE0 + unit);\n    textureCache.uploadRegistered(handle.id, entry.source);\n    textureCache.bind(handle.id, unit);\n    gl.uniform1i(loc, unit);\n    return;\n  }\n\n  // A kit matrix is in doubles; GL wants float32.\n  if (value instanceof Float64Array) value = Float32Array.from(value);\n\n  if (value instanceof Float32Array) {\n    if (value.length === 9) {\n      gl.uniformMatrix3fv(loc, false, value);\n    } else if (value.length === 16) {\n      gl.uniformMatrix4fv(loc, false, value);\n    } else {\n      const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n      if (isDev) throw new TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${value.length}`);\n    }\n    return;\n  }\n\n  if (Array.isArray(value)) {\n    const arr = value as readonly number[];\n    switch (arr.length) {\n      case 2: gl.uniform2fv(loc, arr as [number, number]); break;\n      case 3: gl.uniform3fv(loc, arr as [number, number, number]); break;\n      case 4: gl.uniform4fv(loc, arr as [number, number, number, number]); break;\n      default: {\n        const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n        if (isDev) throw new TypeError(`weasel setUniform: array length ${arr.length} not supported`);\n      }\n    }\n    return;\n  }\n\n  if (typeof value === 'number') {\n    gl.uniform1f(loc, value);\n    return;\n  }\n}\n\n/** How an array's element type is uploaded: the `uniform*v` call and the\n *  number of components per element. */\nconst ARRAY_UPLOADS: Readonly<Record<string, { fn: string; n: number; matrix?: true }>> = {\n  float: { fn: 'uniform1fv', n: 1 }, vec2: { fn: 'uniform2fv', n: 2 },\n  vec3: { fn: 'uniform3fv', n: 3 }, vec4: { fn: 'uniform4fv', n: 4 },\n  int: { fn: 'uniform1iv', n: 1 }, ivec2: { fn: 'uniform2iv', n: 2 },\n  ivec3: { fn: 'uniform3iv', n: 3 }, ivec4: { fn: 'uniform4iv', n: 4 },\n  bool: { fn: 'uniform1iv', n: 1 }, bvec2: { fn: 'uniform2iv', n: 2 },\n  bvec3: { fn: 'uniform3iv', n: 3 }, bvec4: { fn: 'uniform4iv', n: 4 },\n  uint: { fn: 'uniform1uiv', n: 1 }, uvec2: { fn: 'uniform2uiv', n: 2 },\n  uvec3: { fn: 'uniform3uiv', n: 3 }, uvec4: { fn: 'uniform4uiv', n: 4 },\n  mat2: { fn: 'uniformMatrix2fv', n: 4, matrix: true },\n  mat3: { fn: 'uniformMatrix3fv', n: 9, matrix: true },\n  mat4: { fn: 'uniformMatrix4fv', n: 16, matrix: true },\n  mat2x2: { fn: 'uniformMatrix2fv', n: 4, matrix: true },\n  mat3x3: { fn: 'uniformMatrix3fv', n: 9, matrix: true },\n  mat4x4: { fn: 'uniformMatrix4fv', n: 16, matrix: true },\n  mat2x3: { fn: 'uniformMatrix2x3fv', n: 6, matrix: true },\n  mat2x4: { fn: 'uniformMatrix2x4fv', n: 8, matrix: true },\n  mat3x2: { fn: 'uniformMatrix3x2fv', n: 6, matrix: true },\n  mat3x4: { fn: 'uniformMatrix3x4fv', n: 12, matrix: true },\n  mat4x2: { fn: 'uniformMatrix4x2fv', n: 8, matrix: true },\n  mat4x3: { fn: 'uniformMatrix4x3fv', n: 12, matrix: true },\n};\n\ntype ArrayValue = readonly number[] | Float32Array | Int32Array | Uint32Array;\n\nfunction isArrayValue(value: ShaderUniform): value is ArrayValue {\n  return Array.isArray(value) || value instanceof Float32Array\n    || value instanceof Int32Array || value instanceof Uint32Array;\n}\n\n/** Fill an array uniform from slot 0 with one call. Throws in dev on a value\n *  that is not a whole number of elements or overruns the declaration. */\nfunction setUniformArray(\n  gl: WebGL2RenderingContext,\n  name: string,\n  arr: UniformArray,\n  value: ArrayValue,\n): void {\n  const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n  const upload = ARRAY_UPLOADS[arr.type];\n  if (!upload) {\n    if (isDev) console.warn(`weasel setUniform: array uniform \"${name}\" has type ${arr.type}, which cannot be written as a whole`);\n    return;\n  }\n  if (value.length % upload.n !== 0 || value.length > upload.n * arr.size) {\n    if (isDev) {\n      throw new TypeError(\n        `weasel setUniform: \"${name}\" is ${arr.type}[${arr.size}], so its value must hold a multiple of ${upload.n} `\n        + `numbers, at most ${upload.n * arr.size}; got ${value.length}`,\n      );\n    }\n    return;\n  }\n  if (value.length === 0) return;\n  const fn = (gl as unknown as Record<string, (...args: unknown[]) => void>)[upload.fn];\n  if (upload.matrix) fn.call(gl, arr.location, false, value);\n  else fn.call(gl, arr.location, value);\n}\n\n/** Write every entry of a command's `uniforms` map. A key naming an array\n *  uniform with an array value fills the array; anything else goes to the\n *  location of that exact name. */\nexport function setUniforms(\n  gl: WebGL2RenderingContext,\n  program: ShaderProgram,\n  programId: string,\n  uniforms: Record<string, ShaderUniform>,\n  textureCache: GLTextureCache,\n  nextTexUnit: { value: number },\n): void {\n  for (const [name, value] of Object.entries(uniforms)) {\n    const arr = program.uniformArray(name);\n    if (arr && isArrayValue(value)) {\n      setUniformArray(gl, name, arr, value);\n      continue;\n    }\n    const loc = program.uniform(name);\n    if (loc === undefined) {\n      warnOnceUniform(programId, name);\n      continue;\n    }\n    setUniform(gl, loc, value, textureCache, nextTexUnit);\n  }\n}\n\nexport function drawShader(ctx: DrawContext, cmd: ShaderDrawCommand): void {\n  const { gl, programRegistry, quadVbo, quadIbo, textureCache } = ctx;\n\n  const program = programRegistry.get(cmd.program.id);\n  if (!program) {\n    console.warn(\n      `weasel drawShader: program \"${cmd.program.id}\" not compiled on this renderer. ` +\n      `Call renderer.registerProgram(handle) after the module-level registerProgram().`,\n    );\n    return;\n  }\n  if (!quadVbo || !quadIbo) {\n    console.warn('weasel drawShader: quad geometry not initialized');\n    return;\n  }\n\n  gl.useProgram(program.handle);\n\n  const aPosLoc = program.attribute('a_position');\n  const aUvLoc  = program.attribute('a_uv');\n\n  gl.bindBuffer(gl.ARRAY_BUFFER, quadVbo);\n  if (aPosLoc !== undefined) {\n    gl.enableVertexAttribArray(aPosLoc);\n    gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, 16, 0);\n  }\n  if (aUvLoc !== undefined) {\n    gl.enableVertexAttribArray(aUvLoc);\n    gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, 16, 8);\n  }\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, quadIbo);\n\n  const proj = mat3.screenToClip(ctx.widthCss, ctx.heightCss);\n  const uProj = program.uniform('u_proj');\n  if (uProj !== undefined) gl.uniformMatrix3fv(uProj, false, mat3.toUniform(proj));\n\n  const uBounds = program.uniform('u_bounds');\n  if (uBounds !== undefined) {\n    gl.uniform4f(uBounds, cmd.bounds.x, cmd.bounds.y, cmd.bounds.w, cmd.bounds.h);\n  }\n\n  const uView = program.uniform('u_view');\n  if (uView !== undefined) gl.uniformMatrix3fv(uView, false, mat3.toUniform(ctx.state.transform));\n\n  setUniforms(gl, program, cmd.program.id, cmd.uniforms, textureCache, { value: 1 });\n\n  applyClipTest(ctx);\n  drawTriangles(ctx, 6, ctx.gl.UNSIGNED_SHORT);\n\n  if (aPosLoc !== undefined) gl.disableVertexAttribArray(aPosLoc);\n  if (aUvLoc  !== undefined) gl.disableVertexAttribArray(aUvLoc);\n  gl.bindBuffer(gl.ARRAY_BUFFER, null);\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n}\n"],"mappings":"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"}

package/dist/renderer/draw/drawTriangles.js

@@ -1,8 +0,0 @@
-//#region src/renderer/draw/drawTriangles.ts
-function e(e, t, n) {
-	e.gl.drawElements(e.gl.TRIANGLES, t, n, 0), e.stats && e.stats.drawCalls++;
-}
-//#endregion
-export { e as drawTriangles };
-
-//# sourceMappingURL=drawTriangles.js.map

package/dist/renderer/draw/drawTriangles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"drawTriangles.js","names":["drawTriangles","ctx","count","type"],"sources":["../../../src/renderer/draw/drawTriangles.ts"],"sourcesContent":["import type { DrawContext } from './drawContext';\n\n/** Every GL draw the renderer issues goes through here, so the frame's\n *  draw-call count cannot miss one. */\nexport function drawTriangles(ctx: DrawContext, count: number, type: number): void {\n  ctx.gl.drawElements(ctx.gl.TRIANGLES, count, type, 0);\n  if (ctx.stats) ctx.stats.drawCalls++;\n}\n"],"mappings":";AAIA,SAAgBA,EAAc,GAAkB,GAAe,GAAoB;CAEjF,AADAC,EAAI,GAAG,aAAaA,EAAI,GAAG,WAAWC,GAAOC,GAAM,CAAC,GAChDF,EAAI,SAAO,EAAI,MAAM;AAC3B"}

package/dist/renderer/draw/effects.js

@@ -1,28 +0,0 @@
-import { drawTriangles as e } from "./drawTriangles.js";
-import { setUniforms as t } from "./customShader.js";
-import { setColorMatrixUniforms as n } from "./uniforms.js";
-//#region src/renderer/draw/effects.ts
-function r(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 i(r, i, a, o, s, c, l, u) {
-	let d = r.gl;
-	d.useProgram(i.handle);
-	let f = i.attribute("a_position"), p = i.attribute("a_uv");
-	d.bindBuffer(d.ARRAY_BUFFER, r.quadVbo), d.bindBuffer(d.ELEMENT_ARRAY_BUFFER, r.quadIbo), f !== void 0 && f >= 0 && (d.enableVertexAttribArray(f), d.vertexAttribPointer(f, 2, d.FLOAT, !1, 16, 0)), p !== void 0 && p >= 0 && (d.enableVertexAttribArray(p), d.vertexAttribPointer(p, 2, d.FLOAT, !1, 16, 8)), d.activeTexture(d.TEXTURE0), d.bindTexture(d.TEXTURE_2D, a);
-	let m = i.uniform("u_source");
-	m !== void 0 && d.uniform1i(m, 0);
-	let h = i.uniform("u_resolution");
-	h !== void 0 && d.uniform2f(h, o, s);
-	let g = i.uniform("u_texel");
-	if (g !== void 0 && d.uniform2f(g, 1 / o, 1 / s), l) {
-		let e = i.uniform("u_alpha");
-		e !== void 0 && d.uniform1f(e, l.alpha), n(r, i, l.colorMatrix);
-	}
-	c && t(d, i, u ?? "effect", c, r.textureCache, { value: 1 }), e(r, 6, r.gl.UNSIGNED_SHORT), f !== void 0 && f >= 0 && d.disableVertexAttribArray(f), p !== void 0 && p >= 0 && d.disableVertexAttribArray(p), d.bindBuffer(d.ARRAY_BUFFER, null), d.bindBuffer(d.ELEMENT_ARRAY_BUFFER, null);
-}
-//#endregion
-export { i as drawFullscreenQuad, r as returnToRenderTarget };
-
-//# sourceMappingURL=effects.js.map

package/dist/renderer/draw/effects.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effects.js","names":["returnToRenderTarget","gl","ctx","target","width","height","scissorWasOn","drawFullscreenQuad","program","aPos","aUv","texture","source","resolution","texel","composite","alpha","setColorMatrixUniforms","uniforms","setUniforms","programId","drawTriangles"],"sources":["../../../src/renderer/draw/effects.ts"],"sourcesContent":["import type { ShaderUniform } from '../shaders/registerProgram';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { setColorMatrixUniforms } from './uniforms';\nimport { setUniforms } from './customShader';\n\n/** Rebind `ctx.renderTarget` after an offscreen pass: a pooled target takes\n *  the whole `width` × `height` buffer, the default framebuffer the renderer's\n *  own rect and the scissor it had. */\nexport function returnToRenderTarget(\n  ctx: DrawContext, width: number, height: number, scissorWasOn: boolean,\n): void {\n  const gl = ctx.gl;\n  const target = ctx.renderTarget ?? null;\n  gl.bindFramebuffer(gl.FRAMEBUFFER, target ? target.fbo : null);\n  if (target) {\n    gl.viewport(0, 0, width, height);\n  } else {\n    ctx.restoreTargetRect?.();\n    if (scissorWasOn) gl.enable(gl.SCISSOR_TEST);\n  }\n}\n\n/** One pass: the kit quad, `u_source` bound to `texture`, and whatever else\n *  the caller supplies. Leaves no attribute arrays or buffers bound. */\nexport function drawFullscreenQuad(\n  ctx: DrawContext,\n  program: ShaderProgram,\n  texture: WebGLTexture,\n  width: number,\n  height: number,\n  uniforms?: Record<string, ShaderUniform>,\n  composite?: { alpha: number; colorMatrix: Float32Array },\n  programId?: string,\n): void {\n  const gl = ctx.gl;\n  gl.useProgram(program.handle);\n\n  const aPos = program.attribute('a_position');\n  const aUv = program.attribute('a_uv');\n  gl.bindBuffer(gl.ARRAY_BUFFER, ctx.quadVbo);\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ctx.quadIbo);\n  if (aPos !== undefined && aPos >= 0) {\n    gl.enableVertexAttribArray(aPos);\n    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);\n  }\n  if (aUv !== undefined && aUv >= 0) {\n    gl.enableVertexAttribArray(aUv);\n    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);\n  }\n\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, texture);\n  const source = program.uniform('u_source');\n  if (source !== undefined) gl.uniform1i(source, 0);\n  const resolution = program.uniform('u_resolution');\n  if (resolution !== undefined) gl.uniform2f(resolution, width, height);\n  const texel = program.uniform('u_texel');\n  if (texel !== undefined) gl.uniform2f(texel, 1 / width, 1 / height);\n\n  if (composite) {\n    const alpha = program.uniform('u_alpha');\n    if (alpha !== undefined) gl.uniform1f(alpha, composite.alpha);\n    setColorMatrixUniforms(ctx, program, composite.colorMatrix);\n  }\n\n  // Unit 0 is `u_source`; a consumer texture starts above it.\n  if (uniforms) setUniforms(gl, program, programId ?? 'effect', uniforms, ctx.textureCache, { value: 1 });\n\n  drawTriangles(ctx, 6, ctx.gl.UNSIGNED_SHORT);\n\n  if (aPos !== undefined && aPos >= 0) gl.disableVertexAttribArray(aPos);\n  if (aUv !== undefined && aUv >= 0) gl.disableVertexAttribArray(aUv);\n  gl.bindBuffer(gl.ARRAY_BUFFER, null);\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n}\n"],"mappings":";;;;AAUA,SAAgBA,EACd,GAAkB,GAAe,GAAgB,GAC3C;CACN,IAAMC,IAAKC,EAAI,IACTC,IAASD,EAAI,gBAAgB;CAEnC,AADAD,EAAG,gBAAgBA,EAAG,aAAaE,IAASA,EAAO,MAAM,IAAI,GACzDA,IACFF,EAAG,SAAS,GAAG,GAAGG,GAAOC,CAAM,KAE/BH,EAAI,oBAAoB,GACpBI,KAAcL,EAAG,OAAOA,EAAG,YAAY;AAE/C;AAIA,SAAgBM,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMN,IAAKC,EAAI;CACf,EAAG,WAAWM,EAAQ,MAAM;CAE5B,IAAMC,IAAOD,EAAQ,UAAU,YAAY,GACrCE,IAAMF,EAAQ,UAAU,MAAM;CAapC,AAZAP,EAAG,WAAWA,EAAG,cAAcC,EAAI,OAAO,GAC1CD,EAAG,WAAWA,EAAG,sBAAsBC,EAAI,OAAO,GAC9CO,MAAS,KAAA,KAAaA,KAAQ,MAChCR,EAAG,wBAAwBQ,CAAI,GAC/BR,EAAG,oBAAoBQ,GAAM,GAAGR,EAAG,OAAO,IAAO,IAAI,CAAC,IAEpDS,MAAQ,KAAA,KAAaA,KAAO,MAC9BT,EAAG,wBAAwBS,CAAG,GAC9BT,EAAG,oBAAoBS,GAAK,GAAGT,EAAG,OAAO,IAAO,IAAI,CAAC,IAGvDA,EAAG,cAAcA,EAAG,QAAQ,GAC5BA,EAAG,YAAYA,EAAG,YAAYU,CAAO;CACrC,IAAMC,IAASJ,EAAQ,QAAQ,UAAU;CACzC,AAAII,MAAW,KAAA,KAAWX,EAAG,UAAUW,GAAQ,CAAC;CAChD,IAAMC,IAAaL,EAAQ,QAAQ,cAAc;CACjD,AAAIK,MAAe,KAAA,KAAWZ,EAAG,UAAUY,GAAYT,GAAOC,CAAM;CACpE,IAAMS,IAAQN,EAAQ,QAAQ,SAAS;CAGvC,IAFIM,MAAU,KAAA,KAAWb,EAAG,UAAUa,GAAO,IAAIV,GAAO,IAAIC,CAAM,GAE9DU,GAAW;EACb,IAAMC,IAAQR,EAAQ,QAAQ,SAAS;EAEvC,AADIQ,MAAU,KAAA,KAAWf,EAAG,UAAUe,GAAOD,EAAU,KAAK,GAC5DE,EAAuBf,GAAKM,GAASO,EAAU,WAAW;CAC5D;CAUA,AAPIG,KAAUC,EAAYlB,GAAIO,GAASY,KAAa,UAAUF,GAAUhB,EAAI,cAAc,EAAE,OAAO,EAAE,CAAC,GAEtGmB,EAAcnB,GAAK,GAAGA,EAAI,GAAG,cAAc,GAEvCO,MAAS,KAAA,KAAaA,KAAQ,KAAGR,EAAG,yBAAyBQ,CAAI,GACjEC,MAAQ,KAAA,KAAaA,KAAO,KAAGT,EAAG,yBAAyBS,CAAG,GAClET,EAAG,WAAWA,EAAG,cAAc,IAAI,GACnCA,EAAG,WAAWA,EAAG,sBAAsB,IAAI;AAC7C"}

package/dist/renderer/draw/flushBatch.js

@@ -1,35 +0,0 @@
-import { BATCH_TEXTURE_SLOTS as e } from "../shaders/batchFill.js";
-import { mat3 as t } from "../math/mat3.js";
-import { drawTriangles as n } from "./drawTriangles.js";
-import { applyClipTest as r } from "./stencil.js";
-import { setAlphaUniform as i, setColorMatrixUniforms as a, setColorUniform as o, setProjAndModel as s } from "./uniforms.js";
-//#region src/renderer/draw/flushBatch.ts
-var c = t.identity(), l = new Int32Array(Array.from({ length: e }, (e, t) => t)), u = new Float32Array(2 * e);
-function d(e) {
-	let t = e.drawBatch, d = e.batchState;
-	if (t.length === 0 || d === void 0) {
-		e.batchState = void 0;
-		return;
-	}
-	let f = e.gl, p = e.batchFill;
-	f.useProgram(p.handle);
-	let m = t.uploadAndBind();
-	s(e, p, c), o(e, p, 1, 1, 1, 1), i(e, p, d.alpha), f.uniform1f(p.uniform("u_synthBold"), d.synthBold), a(e, p, d.colorMatrix), f.activeTexture(f.TEXTURE0), f.bindTexture(f.TEXTURE_2D, e.whiteTexture);
-	for (let t = 0; t < d.textures.length; t++) {
-		let n = d.textures[t];
-		if (n.kind === "atlas") {
-			e.textureCache.bind(n.id, t + 1), u[2 * (t + 1)] = n.fieldScale[0], u[2 * (t + 1) + 1] = n.fieldScale[1];
-			continue;
-		}
-		if (n.kind === "ramps") {
-			e.gradRamps.bind(t + 1);
-			continue;
-		}
-		e.imageCache.bind(n.image, t + 1), e.imageCache.setMagFilter(n.image, n.sampling === "nearest" ? f.NEAREST : f.LINEAR);
-	}
-	f.uniform1iv(p.uniform("u_samplers"), l), f.uniform2fv(p.uniform("u_fieldScale"), u), r(e, d.clipDepth), n(e, m, e.gl.UNSIGNED_INT), f.activeTexture(f.TEXTURE0), f.bindVertexArray(null), t.reset(), e.batchState = void 0;
-}
-//#endregion
-export { c as BATCH_MODEL, d as flushBatch };
-
-//# sourceMappingURL=flushBatch.js.map

package/dist/renderer/draw/flushBatch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flushBatch.js","names":["BATCH_MODEL","mat3","SAMPLER_UNITS","BATCH_TEXTURE_SLOTS","i","FIELD_SCALES","flushBatch","batch","ctx","staged","gl","prog","indexCount","setProjAndModel","setColorUniform","setAlphaUniform","setColorMatrixUniforms","entry","applyClipTest","drawTriangles"],"sources":["../../../src/renderer/draw/flushBatch.ts"],"sourcesContent":["import { mat3 } from '../math/mat3';\nimport { BATCH_TEXTURE_SLOTS } from '../shaders/batchFill';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport {\n  setColorUniform,\n  setAlphaUniform,\n  setColorMatrixUniforms,\n  setProjAndModel,\n} from './uniforms';\nimport { applyClipTest } from './stencil';\n\n/** The rect batch transforms its own corners, so it draws at model identity. */\nexport const BATCH_MODEL = mat3.identity();\n\n/** `u_samplers[i] = i`, uploaded whole per flush. Built once: the mapping from\n *  slot to texture unit is the identity and never varies. */\nconst SAMPLER_UNITS = new Int32Array(\n  Array.from({ length: BATCH_TEXTURE_SLOTS }, (_, i) => i),\n);\n\n/** `u_fieldScale`, per slot: an atlas slot's `glyphFieldScale`. Slots that are\n *  not atlases keep whatever a previous flush wrote, which nothing reads. */\nconst FIELD_SCALES = new Float32Array(2 * BATCH_TEXTURE_SLOTS);\n\n/**\n * Draw the staged run as one `drawElements`, under the state it was staged\n * under. Callers that are about to bind a different program, or paint anything\n * that must land on top of the run, call this first; a group that only changes\n * the color matrix does not, because `pushRect` notices and flushes then, and\n * one that only changes transform or alpha does not break the run at all.\n *\n * Stencil clips are the exception: the stencil is real GL state that the\n * staged values cannot reconstruct, so `pushClip` flushes *before* writing a\n * bit, and `popClip` before clearing one a staged run tests. Rect clips never\n * reach the stencil while only staged geometry is inside them — see\n * `enterClip`.\n *\n * `u_color` stays white: the vertex-color program multiplies it by the\n * per-vertex color, so white makes the result bit-identical to the flat\n * program's `u_color`-only math. `u_model` stays identity for the same reason —\n * the corners arrive already transformed.\n */\nexport function flushBatch(ctx: DrawContext): void {\n  const batch = ctx.drawBatch;\n  const staged = ctx.batchState;\n  if (batch.length === 0 || staged === undefined) {\n    // An empty run's state still names a clip depth, and an item refused by\n    // the CPU cut is about to be staged again under a different one.\n    ctx.batchState = undefined;\n    return;\n  }\n  const gl = ctx.gl;\n  const prog = ctx.batchFill;\n  gl.useProgram(prog.handle);\n  const indexCount = batch.uploadAndBind();\n  setProjAndModel(ctx, prog, BATCH_MODEL);\n  setColorUniform(ctx, prog, 1, 1, 1, 1);\n  setAlphaUniform(ctx, prog, staged.alpha);\n  gl.uniform1f(prog.uniform('u_synthBold')!, staged.synthBold);\n  setColorMatrixUniforms(ctx, prog, staged.colorMatrix);\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, ctx.whiteTexture);\n  for (let i = 0; i < staged.textures.length; i++) {\n    const entry = staged.textures[i];\n    if (entry.kind === 'atlas') {\n      ctx.textureCache.bind(entry.id, i + 1);\n      FIELD_SCALES[2 * (i + 1)] = entry.fieldScale[0];\n      FIELD_SCALES[2 * (i + 1) + 1] = entry.fieldScale[1];\n      continue;\n    }\n    if (entry.kind === 'ramps') {\n      ctx.gradRamps.bind(i + 1);\n      continue;\n    }\n    ctx.imageCache.bind(entry.image, i + 1);\n    // Per flush, not at upload: the same bitmap can be drawn at both filters in\n    // one frame. The cache skips the write when the texture already carries the\n    // value, which is most flushes.\n    ctx.imageCache.setMagFilter(\n      entry.image,\n      entry.sampling === 'nearest' ? gl.NEAREST : gl.LINEAR,\n    );\n  }\n  gl.uniform1iv(prog.uniform('u_samplers')!, SAMPLER_UNITS);\n  gl.uniform2fv(prog.uniform('u_fieldScale')!, FIELD_SCALES);\n  applyClipTest(ctx, staged.clipDepth);\n  drawTriangles(ctx, indexCount, ctx.gl.UNSIGNED_INT);\n  // Everything else in the renderer binds its texture to unit 0 and some of it\n  // does so without an `activeTexture` of its own, so leaving unit 6 selected\n  // sends the next such bind to a unit nothing samples.\n  gl.activeTexture(gl.TEXTURE0);\n  // Not redundant: `drawShader` binds no VAO and points attributes at whatever\n  // is current, so a slot left bound here comes back corrupted a ring later.\n  gl.bindVertexArray(null);\n  batch.reset();\n  ctx.batchState = undefined;\n}\n"],"mappings":";;;;;;AAaA,IAAaA,IAAcC,EAAK,SAAS,GAInCC,IAAgB,IAAI,WACxB,MAAM,KAAK,EAAE,QAAQC,EAAoB,IAAI,GAAG,MAAMC,CAAC,CACzD,GAIMC,IAAe,IAAI,aAAa,IAAIF,CAAmB;AAoB7D,SAAgBG,EAAW,GAAwB;CACjD,IAAMC,IAAQC,EAAI,WACZC,IAASD,EAAI;CACnB,IAAID,EAAM,WAAW,KAAKE,MAAW,KAAA,GAAW;EAG9C,EAAI,aAAa,KAAA;EACjB;CACF;CACA,IAAMC,IAAKF,EAAI,IACTG,IAAOH,EAAI;CACjB,EAAG,WAAWG,EAAK,MAAM;CACzB,IAAMC,IAAaL,EAAM,cAAc;CAOvC,AANAM,EAAgBL,GAAKG,GAAMX,CAAW,GACtCc,EAAgBN,GAAKG,GAAM,GAAG,GAAG,GAAG,CAAC,GACrCI,EAAgBP,GAAKG,GAAMF,EAAO,KAAK,GACvCC,EAAG,UAAUC,EAAK,QAAQ,aAAa,GAAIF,EAAO,SAAS,GAC3DO,EAAuBR,GAAKG,GAAMF,EAAO,WAAW,GACpDC,EAAG,cAAcA,EAAG,QAAQ,GAC5BA,EAAG,YAAYA,EAAG,YAAYF,EAAI,YAAY;CAC9C,KAAK,IAAIJ,IAAI,GAAGA,IAAIK,EAAO,SAAS,QAAQ,KAAK;EAC/C,IAAMQ,IAAQR,EAAO,SAASL;EAC9B,IAAIa,EAAM,SAAS,SAAS;GAG1B,AAFAT,EAAI,aAAa,KAAKS,EAAM,IAAIb,IAAI,CAAC,GACrC,EAAa,KAAKA,IAAI,MAAMa,EAAM,WAAW,IAC7C,EAAa,KAAKb,IAAI,KAAK,KAAKa,EAAM,WAAW;GACjD;EACF;EACA,IAAIA,EAAM,SAAS,SAAS;GAC1B,EAAI,UAAU,KAAKb,IAAI,CAAC;GACxB;EACF;EAKA,AAJAI,EAAI,WAAW,KAAKS,EAAM,OAAOb,IAAI,CAAC,GAItCI,EAAI,WAAW,aACbS,EAAM,OACNA,EAAM,aAAa,YAAYP,EAAG,UAAUA,EAAG,MACjD;CACF;CAaA,AAZAA,EAAG,WAAWC,EAAK,QAAQ,YAAY,GAAIT,CAAa,GACxDQ,EAAG,WAAWC,EAAK,QAAQ,cAAc,GAAIN,CAAY,GACzDa,EAAcV,GAAKC,EAAO,SAAS,GACnCU,EAAcX,GAAKI,GAAYJ,EAAI,GAAG,YAAY,GAIlDE,EAAG,cAAcA,EAAG,QAAQ,GAG5BA,EAAG,gBAAgB,IAAI,GACvBH,EAAM,MAAM,GACZ,EAAI,aAAa,KAAA;AACnB"}

package/dist/renderer/draw/gradient.js

@@ -1,90 +0,0 @@
-import { PAINT_MODE_CONIC as e, PAINT_MODE_PLAIN as t, PAINT_MODE_RADIAL as n } from "../shaders/batchFill.js";
-import { mat3 as r } from "../math/mat3.js";
-//#region src/renderer/draw/gradient.ts
-function i(r, i, u) {
-	if (u) return;
-	let d = i.fill ?? "solid";
-	if (d === "solid") {
-		let e = i;
-		return {
-			kind: "solid",
-			color: e.color,
-			opacity: e.opacity
-		};
-	}
-	if (d !== "linear-gradient" && d !== "radial-gradient" && d !== "conic-gradient") return;
-	let f = i, p = o(r, f.units);
-	return p ? f.fill === "linear-gradient" ? a(f, t, s(p, f)) : f.fill === "radial-gradient" ? a(f, n, c(p, f)) : a(f, e, l(p, f)) : null;
-}
-function a(e, t, n) {
-	return {
-		kind: "ramp",
-		stops: e.stops,
-		space: e.interpolate ?? "rgb",
-		opacity: e.opacity,
-		mode: t,
-		uv: n
-	};
-}
-function o(e, t) {
-	let n = d(e, t);
-	return n && r.multiply(n, e.state.transform);
-}
-function s(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 c(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 l(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 u(e, n) {
-	return e.mode === t ? {
-		uv: {
-			...e.uv,
-			v0: n
-		},
-		post: 1
-	} : {
-		uv: e.uv,
-		post: n
-	};
-}
-function d(e, t) {
-	return t === "local" ? r.invert(e.state.transform) : t === "world" && e.viewMatrix ? r.invert(e.viewMatrix) : r.identity();
-}
-function f(e, t) {
-	let n = d(e, t), i = n && r.invert(n);
-	if (!i) return null;
-	let a = e.deviceWidth && e.widthCss > 0 ? e.deviceWidth / e.widthCss : 1;
-	return r.multiply(r.scaled(r.identity(), a, a), i);
-}
-//#endregion
-export { i as batchPaint, d as gradientSpaceInverse, u as rampVertices, f as spaceToDevice };
-
-//# sourceMappingURL=gradient.js.map

package/dist/renderer/draw/gradient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gradient.js","names":["batchPaint","hasVColors","kind","fill","solid","grad","g","gradientMap","ctx","ramp","PAINT_MODE_PLAIN","linearRampUV","PAINT_MODE_RADIAL","radialRampUV","PAINT_MODE_CONIC","conicRampUV","inverse","gradientSpaceInverse","units","mat3","dx","dy","len","k","cos","sin","dx0","dy0","rampVertices","paint","rowV","spaceToDevice","toScreen","ratio"],"sources":["../../../src/renderer/draw/gradient.ts"],"sourcesContent":["import type { ColorSpace, FillStyle, GradientUnits, GradStop } from '@weasel-js/paint';\nimport { mat3, type GlMat3 } from '../math/mat3';\nimport type { GradientUV } from '../drawBatch';\nimport { PAINT_MODE_PLAIN, PAINT_MODE_RADIAL, PAINT_MODE_CONIC } from '../shaders/batchFill';\nimport type { DrawContext } from './drawContext';\n\n/** A paint a run can express, resolved from a `FillStyle` by `batchPaint`. */\nexport type BatchPaint =\n  | { kind: 'solid'; color: string; opacity?: number }\n  | {\n      kind: 'ramp'; stops: GradStop[]; space: ColorSpace; opacity?: number;\n      /** `PAINT_MODE_PLAIN` for a linear gradient, whose ramp position a vertex\n       *  carries outright; `PAINT_MODE_RADIAL` / `PAINT_MODE_CONIC` otherwise. */\n      mode: number;\n      uv: GradientUV;\n    };\n\n/**\n * `fill` as something a run can carry, or `undefined` for a paint no run can\n * express — a pattern, a shader, per-vertex colors — and `null` for a gradient\n * whose space has no inverse under this transform, which draws nothing.\n *\n * **All three gradients qualify, and for the same reason,** which is not that\n * their ramp position is affine in position — only a linear gradient's is. It\n * is that the *coordinate* the ramp position is computed from is affine in all\n * three, so a vertex can carry that and the rasterizer's interpolation across a\n * triangle is exact. A linear gradient's coordinate is the ramp position\n * itself, which is why it needs no paint mode; the other two carry a\n * gradient-space point and the shader takes a `length` or an `atan` of it.\n */\nexport function batchPaint(\n  ctx: DrawContext, fill: FillStyle, hasVColors: boolean,\n): BatchPaint | undefined | null {\n  if (hasVColors) return undefined;\n  const kind = fill.fill ?? 'solid';\n  if (kind === 'solid') {\n    const solid = fill as { color: string; opacity?: number };\n    return { kind: 'solid', color: solid.color, opacity: solid.opacity };\n  }\n  if (kind !== 'linear-gradient' && kind !== 'radial-gradient' && kind !== 'conic-gradient') {\n    return undefined;\n  }\n  const grad = fill as Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>;\n  const g = gradientMap(ctx, grad.units);\n  if (!g) return null;\n  if (grad.fill === 'linear-gradient') return ramp(grad, PAINT_MODE_PLAIN, linearRampUV(g, grad));\n  if (grad.fill === 'radial-gradient') return ramp(grad, PAINT_MODE_RADIAL, radialRampUV(g, grad));\n  return ramp(grad, PAINT_MODE_CONIC, conicRampUV(g, grad));\n}\n\nfunction ramp(\n  fill: { stops: GradStop[]; interpolate?: ColorSpace; opacity?: number },\n  mode: number, uv: GradientUV,\n): BatchPaint {\n  return {\n    kind: 'ramp', stops: fill.stops, space: fill.interpolate ?? 'rgb',\n    opacity: fill.opacity, mode, uv,\n  };\n}\n\n/**\n * Geometry-space → gradient-space, as the one matrix a vertex is measured\n * through.\n *\n * `gradientSpaceInverse` maps a screen position back into the gradient's space\n * and the batch's vertices arrive before the model transform, so the two\n * compose. This is the composition `gradFill`'s vertex shader does in two\n * steps, and the pair have to agree: a radial gradient goes through that one\n * and a linear one through this.\n */\nfunction gradientMap(ctx: DrawContext, units: GradientUnits | undefined): GlMat3 | null {\n  const inverse = gradientSpaceInverse(ctx, units);\n  return inverse && mat3.multiply(inverse, ctx.state.transform);\n}\n\n/**\n * The gradient shader's `dot(p - from, dir) / len` folded into `u`, with `v`\n * left for the atlas row `stageRamps` fills in.\n */\nfunction linearRampUV(\n  g: GlMat3, fill: Extract<FillStyle, { fill: 'linear-gradient' }>,\n): GradientUV {\n  const dx = fill.to.x - fill.from.x;\n  const dy = fill.to.y - fill.from.y;\n  const len = Math.hypot(dx, dy) || 1;\n  // dir is (dx, dy)/len and the divisor is len, so the pair is 1/len².\n  const k = 1 / (len * len);\n  return {\n    ux: (g[0] * dx + g[1] * dy) * k,\n    uy: (g[3] * dx + g[4] * dy) * k,\n    u0: ((g[6] - fill.from.x) * dx + (g[7] - fill.from.y) * dy) * k,\n    vx: 0, vy: 0, v0: 0,\n  };\n}\n\n/** The gradient-space point scaled so its distance from the center *is* the\n *  ramp position, which is what makes the shader's half a `length`. */\nfunction radialRampUV(\n  g: GlMat3, fill: Extract<FillStyle, { fill: 'radial-gradient' }>,\n): GradientUV {\n  // The floor is `gradFill`'s own `max(u_gradRadius, 0.0001)`.\n  const k = 1 / Math.max(fill.radius, 1e-4);\n  return {\n    ux: g[0] * k, uy: g[3] * k, u0: (g[6] - fill.center.x) * k,\n    vx: g[1] * k, vy: g[4] * k, v0: (g[7] - fill.center.y) * k,\n  };\n}\n\n/**\n * The gradient-space point about the center, turned by `-angle` so the shader's\n * half is an `atan` of it and nothing else.\n *\n * `gradFill` subtracts the angle from the arctangent instead. The two agree\n * because rotating a point turns its arctangent by the same amount, and the\n * `fract` that follows takes care of the wrap either way.\n */\nfunction conicRampUV(\n  g: GlMat3, fill: Extract<FillStyle, { fill: 'conic-gradient' }>,\n): GradientUV {\n  const cos = Math.cos(fill.angle);\n  const sin = Math.sin(fill.angle);\n  const dx0 = g[6] - fill.center.x;\n  const dy0 = g[7] - fill.center.y;\n  return {\n    ux: cos * g[0] + sin * g[1],\n    uy: cos * g[3] + sin * g[4],\n    u0: cos * dx0 + sin * dy0,\n    vx: cos * g[1] - sin * g[0],\n    vy: cos * g[4] - sin * g[3],\n    v0: cos * dy0 - sin * dx0,\n  };\n}\n\n/**\n * What a gradient's vertices carry once its row is known.\n *\n * A linear gradient's `a_uv` is (ramp position, row) and its `a_post` is the\n * plain 1, because that is what the plain paint mode already samples. A radial\n * or conic one needs both `a_uv` channels for its coordinate, so its row goes\n * in `a_post` — which no gradient uses for alpha, its opacity riding the vertex\n * color instead.\n */\nexport function rampVertices(\n  paint: Extract<BatchPaint, { kind: 'ramp' }>, rowV: number,\n): { uv: GradientUV; post: number } {\n  return paint.mode === PAINT_MODE_PLAIN\n    ? { uv: { ...paint.uv, v0: rowV }, post: 1 }\n    : { uv: paint.uv, post: rowV };\n}\n\n/**\n * Screen→gradient-space matrix for `u_worldInv`, which the vertex shader\n * applies to each fragment's screen position to recover the coordinates the\n * gradient's geometry is expressed in.\n *\n * `'world'` silently degrades to screen space when no view matrix reached\n * the renderer — `render(commands)` without a view is a supported call, and\n * a missing view is not worth a thrown frame. `null` when the space has no\n * inverse; a paint measured in it draws nothing.\n */\nexport function gradientSpaceInverse(ctx: DrawContext, units: GradientUnits | undefined): GlMat3 | null {\n  if (units === 'local') return mat3.invert(ctx.state.transform);\n  if (units === 'world' && ctx.viewMatrix) return mat3.invert(ctx.viewMatrix);\n  return mat3.identity();\n}\n\n/** The paint space `units` names → device pixels: the forward transform\n *  `gradientSpaceInverse` undoes, scaled by the target's pixel ratio. */\nexport function spaceToDevice(ctx: DrawContext, units: GradientUnits | undefined): GlMat3 | null {\n  const inverse = gradientSpaceInverse(ctx, units);\n  const toScreen = inverse && mat3.invert(inverse);\n  if (!toScreen) return null;\n  const ratio = ctx.deviceWidth && ctx.widthCss > 0 ? ctx.deviceWidth / ctx.widthCss : 1;\n  return mat3.multiply(mat3.scaled(mat3.identity(), ratio, ratio), toScreen);\n}\n"],"mappings":"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"}

package/dist/renderer/draw/image.js

@@ -1,38 +0,0 @@
-import { flushBatch as e } from "./flushBatch.js";
-import { enterUncut as t, leaveUncut as n, retryUncut as r } from "./clip.js";
-import { stageImage as i } from "./batch.js";
-import { SPRITE_STRIDE as a } from "../DrawCommand.js";
-//#region src/renderer/draw/image.ts
-function o(e, t) {
-	e.imageCache.upload(t.image, t.image);
-	let { staged: n, slot: a } = i(e, t.image, t.sampling ?? "linear"), s = t.source, c = 0, l = 0, u = 1, d = 1;
-	if (s) {
-		let e = t.image.width, n = t.image.height;
-		c = s.x / e, u = (s.x + s.w) / e, l = s.y / n, d = (s.y + s.h) / n;
-	}
-	if (t.flipX) {
-		let e = c;
-		c = u, u = e;
-	}
-	if (t.flipY) {
-		let e = l;
-		l = d, d = e;
-	}
-	e.drawBatch.pushQuad(t.x, t.y, t.w, t.h, e.state.transform, c, l, u, d, (t.opacity ?? 1) * (n.foldsAlpha ? e.state.alpha : 1), a) || r(e, t, void 0, o);
-}
-function s(r, o) {
-	let s = o.sprites, c = Math.floor(s.length / a);
-	if (c === 0) return;
-	r.imageCache.upload(o.image, o.image);
-	let l = o.sampling ?? "linear", { staged: u, slot: d } = i(r, o.image, l), f = r.drawBatch, p = r.state.transform, m = u.foldsAlpha ? r.state.alpha : 1, h = o.image.width, g = o.image.height;
-	for (let _ = 0, v = 0; _ < c; _++, v += a) {
-		f.wouldOverflow(4) && (e(r), {staged: u, slot: d} = i(r, o.image, l), m = u.foldsAlpha ? r.state.alpha : 1);
-		let a = s[v + 4], c = s[v + 5], _ = s[v + 6], y = s[v + 7], b;
-		for (; !f.pushQuad(s[v], s[v + 1], s[v + 2], s[v + 3], p, a / h, c / g, (a + _) / h, (c + y) / g, s[v + 8] * m, d);) b = t(r), {staged: u, slot: d} = i(r, o.image, l), m = u.foldsAlpha ? r.state.alpha : 1;
-		b !== void 0 && (n(r, b), {staged: u, slot: d} = i(r, o.image, l), m = u.foldsAlpha ? r.state.alpha : 1);
-	}
-}
-//#endregion
-export { o as drawImage, s as drawSprites };
-
-//# sourceMappingURL=image.js.map

package/dist/renderer/draw/image.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"image.js","names":["drawImage","cmd","stageImage","ctx","src","u0","v0","u1","v1","tw","th","t","staged","slot","retryUncut","drawSprites","data","count","SPRITE_STRIDE","sampling","batch","m","groupAlpha","s","i","flushBatch","sx","sy","sw","sh","cut","enterUncut","leaveUncut"],"sources":["../../../src/renderer/draw/image.ts"],"sourcesContent":["import { type ImageDrawCommand, type SpritesDrawCommand, SPRITE_STRIDE } from '../DrawCommand';\nimport type { ClipRect } from '../batchClip';\nimport type { DrawContext } from './drawContext';\nimport { enterUncut, leaveUncut, retryUncut } from './clip';\nimport { flushBatch } from './flushBatch';\nimport { stageImage } from './batch';\n\n/**\n * Stage one image quad. Nothing reaches the GPU here — `flushBatch` draws the\n * run this joins.\n *\n * The upload has to happen now rather than at flush: a run is keyed on bitmap\n * identity, and `flushBatch` binds a texture it assumes already exists.\n */\nexport function drawImage(ctx: DrawContext, cmd: ImageDrawCommand): void {\n  ctx.imageCache.upload(cmd.image, cmd.image);\n  const { staged, slot } = stageImage(ctx, cmd.image, cmd.sampling ?? 'linear');\n\n  // Sampling window: the whole bitmap unless `source` narrows it, with the\n  // flips applied by swapping the ends rather than moving the quad.\n  const src = cmd.source;\n  let u0 = 0, v0 = 0, u1 = 1, v1 = 1;\n  if (src) {\n    const tw = cmd.image.width, th = cmd.image.height;\n    u0 = src.x / tw; u1 = (src.x + src.w) / tw;\n    v0 = src.y / th; v1 = (src.y + src.h) / th;\n  }\n  if (cmd.flipX) { const t = u0; u0 = u1; u1 = t; }\n  if (cmd.flipY) { const t = v0; v0 = v1; v1 = t; }\n\n  if (!ctx.drawBatch.pushQuad(\n    cmd.x, cmd.y, cmd.w, cmd.h, ctx.state.transform,\n    u0, v0, u1, v1,\n    // Group alpha rides the vertices only where it rode the solid colors too:\n    // with a real color matrix in the run it is `u_alpha`, and folding it here\n    // as well would apply it twice.\n    (cmd.opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1),\n    slot,\n  )) retryUncut(ctx, cmd, undefined, drawImage);\n}\n\n/**\n * Stage a packed run of sprites. The same staging `drawImage` does, minus a\n * command object per quad — see `SpritesDrawCommand`.\n *\n * The run is opened once and reopened only when the per-flush cap forces a\n * chunk, so the state check that costs a command its own run happens twice in\n * a frame rather than twenty thousand times.\n */\nexport function drawSprites(ctx: DrawContext, cmd: SpritesDrawCommand): void {\n  const data = cmd.sprites;\n  const count = Math.floor(data.length / SPRITE_STRIDE);\n  if (count === 0) return;\n\n  ctx.imageCache.upload(cmd.image, cmd.image);\n  const sampling = cmd.sampling ?? 'linear';\n  let { staged, slot } = stageImage(ctx, cmd.image, sampling);\n\n  const batch = ctx.drawBatch;\n  const m = ctx.state.transform;\n  let groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n  const tw = cmd.image.width;\n  const th = cmd.image.height;\n\n  for (let s = 0, i = 0; s < count; s++, i += SPRITE_STRIDE) {\n    if (batch.wouldOverflow(4)) {\n      flushBatch(ctx);\n      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));\n      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n    }\n    const sx = data[i + 4], sy = data[i + 5], sw = data[i + 6], sh = data[i + 7];\n    let cut: ClipRect | null | undefined;\n    while (!batch.pushQuad(\n      data[i], data[i + 1], data[i + 2], data[i + 3], m,\n      sx / tw, sy / th, (sx + sw) / tw, (sy + sh) / th,\n      data[i + 8] * groupAlpha, slot,\n    )) {\n      cut = enterUncut(ctx);\n      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));\n      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n    }\n    if (cut !== undefined) {\n      leaveUncut(ctx, cut);\n      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));\n      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n    }\n  }\n}\n"],"mappings":";;;;;AAcA,SAAgBA,EAAU,GAAkB,GAA6B;CACvE,EAAI,WAAW,OAAOC,EAAI,OAAOA,EAAI,KAAK;CAC1C,IAAM,EAAE,WAAQ,YAASC,EAAWC,GAAKF,EAAI,OAAOA,EAAI,YAAY,QAAQ,GAItEG,IAAMH,EAAI,QACZI,IAAK,GAAGC,IAAK,GAAGC,IAAK,GAAGC,IAAK;CACjC,IAAIJ,GAAK;EACP,IAAMK,IAAKR,EAAI,MAAM,OAAOS,IAAKT,EAAI,MAAM;EAE1B,AADjB,IAAKG,EAAI,IAAIK,GAAI,KAAML,EAAI,IAAIA,EAAI,KAAKK,GACxC,IAAKL,EAAI,IAAIM,GAAI,KAAMN,EAAI,IAAIA,EAAI,KAAKM;CAC1C;CACA,IAAIT,EAAI,OAAO;EAAE,IAAMU,IAAIN;EAAa,AAAT,IAAKE,GAAI,IAAKI;CAAG;CAChD,IAAIV,EAAI,OAAO;EAAE,IAAMU,IAAIL;EAAa,AAAT,IAAKE,GAAI,IAAKG;CAAG;CAEhD,AAAKR,EAAI,UAAU,SACjBF,EAAI,GAAGA,EAAI,GAAGA,EAAI,GAAGA,EAAI,GAAGE,EAAI,MAAM,WACtCE,GAAIC,GAAIC,GAAIC,IAIXP,EAAI,WAAW,MAAMW,EAAO,aAAaT,EAAI,MAAM,QAAQ,IAC5DU,CACF,KAAGC,EAAWX,GAAKF,GAAK,KAAA,GAAWD,CAAS;AAC9C;AAUA,SAAgBe,EAAY,GAAkB,GAA+B;CAC3E,IAAMC,IAAOf,EAAI,SACXgB,IAAQ,KAAK,MAAMD,EAAK,SAASE,CAAa;CACpD,IAAID,MAAU,GAAG;CAEjB,EAAI,WAAW,OAAOhB,EAAI,OAAOA,EAAI,KAAK;CAC1C,IAAMkB,IAAWlB,EAAI,YAAY,UAC7B,EAAE,WAAQ,YAASC,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GAEpDC,IAAQjB,EAAI,WACZkB,IAAIlB,EAAI,MAAM,WAChBmB,IAAaV,EAAO,aAAaT,EAAI,MAAM,QAAQ,GACjDM,IAAKR,EAAI,MAAM,OACfS,IAAKT,EAAI,MAAM;CAErB,KAAK,IAAIsB,IAAI,GAAGC,IAAI,GAAGD,IAAIN,GAAO,KAAK,KAAKC,GAAe;EACzD,AAAIE,EAAM,cAAc,CAAC,MACvBK,EAAWtB,CAAG,GACb,uBAAmBD,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GACvD,IAAaP,EAAO,aAAaT,EAAI,MAAM,QAAQ;EAErD,IAAMuB,IAAKV,EAAKQ,IAAI,IAAIG,IAAKX,EAAKQ,IAAI,IAAII,IAAKZ,EAAKQ,IAAI,IAAIK,IAAKb,EAAKQ,IAAI,IACtEM;EACJ,OAAO,CAACV,EAAM,SACZJ,EAAKQ,IAAIR,EAAKQ,IAAI,IAAIR,EAAKQ,IAAI,IAAIR,EAAKQ,IAAI,IAAIH,GAChDK,IAAKjB,GAAIkB,IAAKjB,IAAKgB,IAAKE,KAAMnB,IAAKkB,IAAKE,KAAMnB,GAC9CM,EAAKQ,IAAI,KAAKF,GAAYT,CAC5B,IAGE,AAFA,IAAMkB,EAAW5B,CAAG,GACnB,uBAAmBD,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GACvD,IAAaP,EAAO,aAAaT,EAAI,MAAM,QAAQ;EAErD,AAAI2B,MAAQ,KAAA,MACVE,EAAW7B,GAAK2B,CAAG,GAClB,uBAAmB5B,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GACvD,IAAaP,EAAO,aAAaT,EAAI,MAAM,QAAQ;CAEvD;AACF"}

package/dist/renderer/draw/mesh.js

@@ -1,16 +0,0 @@
-import { getMesh as e } from "../cache/cache.js";
-import { tessellate as t } from "@weasel-js/geom/tessellate";
-//#region src/renderer/draw/mesh.ts
-function n(n, r) {
-	return n.flattenTolerance === void 0 ? e(r) : t(r, { flattenTolerance: n.flattenTolerance });
-}
-function r(e, t) {
-	return e.flattenTolerance === void 0 ? e.meshCache.handleFor(t) : e.meshCache.uploadTransient(t);
-}
-function i(e, t) {
-	return r(e, n(e, t));
-}
-//#endregion
-export { n as fillMesh, i as fillMeshHandle, r as meshHandle };
-
-//# sourceMappingURL=mesh.js.map

package/dist/renderer/draw/mesh.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mesh.js","names":["fillMesh","ctx","getMesh","path","tessellate","meshHandle","mesh","fillMeshHandle"],"sources":["../../../src/renderer/draw/mesh.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport type { GLMeshHandle } from '../cache/GLMeshCache';\nimport { getMesh } from '../cache/cache';\nimport { tessellate, type Mesh } from '@weasel-js/geom/tessellate';\nimport type { DrawContext } from './drawContext';\n\n/**\n * Tessellate a fill honoring ctx.flattenTolerance: default route is the\n * persistent Path-identity cache; a custom tolerance tessellates fresh, because\n * the persistent cache's key does not include tolerance.\n */\nexport function fillMesh(ctx: DrawContext, path: Path): Mesh {\n  if (ctx.flattenTolerance !== undefined) {\n    return tessellate(path, { flattenTolerance: ctx.flattenTolerance });\n  }\n  return getMesh(path);\n}\n\n/** Upload a mesh for its own draw. A freshly tessellated one rides the\n *  transient pool, freed at end of frame. */\nexport function meshHandle(ctx: DrawContext, mesh: Mesh): GLMeshHandle {\n  if (ctx.flattenTolerance !== undefined) return ctx.meshCache.uploadTransient(mesh);\n  return ctx.meshCache.handleFor(mesh);\n}\n\nexport function fillMeshHandle(ctx: DrawContext, path: Path): GLMeshHandle {\n  return meshHandle(ctx, fillMesh(ctx, path));\n}\n"],"mappings":";;;AAWA,SAAgBA,EAAS,GAAkB,GAAkB;CAI3D,OAHIC,EAAI,qBAAqB,KAAA,IAGtBC,EAAQC,CAAI,IAFVC,EAAWD,GAAM,EAAE,kBAAkBF,EAAI,iBAAiB,CAAC;AAGtE;AAIA,SAAgBI,EAAW,GAAkB,GAA0B;CAErE,OADIJ,EAAI,qBAAqB,KAAA,IACtBA,EAAI,UAAU,UAAUK,CAAI,IADYL,EAAI,UAAU,gBAAgBK,CAAI;AAEnF;AAEA,SAAgBC,EAAe,GAAkB,GAA0B;CACzE,OAAOF,EAAWJ,GAAKD,EAASC,GAAKE,CAAI,CAAC;AAC5C"}