@weasel-js/core 1.7.0 → 1.7.1

package/dist/registerProgram-ateHDGjw.d.ts

@@ -0,0 +1,193 @@
+import { Mat3 } from '@weasel-js/geom';
+import { Reflection } from '@weasel-js/registry';
+import { TextureHandle } from '@weasel-js/paint';
+
+/**
+ * 2D affine matrix utilities. Column-major 9-element Float32Array, matching
+ * `WebGL2RenderingContext.uniformMatrix3fv` byte order so we can pass the
+ * array directly without a transpose flag.
+ *
+ * Layout (column-major):
+ *   [m00, m10, 0,
+ *    m01, m11, 0,
+ *    tx,  ty,  1]
+ *
+ * `apply(m, x, y)` returns `[m * (x, y, 1)] = [m00*x + m01*y + tx,
+ *                                              m10*x + m11*y + ty]`.
+ */
+
+/** A 2D affine transform as a column-major 9-element `Float32Array`, laid out as above. */
+type GlMat3 = Float32Array;
+declare function identity(): GlMat3;
+declare function multiply(out: GlMat3, m: GlMat3): GlMat3;
+/** `m · T(tx, ty)`: composes onto `m`, where `@weasel-js/geom`'s `translate`
+ *  constructs a fresh matrix. */
+declare function translated(m: GlMat3, tx: number, ty: number): GlMat3;
+/** `m · S(sx, sy)`: composes onto `m`, where geom's `scale` constructs one. */
+declare function scaled(m: GlMat3, sx: number, sy: number): GlMat3;
+/** This layout read as the kernel's 6-element affine. The two carry the same
+ *  logical order, so the conversion is a repack and nothing else — it exists
+ *  so the repack has a name instead of appearing inline at each crossing. */
+declare function toAffine(m: GlMat3): Mat3;
+/** The kernel's affine in this layout. The inverse of {@link toAffine}, and
+ *  what an `SvgGroupNode.transform` (also a kernel affine) becomes on its way
+ *  to a `GroupDrawCommand`. */
+declare function fromAffine(a: Mat3): GlMat3;
+/** Inverse of an affine matrix, or `null` when `@weasel-js/geom`'s `invert`
+ *  finds it singular — the same rule, read through this layout. */
+declare function invert(m: GlMat3): GlMat3 | null;
+declare function apply(m: GlMat3, x: number, y: number): [number, number];
+/**
+ * Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)
+ * into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down
+ * matches clip-down).
+ */
+declare function screenToClip(width: number, height: number): GlMat3;
+/**
+ * Uniform-equivalent scale factor: the square root of the absolute
+ * determinant of the linear part, i.e. the geometric mean of the two axis
+ * scales. Rotation-invariant. Under non-uniform scale it is between the two
+ * axes and exact on neither — the same compromise `meanScale` documents.
+ */
+declare function meanScaleOf(m: GlMat3): number;
+/** The renderer's 3x3 matrix operations, as one namespace. These work on the
+ *  9-element `Float32Array` form the GL uniform upload wants — distinct from
+ *  `@weasel-js/geom`'s 6-element affine `GlMat3`, though the logical element
+ *  order is the same. */
+declare const mat3: {
+    identity: typeof identity;
+    toAffine: typeof toAffine;
+    fromAffine: typeof fromAffine;
+    multiply: typeof multiply;
+    translated: typeof translated;
+    scaled: typeof scaled;
+    invert: typeof invert;
+    apply: typeof apply;
+    screenToClip: typeof screenToClip;
+    meanScaleOf: typeof meanScaleOf;
+};
+
+/**
+ * Minimal compile/link/lookup wrapper for a GL program. Throws
+ * `ShaderCompileError` on compile or link failure with the GL info log
+ * embedded in the error message — never returns a half-initialized program.
+ *
+ * Designed so test code can stub `getShaderParameter` / `getProgramParameter`
+ * via the recorder Proxy without further special-casing.
+ */
+type Stage = 'vertex' | 'fragment' | 'link';
+/** Thrown when a shader fails to compile or link, carrying which stage failed
+ *  and the driver's log. */
+declare class ShaderCompileError extends Error {
+    readonly stage: Stage;
+    readonly log: string;
+    constructor(stage: Stage, log: string);
+}
+/** An array uniform a program can be written as a whole: its element type as
+ *  declared, its declared length, and the location of slot 0. */
+interface UniformArray {
+    readonly type: string;
+    readonly size: number;
+    readonly location: WebGLUniformLocation;
+}
+/** A linked GL program with its uniform and attribute locations cached by name. */
+declare class ShaderProgram {
+    private readonly gl;
+    readonly handle: WebGLProgram;
+    private readonly uniforms;
+    private readonly arrays;
+    private readonly attributes;
+    constructor(gl: WebGL2RenderingContext, vertSrc: string, fragSrc: string);
+    private compile;
+    lookupUniforms(names: readonly string[]): void;
+    /** Record each array's slot-0 location under its bare name. An array the
+     *  driver optimized away has no location and is left out. */
+    lookupUniformArrays(decls: ReadonlyMap<string, {
+        type: string;
+        size: number;
+    }>): void;
+    lookupAttributes(names: readonly string[]): void;
+    uniform(name: string): WebGLUniformLocation | undefined;
+    uniformArray(name: string): UniformArray | undefined;
+    attribute(name: string): number | undefined;
+}
+
+/**
+ * registerProgram — public API for registering custom shader programs.
+ *
+ * Stores raw GLSL source strings in a module-level registry. GL compilation
+ * happens on each WeaselRenderer via WeaselRenderer.registerProgram(), which
+ * calls getProgramSource() and compiles the result. This keeps registerProgram
+ * GL-context-agnostic — identical pattern to registerFont storing ImageBitmap.
+ *
+ * Module-level state = source strings only; compiled GL
+ * programs live on each renderer's programRegistry (Map<id, ShaderProgram>).
+ *
+ * Lifecycle: program sources live for the module lifetime. No unregister in v1.
+ */
+
+/** Opaque handle to a compiled custom shader program. */
+interface ShaderProgramHandle {
+    readonly id: string;
+}
+/**
+ * A value for one uniform in `ShaderDrawCommand.uniforms`.
+ *
+ * | TS type                 | GL call                              |
+ * |-------------------------|--------------------------------------|
+ * | number                  | uniform1f                            |
+ * | [n, n]                  | uniform2fv                           |
+ * | [n, n, n]               | uniform3fv                           |
+ * | [n, n, n, n]            | uniform4fv                           |
+ * | Float32Array length 9   | uniformMatrix3fv (column-major)      |
+ * | Float32Array length 16  | uniformMatrix4fv (column-major)      |
+ * | TextureHandle           | bind to next tex unit + uniform1i    |
+ *
+ * **Array uniforms.** Keyed by an array's bare name (`u_ripples` for
+ * `uniform vec3 u_ripples[8]`), a flat `number[]`, `Float32Array`,
+ * `Int32Array` or `Uint32Array` fills the array from slot 0 in one
+ * `uniform*v` call chosen by the declared element type (`vec3` →
+ * `uniform3fv`, `ivec2` → `uniform2iv`, `mat4` → `uniformMatrix4fv`, …).
+ * Its length must be a whole number of elements and at most the declared
+ * size; a shorter value leaves the remaining slots as they were. Per-slot
+ * keys (`u_ripples[2]`) keep working and take the table above.
+ */
+type ShaderUniform = number | [number, number] | [number, number, number] | [number, number, number, number] | readonly number[] | Float32Array | Int32Array | Uint32Array | TextureHandle;
+/** A registered program's GLSL source. An empty `vert` means the kit's default vertex shader. */
+interface ProgramSource {
+    vert: string;
+    frag: string;
+}
+/** Every registered program's GLSL source, keyed by program id. */
+declare const programSourceRegistry: Reflection<ProgramSource>;
+/**
+ * Register a custom shader program by id.
+ *
+ * Pass an empty string for `vert` to use the kit's default vertex shader
+ * (recommended). The kit's vertex shader exposes `v_uv`, `v_screen`, and
+ * `v_world` varyings plus `u_bounds` and `u_view` uniforms.
+ *
+ * **IMPORTANT — Premultiplied alpha:**
+ * Your fragment shader MUST output premultiplied alpha:
+ *   `outColor = vec4(rgb * a, a);`  ← correct
+ *   `outColor = vec4(rgb, a);`      ← WRONG — over-brightens translucent regions
+ *
+ * The renderer uses `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)` to match.
+ * Opaque fragments (a=1) are unaffected; only fragments with a < 1 differ.
+ *
+ * **Re-registration behavior:**
+ * - Dev mode (`NODE_ENV !== 'production'`): calling with an existing id and new
+ *   source replaces it (hot reload). Every renderer that compiled the old source
+ *   recompiles on its next frame and deletes the program it replaces; a
+ *   `<Canvas shaders>` naming the id repaints to show it. If the new source fails
+ *   to compile, the renderer logs the error once and keeps drawing the old one.
+ * - Prod mode: calling with an existing id throws.
+ *
+ * Actual GL compilation and `ShaderCompileError` throwing happen in
+ * `WeaselRenderer.registerProgram()`, not here.
+ *
+ * @experimental API may break before v2.
+ */
+declare function registerProgram(id: string, vert: string, frag: string): ShaderProgramHandle;
+
+export { type GlMat3 as G, type ProgramSource as P, ShaderCompileError as S, type ShaderProgramHandle as a, type ShaderUniform as b, ShaderProgram as c, mat3 as m, programSourceRegistry as p, registerProgram as r };

package/dist/renderer/DrawCommand.js

@@ -0,0 +1,6 @@
+//#region src/renderer/DrawCommand.ts
+var e = 9;
+//#endregion
+export { e as SPRITE_STRIDE };
+
+//# sourceMappingURL=DrawCommand.js.map

package/dist/renderer/DrawCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrawCommand.js","names":["SPRITE_STRIDE"],"sources":["../../src/renderer/DrawCommand.ts"],"sourcesContent":["// Import the source types directly, NOT through the `@weasel-js/core` self-barrel.\n// `src/index.ts` reexports `renderer/index.ts`, which reexports this module — so a\n// barrel import here forms a DrawCommand.ts → index.ts → renderer/index.ts → DrawCommand.ts\n// cycle that makes the dts bundler split them into mutually-dependent chunks and warn.\nimport type { Path } from '@weasel-js/geom';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport type { TextStyle } from '@weasel-js/text';\nimport type { ResolvedRun } from '@weasel-js/text';\nimport type { TextVerticalAlign } from '@weasel-js/text';\nimport type { GlMat3 } from './math/mat3';\nimport type { ShaderProgramHandle, ShaderUniform } from './shaders/registerProgram';\nimport type { Effect } from './effects/types';\n\n/**\n * Solid-fill paint variant (subset of the full `FillStyle` union from\n * `@weasel-js/core`). Kept for back-compat with step-1/2 consumers and\n * because some code reads `fill.color` directly. Through step 4, fills can\n * be any `FillStyle` variant — solid, pattern, or gradient.\n */\nexport interface SolidPaint {\n  fill?: 'solid';\n  /** Any CSS color string accepted by `parseColor`: hex, `rgb()`/`rgba()`, `hsl()`/`hsla()`, named, or `transparent`. */\n  color: string;\n  opacity?: number;\n}\n\n/** DrawCommand variants implemented through step 6. */\nexport type DrawCommand =\n  | PathDrawCommand\n  | GroupDrawCommand\n  | TextDrawCommand\n  | ImageDrawCommand\n  | SpritesDrawCommand\n  | ShaderDrawCommand;\n\n/** Draw a path, filled and/or stroked. The workhorse command: every shape the\n *  kit draws that is not text, an image, or a custom shader is one of these. */\nexport interface PathDrawCommand {\n  kind: 'path';\n  path: Path;\n  /** Any `FillStyle` variant: solid, pattern, or gradient (linear/radial/conic). */\n  fill?: FillStyle;\n  /** Stroke spec. Only solid `paint` supported through step 4. */\n  stroke?: Stroke;\n  /**\n   * Optional flat RGBA-per-path-anchor color array (length =\n   * `4 × countPathAnchors(path)`, floats in 0..1). The renderer\n   * arc-length-interpolates these per-anchor colors across the\n   * flattened/triangulated mesh between consecutive anchors using the\n   * mesh's `anchorA` / `anchorB` / `anchorT` parameterization.\n   *\n   * **`fill` must also be set when using `vertexColors`.** The renderer\n   * only enters the per-vertex shader path when the command has a fill\n   * (the fill provides the opacity uniform; the vertex colors override\n   * the fill's color). Pass any solid `fill` (e.g. `{ color: '#fff' }`)\n   * as the placeholder; the per-vertex colors win in the shader.\n   */\n  vertexColors?: number[];\n}\n\n/** Draw a list of commands under a shared transform, opacity, color matrix\n *  and clip. Groups nest, and their effects accumulate down the stack — this\n *  is how a container node's transform reaches its descendants. */\nexport interface GroupDrawCommand {\n  kind: 'group';\n  transform?: GlMat3;\n  alpha?: number;\n  /**\n   * Optional 4×5 color matrix (row-major, 20 numbers) — `out = M₄ₓ₄ * in + bias`.\n   * Accumulated multiplicatively down the group stack. Defaults to identity.\n   */\n  colorMatrix?: number[];\n  /** Optional clip path. When set, the renderer rasterizes this path into\n   *  the stencil buffer before drawing `children`; the children paint only\n   *  where the clip covers. Nested groups with clips intersect — a child\n   *  cannot escape an ancestor's clip. Max 7 nesting levels; the renderer\n   *  throws if exceeded. */\n  clip?: Path;\n  /**\n   * Full-screen passes run over this group's own pixels, in order, before it\n   * is composited into its parent.\n   *\n   * Unlike every other field here, this does not accumulate down the group\n   * stack — it is a render-target boundary. The children draw into a buffer of\n   * their own, each effect reads the previous one's output, and the result is\n   * composited back under this group's `transform`, `alpha`, `colorMatrix` and\n   * whatever clip encloses it. So a blur here blurs this group and nothing\n   * around it, which is what a CSS `filter` on the canvas cannot do.\n   *\n   * An empty or absent list costs nothing: no buffer is allocated until a\n   * group asks for one.\n   */\n  effects?: readonly Effect[];\n  children: DrawCommand[];\n}\n\n/**\n * Text draw command. Renders one or more runs at (`x`, `y`) in screen\n * space, optionally word-wrapping at `maxWidth`. The renderer resolves\n * each run's `(fontFamily, fontWeight, fontStyle)` to an MSDF atlas via\n * `resolveFontVariant` and bucket-draws by atlas + color group.\n *\n * `style` carries node-level defaults (`lineHeight`, anti-alias width)\n * that don't belong on individual runs.\n */\nexport interface TextDrawCommand {\n  kind: 'text';\n  x: number;\n  y: number;\n  runs: ResolvedRun[];\n  /** Wrap width. Absent never wraps. */\n  maxWidth?: number;\n  align?: 'left' | 'center' | 'right';\n  /** Spread each wrapped line across `width` — see `LayoutRunsOpts.justify`.\n   *  `align` then sets only the lines it does not spread. Default `false`. */\n  justify?: boolean;\n  /** Box width `align` resolves within, from `x`. Default `maxWidth`; with\n   *  neither, `x` is the line's left edge, midpoint or right edge. */\n  width?: number;\n  style: TextStyle;\n  /** Box height for vertical alignment. When set with `verticalAlign`,\n   *  the laid-out block shifts within `[y, y+height]`. */\n  height?: number;\n  /** Default 'top' — the legacy top-anchored behavior. */\n  verticalAlign?: TextVerticalAlign;\n}\n\n/**\n * Image draw command — renders `image` at screen-space rect (x, y, w, h).\n * The image is stretched to fit; no tiling. Use a pattern FillStyle on a path\n * for tiling.\n */\nexport interface ImageDrawCommand {\n  kind: 'image';\n  image: ImageBitmap;\n  x: number;\n  y: number;\n  w: number;\n  h: number;\n  opacity?: number;\n  /** Magnification filter. `'linear'` (default) smooths; `'nearest'` shows\n   *  device pixels as hard squares — required by anything magnifying a\n   *  framebuffer readback, where blur destroys the point of the readback. */\n  sampling?: 'linear' | 'nearest';\n  /** Sub-rectangle of `image` to draw, in bitmap pixels from the top-left.\n   *  Omitted draws the whole bitmap. Not range-checked: a rect past the edge\n   *  samples outside [0..1], which CLAMP_TO_EDGE smears. With\n   *  `sampling: 'linear'` the filter reaches half a texel beyond `source`, so\n   *  atlas frames need a gutter (see `SpriteSheet.spacing`) or `'nearest'`. */\n  source?: { x: number; y: number; w: number; h: number };\n  /** Mirror the sampled region within the destination rect. The quad does not\n   *  move — a flipped draw covers exactly the pixels an unflipped one does. */\n  flipX?: boolean;\n  flipY?: boolean;\n}\n\n/** Floats per sprite in `SpritesDrawCommand.sprites`. */\nexport const SPRITE_STRIDE = 9;\n\n/**\n * Draw many quads sampling one bitmap — an atlas, a sprite sheet, a wall of\n * thumbnails. The same picture as a run of `ImageDrawCommand`s the renderer\n * would coalesce anyway, handed over already packed so it never walks a\n * command object per quad.\n *\n * Reach for it past a few thousand sprites. Below that a plain run of image\n * commands merges into the same single draw and reads better; the packed form\n * exists because at 20,000 the object walk is about half the frame.\n *\n * The sprites are one run: they share a texture, a filter, and whatever group\n * transform, alpha, color matrix and clip are live, exactly as a merged run of\n * image commands would. Anything varying per sprite is in the array.\n */\nexport interface SpritesDrawCommand {\n  kind: 'sprites';\n  image: ImageBitmap;\n  /** Magnification filter for the whole run, as `ImageDrawCommand.sampling`. */\n  sampling?: 'linear' | 'nearest';\n  /**\n   * `SPRITE_STRIDE` floats per sprite:\n   * `dx, dy, dw, dh, sx, sy, sw, sh, opacity`.\n   *\n   * Destination is in the group's coordinates; source is in bitmap pixels,\n   * like `ImageDrawCommand.source`. A negative `sw` or `sh` mirrors that axis\n   * within the source rect, which is what `flipX` / `flipY` do. A trailing\n   * partial sprite is ignored.\n   */\n  sprites: Float32Array;\n}\n\n/**\n * Custom shader draw command. The renderer generates a quad over `bounds`\n * and dispatches the consumer's fragment shader with the kit's vertex prelude.\n *\n * `uniforms` keys must match names declared in the consumer's fragment shader.\n * The kit automatically sets `u_bounds`, `u_view`, and `u_proj` — do not\n * declare those in `uniforms`.\n *\n * @experimental API may change before v2.\n */\nexport interface ShaderDrawCommand {\n  kind: 'shader';\n  program: ShaderProgramHandle;\n  uniforms: Record<string, ShaderUniform>;\n  /** Screen-space bounding rect in CSS pixels. */\n  bounds: { x: number; y: number; w: number; h: number };\n}\n"],"mappings":";AA6JA,IAAaA,IAAgB"}

package/dist/renderer/WeaselRenderer.js

@@ -0,0 +1,328 @@
+import { createPaintResources as e } from "./paintResources.js";
+import { ShaderProgram as t } from "./shaders/ShaderProgram.js";
+import { FRAG_SRC as n, PATH_FILL_ATTRIBUTES as r, PATH_FILL_UNIFORMS as i, PATH_FILL_VCOLOR_ATTRIBUTES as a, VCOLOR_FRAG_SRC as o, VCOLOR_VERT_SRC as s, VERT_SRC as c } from "./shaders/pathFill.js";
+import { IMAGE_FILL_ATTRIBUTES as l, IMAGE_FILL_UNIFORMS as u, IMAGE_FRAG_SRC as d, IMAGE_VERT_SRC as f } from "./shaders/imageFill.js";
+import { BATCH_FILL_ATTRIBUTES as p, BATCH_FILL_UNIFORMS as m, BATCH_FRAG_SRC as h, BATCH_VERT_SRC as g } from "./shaders/batchFill.js";
+import { GRAD_FILL_ATTRIBUTES as _, GRAD_FILL_UNIFORMS as v, GRAD_FRAG_SRC as y, GRAD_VERT_SRC as b } from "./shaders/gradFill.js";
+import { PATTERN_FILL_ATTRIBUTES as x, PATTERN_FILL_UNIFORMS as S, PATTERN_FRAG_SRC as C, PATTERN_VERT_SRC as w } from "./shaders/patternFill.js";
+import { GLYPH_GRAD_FRAG_SRC as T, GLYPH_GRAD_UNIFORMS as E, GLYPH_PAINT_ATTRIBUTES as D, GLYPH_PAINT_VERT_SRC as O, GLYPH_PATTERN_FRAG_SRC as k, GLYPH_PATTERN_UNIFORMS as A, GLYPH_TEXTURE_FRAG_SRC as j, GLYPH_TEXTURE_UNIFORMS as ee } from "./shaders/glyphPaint.js";
+import { PaintScratch as te } from "./paintScratch.js";
+import { GLMeshCache as M } from "./cache/GLMeshCache.js";
+import { GLTextureCache as N } from "./cache/GLTextureCache.js";
+import { GLImageCache as P } from "./cache/GLImageCache.js";
+import { GradientRampAtlas as F } from "./cache/GradientRampAtlas.js";
+import { GroupState as I } from "./state/GroupState.js";
+import { getProgramSource as L } from "./shaders/registerProgram.js";
+import { DrawBatch as R } from "./drawBatch.js";
+import { OUTLINE_MIN_SCREEN_PX as ne, dispatch as z, flushBatch as B } from "./draw.js";
+import { CUSTOM_ATTRIBUTES as V, CUSTOM_KIT_UNIFORMS as H, CUSTOM_VERT_SRC as U, QUAD_INDICES as W, QUAD_VERTICES as G } from "./shaders/customPrelude.js";
+import { EffectTargets as K } from "./effects/EffectTargets.js";
+import { extractUniformArrays as q, extractUniformNames as J } from "./shaders/extractUniformNames.js";
+import { DEFAULT_BAKE_BUDGET as Y, markAllFontsNotUploaded as X, resetBakeBudget as re } from "@weasel-js/font";
+//#region src/renderer/WeaselRenderer.ts
+function ie(e, t) {
+	return [
+		...H,
+		...J(e),
+		...J(t)
+	];
+}
+function Z(e, n) {
+	let r = n.vert === "" ? U : n.vert, i = new t(e, r, n.frag);
+	return i.lookupUniforms(ie(r, n.frag)), i.lookupUniformArrays(new Map([...q(r), ...q(n.frag)])), i.lookupAttributes(V), i;
+}
+function Q() {
+	return typeof performance < "u" ? performance.now() : Date.now();
+}
+var ae = {
+	pattern: [k, A],
+	gradient: [T, E],
+	texture: [j, ee]
+}, oe = class {
+	gl;
+	stats = {
+		drawCalls: 0,
+		ms: 0,
+		spans: []
+	};
+	pathFill;
+	pathFillVColor;
+	imageFill;
+	batchFill;
+	gradFill;
+	patternFill;
+	glyphPaintPrograms = /* @__PURE__ */ new Map();
+	meshCache;
+	textureCache;
+	imageCache;
+	gradRamps;
+	programRegistry = /* @__PURE__ */ new Map();
+	programSources = /* @__PURE__ */ new Map();
+	quadVbo = null;
+	quadIbo = null;
+	drawBatch;
+	whiteTexture = null;
+	groupState = new I();
+	widthCss;
+	heightCss;
+	dpr;
+	canvas = null;
+	target = null;
+	effectTargets;
+	paintScratch;
+	imageMinification;
+	flattenTolerance;
+	bakeBudget;
+	textOutlineMinScreenSize;
+	contextLost = !1;
+	boundOnLost = (e) => this.onContextLost(e);
+	boundOnRestored = () => this.onContextRestored();
+	disposed = !1;
+	paintResources = e();
+	constructor(e) {
+		if (!e.gl && !e.canvas) throw Error("WeaselRenderer requires either gl or canvas");
+		let T = e.gl ?? e.canvas.getContext("webgl2", { stencil: !0 });
+		if (!T) throw Error("WeaselRenderer: WebGL2 not available");
+		this.gl = T, this.effectTargets = new K(this.gl), this.paintScratch = new te(this.gl);
+		let E = typeof this.gl.getContextAttributes == "function" ? this.gl.getContextAttributes() : null;
+		if (E && E.stencil === !1) throw Error("WeaselRenderer: the supplied WebGL2 context has no stencil buffer. Create it with { stencil: true } — clips and even-odd fills need one.");
+		this.widthCss = e.width, this.heightCss = e.height, this.dpr = e.dpr, this.imageMinification = e.imageMinification ?? "linear", this.flattenTolerance = e.flattenTolerance, this.bakeBudget = e.bakeBudget ?? Y, this.textOutlineMinScreenSize = e.textOutlineMinScreenSize ?? ne, this.canvas = e.canvas ?? null, this.canvas && (this.canvas.width = Math.round(e.width * e.dpr), this.canvas.height = Math.round(e.height * e.dpr), this.canvas.style && (this.canvas.style.width = `${e.width}px`, this.canvas.style.height = `${e.height}px`), this.canvas.addEventListener("webglcontextlost", this.boundOnLost), this.canvas.addEventListener("webglcontextrestored", this.boundOnRestored)), this.applyGlState(), this.applyTarget(), this.pathFill = new t(this.gl, c, n), this.pathFill.lookupUniforms(i), this.pathFill.lookupAttributes(r), this.pathFillVColor = new t(this.gl, s, o), this.pathFillVColor.lookupUniforms(i), this.pathFillVColor.lookupAttributes(a), this.imageFill = new t(this.gl, f, d), this.imageFill.lookupUniforms(u), this.imageFill.lookupAttributes(l), this.batchFill = new t(this.gl, g, h), this.batchFill.lookupUniforms(m), this.batchFill.lookupAttributes(p), this.gradFill = new t(this.gl, b, y), this.gradFill.lookupUniforms(v), this.gradFill.lookupAttributes(_), this.patternFill = new t(this.gl, w, C), this.patternFill.lookupUniforms(S), this.patternFill.lookupAttributes(x);
+		let D = this.pathFill.attribute("a_position");
+		if (D === void 0) throw Error("WeaselRenderer: a_position not found in path-fill shader");
+		this.meshCache = new M(this.gl, D), this.textureCache = new N(this.gl), this.imageCache = new P(this.gl, this.imageMinification), this.gradRamps = new F(this.gl), this.uploadQuadGeometry(), this.drawBatch = new R(this.gl, this.batchFill), this.whiteTexture = $(this.gl);
+	}
+	uploadQuadGeometry() {
+		let e = this.gl;
+		if (this.quadVbo = e.createBuffer(), this.quadIbo = e.createBuffer(), !this.quadVbo || !this.quadIbo) throw Error("WeaselRenderer: failed to create quad geometry buffers");
+		e.bindBuffer(e.ARRAY_BUFFER, this.quadVbo), e.bufferData(e.ARRAY_BUFFER, G, e.STATIC_DRAW), e.bindBuffer(e.ARRAY_BUFFER, null), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.quadIbo), e.bufferData(e.ELEMENT_ARRAY_BUFFER, W, e.STATIC_DRAW), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, null);
+	}
+	registerProgram(e) {
+		if (this.disposed) return;
+		let t = L(e.id);
+		if (!t) throw Error(`WeaselRenderer.registerProgram: program "${e.id}" not found in source registry. Call the module-level registerProgram() first.`);
+		this.installProgram(e.id, t, Z(this.gl, t));
+	}
+	installProgram(e, t, n) {
+		let r = this.programRegistry.get(e);
+		r && this.gl.deleteProgram(r.handle), this.programRegistry.set(e, n), this.programSources.set(e, t);
+	}
+	refreshPrograms() {
+		for (let [e, t] of this.programSources) {
+			let n = L(e);
+			if (n && n !== t) {
+				if (n.vert === t.vert && n.frag === t.frag) {
+					this.programSources.set(e, n);
+					continue;
+				}
+				try {
+					this.installProgram(e, n, Z(this.gl, n));
+				} catch (t) {
+					this.programSources.set(e, n), console.error(`weasel: failed to recompile re-registered program "${e}"; still drawing the previous one:`, t);
+				}
+			}
+		}
+	}
+	ensureProgram(e) {
+		let t = this.programRegistry.get(e);
+		if (t) return t;
+		if (this.disposed || !L(e)) return null;
+		try {
+			this.registerProgram({ id: e });
+		} catch (t) {
+			return console.error(`weasel: failed to compile paint program "${e}":`, t), null;
+		}
+		return this.programRegistry.get(e) ?? null;
+	}
+	glyphPaintProgram(e) {
+		let n = this.glyphPaintPrograms.get(e);
+		if (n) return n;
+		let [r, i] = ae[e], a = new t(this.gl, O, r);
+		return a.lookupUniforms(i), a.lookupAttributes(D), this.glyphPaintPrograms.set(e, a), a;
+	}
+	applyGlState() {
+		let e = this.gl;
+		e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), e.disable(e.DEPTH_TEST), e.disable(e.CULL_FACE), e.clearColor(0, 0, 0, 0);
+	}
+	applyTarget() {
+		let e = this.gl, t = Math.round(this.widthCss * this.dpr), n = Math.round(this.heightCss * this.dpr);
+		if (!this.target) {
+			e.disable(e.SCISSOR_TEST), e.viewport(0, 0, t, n);
+			return;
+		}
+		let r = Math.round(this.target.origin.x * this.dpr), i = e.drawingBufferHeight - Math.round(this.target.origin.y * this.dpr) - n;
+		e.viewport(r, i, t, n), e.scissor(r, i, t, n), e.enable(e.SCISSOR_TEST);
+	}
+	setTarget(e) {
+		this.target = e, this.applyTarget();
+	}
+	getTarget() {
+		return this.target;
+	}
+	isContextLost() {
+		return this.contextLost;
+	}
+	onContextLost(e) {
+		e.preventDefault(), this.contextLost = !0;
+	}
+	onContextRestored() {
+		this.contextLost = !1, this.applyGlState(), this.applyTarget(), this.effectTargets.releaseAll(), this.paintScratch.release(), this.paintResources.release(), this.paintResources = e(), this.pathFill = new t(this.gl, c, n), this.pathFill.lookupUniforms(i), this.pathFill.lookupAttributes(r), this.pathFillVColor = new t(this.gl, s, o), this.pathFillVColor.lookupUniforms(i), this.pathFillVColor.lookupAttributes(a), this.imageFill = new t(this.gl, f, d), this.imageFill.lookupUniforms(u), this.imageFill.lookupAttributes(l), this.batchFill = new t(this.gl, g, h), this.batchFill.lookupUniforms(m), this.batchFill.lookupAttributes(p), this.gradFill = new t(this.gl, b, y), this.gradFill.lookupUniforms(v), this.gradFill.lookupAttributes(_), this.patternFill = new t(this.gl, w, C), this.patternFill.lookupUniforms(S), this.patternFill.lookupAttributes(x), this.glyphPaintPrograms.clear();
+		let T = this.pathFill.attribute("a_position");
+		if (T === void 0) throw Error("a_position missing after restore");
+		this.meshCache = new M(this.gl, T), this.textureCache = new N(this.gl), this.imageCache.abandon(), this.imageCache = new P(this.gl, this.imageMinification), this.gradRamps = new F(this.gl), X(), this.uploadQuadGeometry(), this.drawBatch = new R(this.gl, this.batchFill), this.whiteTexture = $(this.gl);
+		for (let e of this.programRegistry.keys()) {
+			let t = L(e);
+			if (t) try {
+				this.programRegistry.set(e, Z(this.gl, t)), this.programSources.set(e, t);
+			} catch (t) {
+				console.error(`weasel: failed to recompile program "${e}" after context restore:`, t);
+			}
+		}
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = !0;
+		let e = this.gl;
+		this.canvas && (this.canvas.removeEventListener("webglcontextlost", this.boundOnLost), this.canvas.removeEventListener("webglcontextrestored", this.boundOnRestored)), this.meshCache.dispose(), this.paintResources.release();
+		for (let t of [
+			this.pathFill,
+			this.pathFillVColor,
+			this.imageFill,
+			this.batchFill,
+			this.gradFill,
+			this.patternFill,
+			...this.glyphPaintPrograms.values()
+		]) e.deleteProgram(t.handle);
+		this.glyphPaintPrograms.clear();
+		for (let t of this.programRegistry.values()) e.deleteProgram(t.handle);
+		this.programRegistry.clear(), this.programSources.clear(), this.textureCache.free(), this.imageCache.dispose(), this.gradRamps.free(), this.quadVbo && e.deleteBuffer(this.quadVbo), this.quadIbo && e.deleteBuffer(this.quadIbo), this.drawBatch.dispose(), this.whiteTexture && e.deleteTexture(this.whiteTexture), this.whiteTexture = null, this.effectTargets.releaseAll(), this.paintScratch.release();
+	}
+	render(e, t, n) {
+		if (this.contextLost || this.disposed) return;
+		let r = Q(), i = { drawCalls: 0 }, a = [];
+		this.stats = {
+			drawCalls: 0,
+			ms: 0,
+			spans: a
+		};
+		let o = this.gl;
+		this.meshCache.drainPendingDeletes(), this.refreshPrograms(), re(this.bakeBudget), this.groupState.reset(), this.applyGlState(), this.applyTarget(), this.target?.clear !== !1 && (o.stencilMask(255), o.clear(o.COLOR_BUFFER_BIT | o.STENCIL_BUFFER_BIT));
+		let s = {
+			gl: o,
+			pathFill: this.pathFill,
+			pathFillVColor: this.pathFillVColor,
+			imageFill: this.imageFill,
+			batchFill: this.batchFill,
+			gradFill: this.gradFill,
+			patternFill: this.patternFill,
+			meshCache: this.meshCache,
+			textureCache: this.textureCache,
+			imageCache: this.imageCache,
+			gradRamps: this.gradRamps,
+			programRegistry: this.programRegistry,
+			ensureProgram: (e) => this.ensureProgram(e),
+			glyphPaintProgram: (e) => this.glyphPaintProgram(e),
+			quadVbo: this.quadVbo,
+			quadIbo: this.quadIbo,
+			drawBatch: this.drawBatch,
+			whiteTexture: this.whiteTexture,
+			state: this.groupState,
+			widthCss: this.widthCss,
+			heightCss: this.heightCss,
+			clipDepth: 0,
+			flattenTolerance: this.flattenTolerance,
+			textOutlineMinScreenSize: this.textOutlineMinScreenSize,
+			viewMatrix: t,
+			effectTargets: this.effectTargets,
+			paintScratch: this.paintScratch,
+			renderTarget: null,
+			deviceWidth: Math.round(this.widthCss * this.dpr),
+			deviceHeight: Math.round(this.heightCss * this.dpr),
+			restoreTargetRect: () => this.applyTarget(),
+			paintResources: this.paintResources,
+			stats: i
+		}, c = n?.spans ?? [], l = 0;
+		for (let t = 0; t < c.length; t++) {
+			let n = c[t];
+			for (; l < n.start; l++) z(s, e[l]);
+			let r = i.drawCalls, o = Q();
+			for (; l < n.end; l++) z(s, e[l]);
+			t === c.length - 1 && l >= e.length && B(s), a.push({
+				id: n.id,
+				drawCalls: i.drawCalls - r,
+				ms: Q() - o
+			});
+		}
+		for (; l < e.length; l++) z(s, e[l]);
+		B(s), this.meshCache.freeTransient(), this.stats.drawCalls = i.drawCalls, this.stats.ms = Q() - r;
+	}
+	lastFrameStats() {
+		return this.stats;
+	}
+	setFlattenTolerance(e) {
+		this.flattenTolerance = e;
+	}
+	resize(e) {
+		this.widthCss = e.width, this.heightCss = e.height, this.dpr = e.dpr, this.canvas && (this.canvas.width = Math.round(e.width * e.dpr), this.canvas.height = Math.round(e.height * e.dpr), this.canvas.style && (this.canvas.style.width = `${e.width}px`, this.canvas.style.height = `${e.height}px`)), this.applyTarget();
+	}
+	_gl() {
+		return this.gl;
+	}
+	_pathFill() {
+		return this.pathFill;
+	}
+	_pathFillVColor() {
+		return this.pathFillVColor;
+	}
+	_drawBatch() {
+		return this.drawBatch;
+	}
+	_imageFill() {
+		return this.imageFill;
+	}
+	_batchFill() {
+		return this.batchFill;
+	}
+	_gradFill() {
+		return this.gradFill;
+	}
+	_patternFill() {
+		return this.patternFill;
+	}
+	_meshCache() {
+		return this.meshCache;
+	}
+	_textureCache() {
+		return this.textureCache;
+	}
+	_imageCache() {
+		return this.imageCache;
+	}
+	_gradRamps() {
+		return this.gradRamps;
+	}
+	_groupState() {
+		return this.groupState;
+	}
+	_widthCss() {
+		return this.widthCss;
+	}
+	_heightCss() {
+		return this.heightCss;
+	}
+	_dpr() {
+		return this.dpr;
+	}
+};
+function $(e) {
+	let t = e.createTexture();
+	return t ? (e.bindTexture(e.TEXTURE_2D, t), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, 1, 1, 0, e.RGBA, e.UNSIGNED_BYTE, new Uint8Array([
+		255,
+		255,
+		255,
+		255
+	])), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.bindTexture(e.TEXTURE_2D, null), t) : null;
+}
+//#endregion
+export { oe as WeaselRenderer };
+
+//# sourceMappingURL=WeaselRenderer.js.map

package/dist/renderer/WeaselRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeaselRenderer.js","names":["customUniformNames","CUSTOM_KIT_UNIFORMS","extractUniformNames","vertSrc","fragSrc","compileCustomProgram","src","CUSTOM_VERT_SRC","program","ShaderProgram","gl","extractUniformArrays","CUSTOM_ATTRIBUTES","now","GLYPH_PAINT_SOURCES","GLYPH_PATTERN_FRAG_SRC","GLYPH_PATTERN_UNIFORMS","GLYPH_GRAD_FRAG_SRC","GLYPH_GRAD_UNIFORMS","GLYPH_TEXTURE_FRAG_SRC","GLYPH_TEXTURE_UNIFORMS","WeaselRenderer","GroupState","createPaintResources","opts","EffectTargets","PaintScratch","attrs","DEFAULT_BAKE_BUDGET","OUTLINE_MIN_SCREEN_PX","VERT_SRC","FRAG_SRC","PATH_FILL_UNIFORMS","PATH_FILL_ATTRIBUTES","VCOLOR_VERT_SRC","VCOLOR_FRAG_SRC","PATH_FILL_VCOLOR_ATTRIBUTES","IMAGE_VERT_SRC","IMAGE_FRAG_SRC","IMAGE_FILL_UNIFORMS","IMAGE_FILL_ATTRIBUTES","BATCH_VERT_SRC","BATCH_FRAG_SRC","BATCH_FILL_UNIFORMS","BATCH_FILL_ATTRIBUTES","GRAD_VERT_SRC","GRAD_FRAG_SRC","GRAD_FILL_UNIFORMS","GRAD_FILL_ATTRIBUTES","PATTERN_VERT_SRC","PATTERN_FRAG_SRC","PATTERN_FILL_UNIFORMS","PATTERN_FILL_ATTRIBUTES","aPos","GLMeshCache","GLTextureCache","GLImageCache","GradientRampAtlas","DrawBatch","createWhiteTexture","QUAD_VERTICES","QUAD_INDICES","getProgramSource","handle","previous","id","compiled","e","existing","kind","frag","uniforms","GLYPH_PAINT_VERT_SRC","GLYPH_PAINT_ATTRIBUTES","w","h","x","y","target","markAllFontsNotUploaded","prog","t0","counters","spanStats","resetBakeBudget","ctx","spans","next","si","span","commands","drawsBefore","spanT0","flushBatch","tolerance","dims","tex"],"sources":["../../src/renderer/WeaselRenderer.ts"],"sourcesContent":["import { createPaintResources, type OwnedPaintResources } from './paintResources';\nimport { ShaderProgram } from './shaders/ShaderProgram';\nimport {\n  VERT_SRC,\n  FRAG_SRC,\n  VCOLOR_VERT_SRC,\n  VCOLOR_FRAG_SRC,\n  PATH_FILL_UNIFORMS,\n  PATH_FILL_ATTRIBUTES,\n  PATH_FILL_VCOLOR_ATTRIBUTES,\n} from './shaders/pathFill';\nimport {\n  markAllFontsNotUploaded,\n  resetBakeBudget,\n  DEFAULT_BAKE_BUDGET,\n} from '@weasel-js/font';\nimport {\n  IMAGE_VERT_SRC,\n  IMAGE_FRAG_SRC,\n  IMAGE_FILL_UNIFORMS,\n  IMAGE_FILL_ATTRIBUTES,\n} from './shaders/imageFill';\nimport {\n  BATCH_VERT_SRC,\n  BATCH_FRAG_SRC,\n  BATCH_FILL_UNIFORMS,\n  BATCH_FILL_ATTRIBUTES,\n} from './shaders/batchFill';\nimport {\n  GRAD_VERT_SRC,\n  GRAD_FRAG_SRC,\n  GRAD_FILL_UNIFORMS,\n  GRAD_FILL_ATTRIBUTES,\n} from './shaders/gradFill';\nimport {\n  PATTERN_VERT_SRC,\n  PATTERN_FRAG_SRC,\n  PATTERN_FILL_UNIFORMS,\n  PATTERN_FILL_ATTRIBUTES,\n} from './shaders/patternFill';\nimport {\n  GLYPH_PAINT_VERT_SRC,\n  GLYPH_PATTERN_FRAG_SRC,\n  GLYPH_GRAD_FRAG_SRC,\n  GLYPH_TEXTURE_FRAG_SRC,\n  GLYPH_PATTERN_UNIFORMS,\n  GLYPH_GRAD_UNIFORMS,\n  GLYPH_TEXTURE_UNIFORMS,\n  GLYPH_PAINT_ATTRIBUTES,\n} from './shaders/glyphPaint';\nimport { PaintScratch } from './paintScratch';\nimport { GLMeshCache } from './cache/GLMeshCache';\nimport { GLTextureCache } from './cache/GLTextureCache';\nimport { GLImageCache, type ImageMinification } from './cache/GLImageCache';\nimport { GradientRampAtlas } from './cache/GradientRampAtlas';\nimport { GroupState } from './state/GroupState';\nimport type { DrawCommand } from './DrawCommand';\nimport type { GlMat3 } from './math/mat3';\nimport {\n  dispatch, flushBatch, OUTLINE_MIN_SCREEN_PX, type DrawContext, type GlyphPaintKind,\n} from './draw';\nimport { DrawBatch } from './drawBatch';\nimport {\n  CUSTOM_VERT_SRC, CUSTOM_ATTRIBUTES, CUSTOM_KIT_UNIFORMS,\n  QUAD_VERTICES, QUAD_INDICES,\n} from './shaders/customPrelude';\nimport { getProgramSource, type ProgramSource, type ShaderProgramHandle } from './shaders/registerProgram';\nimport { EffectTargets } from './effects/EffectTargets';\nimport { extractUniformArrays, extractUniformNames } from './shaders/extractUniformNames';\n\n/** Every uniform a custom program may be written through. Both stages, not\n *  just the fragment one: a name never looked up is written through `null`,\n *  which GL accepts silently, so the uniform keeps its zero default. */\nfunction customUniformNames(vertSrc: string, fragSrc: string): string[] {\n  return [...CUSTOM_KIT_UNIFORMS, ...extractUniformNames(vertSrc), ...extractUniformNames(fragSrc)];\n}\n\n/** Compile a registered program's source against `gl`, with every uniform\n *  location and array base it may be written through. */\nfunction compileCustomProgram(gl: WebGL2RenderingContext, src: ProgramSource): ShaderProgram {\n  const vertSrc = src.vert === '' ? CUSTOM_VERT_SRC : src.vert;\n  const program = new ShaderProgram(gl, vertSrc, src.frag);\n  program.lookupUniforms(customUniformNames(vertSrc, src.frag));\n  program.lookupUniformArrays(new Map([...extractUniformArrays(vertSrc), ...extractUniformArrays(src.frag)]));\n  program.lookupAttributes(CUSTOM_ATTRIBUTES);\n  return program;\n}\n\n/** How to construct a `WeaselRenderer`: the GL context or canvas to draw\n *  into, the output size, and the quality knobs that separate screen\n *  rendering from print. */\n/** A run of top-level commands, `[start, end)` by index, that\n *  {@link WeaselRenderer.lastFrameStats} accounts for separately — one render\n *  layer's commands, say. Spans are in order and do not overlap. */\nexport interface RenderSpan {\n  id: string;\n  start: number;\n  end: number;\n}\n\n/** Per-frame options for {@link WeaselRenderer.render}. */\nexport interface RenderOptions {\n  spans?: readonly RenderSpan[];\n}\n\n/** What one span cost. A batched run is drawn when something closes it, so\n *  its draw call counts toward the span that closed it. */\nexport interface RenderSpanStats {\n  id: string;\n  drawCalls: number;\n  ms: number;\n}\n\n/** What one `render()` cost. See {@link WeaselRenderer.lastFrameStats}. */\nexport interface RenderStats {\n  drawCalls: number;\n  ms: number;\n  spans: RenderSpanStats[];\n}\n\nfunction now(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\n/** Construction options for {@link WeaselRenderer}. Pass `gl` or `canvas`;\n *  a context passed in must have a stencil buffer. */\nexport interface WeaselRendererOptions {\n  /** A WebGL2 context to draw with. Wins over `canvas`. */\n  gl?: WebGL2RenderingContext;\n  /** A canvas to open a stencil-backed WebGL2 context on, when `gl` is absent. */\n  canvas?: HTMLCanvasElement;\n  /** Drawing size in CSS pixels. */\n  width: number;\n  /** Drawing size in CSS pixels. */\n  height: number;\n  /** Device pixels per CSS pixel. */\n  dpr: number;\n  /** MIN_FILTER strategy for image/pattern textures (`GLImageCache`).\n   *  Default `'linear'` — the existing screen behavior. The headless\n   *  `renderSceneToPixels` path passes `'mipmap'` for print-quality\n   *  minification. Explicitly passing `'linear'` is always valid. */\n  imageMinification?: ImageMinification;\n  /** Flatness tolerance for curve tessellation, in WORLD units (see\n   *  `TessellateOptions.flattenTolerance`). When set, path fills are\n   *  tessellated fresh at this tolerance per frame (transient pool) instead\n   *  of served from the Path-identity mesh cache — the cache key does not\n   *  include tolerance. Default: unset — the existing cached behavior at\n   *  `DEFAULT_FLATTEN_TOLERANCE`. The headless path derives this from the\n   *  requested output scale; screen callers normally leave it unset. */\n  flattenTolerance?: number;\n  /** Per-render synchronous bake budget for dynamic canvas-SDF glyphs.\n   *  Default DEFAULT_BAKE_BUDGET (16). The headless renderSceneToPixels\n   *  path passes Infinity so print never defers a glyph. */\n  bakeBudget?: number;\n  /** On-screen glyph size, in CSS pixels, at or above which text renders from\n   *  tessellated font outlines instead of a distance field — see\n   *  `OUTLINE_MIN_SCREEN_PX`. Only faces registered with\n   *  `registerFontOutlines` are affected; everything else keeps its SDF tier\n   *  whatever this says. Pass `Infinity` to disable the tier outright, or 0\n   *  to use outlines wherever they exist (what the headless path does, since\n   *  print has no reason to sample a field it could evaluate exactly). */\n  textOutlineMinScreenSize?: number;\n}\n\n/** Where a renderer draws inside a buffer it does not own.\n *\n *  The rect's SIZE is the renderer's own `width`/`height` — `resize()` owns\n *  that, and a second copy here could disagree with the one `DrawContext`\n *  reports to screen-space layers. */\nexport interface RenderTarget {\n  /** Top-left of this renderer's output within the drawing buffer, in CSS\n   *  pixels, with the origin at the buffer's top-left. GL's bottom-left origin\n   *  is handled internally. */\n  origin: { x: number; y: number };\n  /** Clear colour and stencil within the rect before drawing. Default true.\n   *  Pass false only when the caller clears the whole buffer itself on behalf\n   *  of every co-tenant — a frame that clears neither inherits its neighbour's\n   *  stencil bits, and even-odd fills then fill their holes. */\n  clear?: boolean;\n}\n\n/** Each glyph-paint program's fragment stage and the uniforms it looks up. */\nconst GLYPH_PAINT_SOURCES: Record<GlyphPaintKind, readonly [string, readonly string[]]> = {\n  pattern: [GLYPH_PATTERN_FRAG_SRC, GLYPH_PATTERN_UNIFORMS],\n  gradient: [GLYPH_GRAD_FRAG_SRC, GLYPH_GRAD_UNIFORMS],\n  texture: [GLYPH_TEXTURE_FRAG_SRC, GLYPH_TEXTURE_UNIFORMS],\n};\n\n/**\n * The WebGL2 renderer: takes a list of draw commands and paints them.\n *\n * It knows nothing about the scene — commands are the whole interface, which\n * is what lets layers, HUD widgets and overlays all draw through the same\n * pipeline. GPU resources (meshes, textures, gradient ramps) are cached across\n * frames and keyed by identity, so re-issuing the same command is cheap.\n */\nexport class WeaselRenderer {\n  private readonly gl: WebGL2RenderingContext;\n  private stats: RenderStats = { drawCalls: 0, ms: 0, spans: [] };\n  private pathFill: ShaderProgram;\n  private pathFillVColor: ShaderProgram;\n  private imageFill: ShaderProgram;\n  private batchFill: ShaderProgram;\n  private gradFill: ShaderProgram;\n  private patternFill: ShaderProgram;\n  /** Compiled on first use: only atlas text under a texture paint needs one. */\n  private glyphPaintPrograms = new Map<GlyphPaintKind, ShaderProgram>();\n  private meshCache: GLMeshCache;\n  private textureCache: GLTextureCache;\n  private imageCache: GLImageCache;\n  private gradRamps: GradientRampAtlas;\n  private programRegistry = new Map<string, ShaderProgram>();\n  /** The source each compiled custom program was built from — or, after a\n   *  failed recompile, the source that failed, so it is not retried every frame. */\n  private programSources = new Map<string, ProgramSource>();\n  private quadVbo: WebGLBuffer | null = null;\n  private quadIbo: WebGLBuffer | null = null;\n  private drawBatch: DrawBatch;\n  /** 1x1 white, so a batch flush sampling no image still samples something —\n   *  see `shaders/batchFill.ts`. */\n  private whiteTexture: WebGLTexture | null = null;\n  private readonly groupState = new GroupState();\n  private widthCss: number;\n  private heightCss: number;\n  private dpr: number;\n  private canvas: HTMLCanvasElement | null = null;\n  private target: RenderTarget | null = null;\n  /** Offscreen buffers for group effects. Allocates nothing until a group\n   *  with effects asks, so a canvas without them pays no memory. */\n  private readonly effectTargets: EffectTargets;\n  private readonly paintScratch: PaintScratch;\n  private readonly imageMinification: ImageMinification;\n  private flattenTolerance?: number;\n  private readonly bakeBudget: number;\n  private readonly textOutlineMinScreenSize: number;\n  private contextLost = false;\n  private boundOnLost = (e: Event) => this.onContextLost(e);\n  private boundOnRestored = () => this.onContextRestored();\n  /** True after `dispose()`. A disposed renderer ignores further `render()`\n   *  calls and `registerProgram()` calls. */\n  private disposed = false;\n  /** What registered paint kinds hang their GPU state on. One per context\n   *  generation: a restore releases it and opens the next. */\n  private paintResources: OwnedPaintResources = createPaintResources();\n\n  constructor(opts: WeaselRendererOptions) {\n    if (!opts.gl && !opts.canvas) {\n      throw new Error('WeaselRenderer requires either gl or canvas');\n    }\n    const gl = opts.gl ?? opts.canvas!.getContext('webgl2', { stencil: true });\n    if (!gl) throw new Error('WeaselRenderer: WebGL2 not available');\n    this.gl = gl as WebGL2RenderingContext;\n    this.effectTargets = new EffectTargets(this.gl);\n    this.paintScratch = new PaintScratch(this.gl);\n\n    // Bits 0-7 are load-bearing: bit 0 for even-odd fills and stenciled\n    // strokes, bits 1-7 for clip depth (`renderer/draw.ts`). Without a stencil\n    // buffer both render wrong rather than not at all, so refuse the context\n    // instead of painting a plausible lie. A stub that cannot answer is not a\n    // stencil-less context — only an explicit `false` is.\n    const attrs = typeof this.gl.getContextAttributes === 'function'\n      ? this.gl.getContextAttributes()\n      : null;\n    if (attrs && attrs.stencil === false) {\n      throw new Error(\n        'WeaselRenderer: the supplied WebGL2 context has no stencil buffer. '\n        + 'Create it with { stencil: true } — clips and even-odd fills need one.',\n      );\n    }\n\n    this.widthCss = opts.width;\n    this.heightCss = opts.height;\n    this.dpr = opts.dpr;\n    this.imageMinification = opts.imageMinification ?? 'linear';\n    this.flattenTolerance = opts.flattenTolerance;\n    this.bakeBudget = opts.bakeBudget ?? DEFAULT_BAKE_BUDGET;\n    this.textOutlineMinScreenSize = opts.textOutlineMinScreenSize ?? OUTLINE_MIN_SCREEN_PX;\n\n    this.canvas = opts.canvas ?? null;\n    if (this.canvas) {\n      this.canvas.width = Math.round(opts.width * opts.dpr);\n      this.canvas.height = Math.round(opts.height * opts.dpr);\n      if (this.canvas.style) {\n        this.canvas.style.width = `${opts.width}px`;\n        this.canvas.style.height = `${opts.height}px`;\n      }\n      this.canvas.addEventListener('webglcontextlost', this.boundOnLost);\n      this.canvas.addEventListener('webglcontextrestored', this.boundOnRestored);\n    }\n\n    this.applyGlState();\n    this.applyTarget();\n\n    this.pathFill = new ShaderProgram(this.gl, VERT_SRC, FRAG_SRC);\n    this.pathFill.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFill.lookupAttributes(PATH_FILL_ATTRIBUTES);\n\n    this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);\n    this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);\n\n    this.imageFill = new ShaderProgram(this.gl, IMAGE_VERT_SRC, IMAGE_FRAG_SRC);\n    this.imageFill.lookupUniforms(IMAGE_FILL_UNIFORMS);\n    this.imageFill.lookupAttributes(IMAGE_FILL_ATTRIBUTES);\n\n    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);\n    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);\n    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);\n\n    this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);\n    this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);\n    this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);\n\n    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);\n    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);\n    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);\n\n    const aPos = this.pathFill.attribute('a_position');\n    if (aPos === undefined) throw new Error('WeaselRenderer: a_position not found in path-fill shader');\n    this.meshCache = new GLMeshCache(this.gl, aPos);\n    this.textureCache = new GLTextureCache(this.gl);\n    this.imageCache = new GLImageCache(this.gl, this.imageMinification);\n    this.gradRamps = new GradientRampAtlas(this.gl);\n    this.uploadQuadGeometry();\n    this.drawBatch = new DrawBatch(this.gl, this.batchFill);\n    this.whiteTexture = createWhiteTexture(this.gl);\n  }\n\n  private uploadQuadGeometry(): void {\n    const gl = this.gl;\n    this.quadVbo = gl.createBuffer();\n    this.quadIbo = gl.createBuffer();\n    if (!this.quadVbo || !this.quadIbo) {\n      throw new Error('WeaselRenderer: failed to create quad geometry buffers');\n    }\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadVbo);\n    gl.bufferData(gl.ARRAY_BUFFER, QUAD_VERTICES, gl.STATIC_DRAW);\n    gl.bindBuffer(gl.ARRAY_BUFFER, null);\n\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.quadIbo);\n    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, QUAD_INDICES, gl.STATIC_DRAW);\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n  }\n\n  /**\n   * Compile a consumer-registered shader program against this renderer's GL context.\n   *\n   * Call once per renderer after the module-level `registerProgram()`.\n   * Throws `ShaderCompileError` if compilation fails.\n   *\n   * In dev mode, calling again with the same handle replaces the compiled program.\n   *\n   * @experimental\n   */\n  registerProgram(handle: ShaderProgramHandle): void {\n    // A disposed renderer must not compile programs into the cleared registry.\n    if (this.disposed) return;\n    const src = getProgramSource(handle.id);\n    if (!src) {\n      throw new Error(\n        `WeaselRenderer.registerProgram: program \"${handle.id}\" not found in source registry. ` +\n        `Call the module-level registerProgram() first.`,\n      );\n    }\n    this.installProgram(handle.id, src, compileCustomProgram(this.gl, src));\n  }\n\n  private installProgram(id: string, src: ProgramSource, program: ShaderProgram): void {\n    const previous = this.programRegistry.get(id);\n    if (previous) this.gl.deleteProgram(previous.handle);\n    this.programRegistry.set(id, program);\n    this.programSources.set(id, src);\n  }\n\n  /** Recompile every program whose module-level source was re-registered\n   *  since it was compiled. A source that fails keeps the old program drawing. */\n  private refreshPrograms(): void {\n    for (const [id, compiled] of this.programSources) {\n      const src = getProgramSource(id);\n      if (!src || src === compiled) continue;\n      if (src.vert === compiled.vert && src.frag === compiled.frag) {\n        this.programSources.set(id, src);\n        continue;\n      }\n      try {\n        this.installProgram(id, src, compileCustomProgram(this.gl, src));\n      } catch (e) {\n        this.programSources.set(id, src);\n        console.error(`weasel: failed to recompile re-registered program \"${id}\"; still drawing the previous one:`, e);\n      }\n    }\n  }\n\n  /**\n   * The compiled program for `id`, compiling it against this context on first\n   * use. Unlike {@link registerProgram} this neither throws on a missing\n   * source nor on a compile failure: a paint kind asking for a program it\n   * never registered must decline the paint, not take down the frame.\n   */\n  private ensureProgram(id: string): ShaderProgram | null {\n    const existing = this.programRegistry.get(id);\n    if (existing) return existing;\n    if (this.disposed || !getProgramSource(id)) return null;\n    try {\n      this.registerProgram({ id });\n    } catch (e) {\n      console.error(`weasel: failed to compile paint program \"${id}\":`, e);\n      return null;\n    }\n    return this.programRegistry.get(id) ?? null;\n  }\n\n  private glyphPaintProgram(kind: GlyphPaintKind): ShaderProgram {\n    const existing = this.glyphPaintPrograms.get(kind);\n    if (existing) return existing;\n    const [frag, uniforms] = GLYPH_PAINT_SOURCES[kind];\n    const program = new ShaderProgram(this.gl, GLYPH_PAINT_VERT_SRC, frag);\n    program.lookupUniforms(uniforms);\n    program.lookupAttributes(GLYPH_PAINT_ATTRIBUTES);\n    this.glyphPaintPrograms.set(kind, program);\n    return program;\n  }\n\n  /** The GL state every frame assumes. Applied per `render()` rather than once\n   *  at construction because a co-tenant sharing this context moves all of it\n   *  between our frames. */\n  private applyGlState(): void {\n    const gl = this.gl;\n    gl.enable(gl.BLEND);\n    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n    gl.disable(gl.DEPTH_TEST);\n    gl.disable(gl.CULL_FACE);\n    gl.clearColor(0, 0, 0, 0);\n  }\n\n  /** Viewport and scissor for this frame. Re-applied inside `render()` because\n   *  a co-tenant on the same context moves both between our frames. */\n  private applyTarget(): void {\n    const gl = this.gl;\n    const w = Math.round(this.widthCss * this.dpr);\n    const h = Math.round(this.heightCss * this.dpr);\n    if (!this.target) {\n      gl.disable(gl.SCISSOR_TEST);\n      gl.viewport(0, 0, w, h);\n      return;\n    }\n    const x = Math.round(this.target.origin.x * this.dpr);\n    const y = gl.drawingBufferHeight - Math.round(this.target.origin.y * this.dpr) - h;\n    gl.viewport(x, y, w, h);\n    gl.scissor(x, y, w, h);\n    gl.enable(gl.SCISSOR_TEST);\n  }\n\n  /** Confine this renderer to a rect of its drawing buffer, or pass null to\n   *  give it the whole buffer back. Takes effect from the next `render()`. */\n  setTarget(target: RenderTarget | null): void {\n    this.target = target;\n    this.applyTarget();\n  }\n\n  getTarget(): RenderTarget | null {\n    return this.target;\n  }\n\n  isContextLost(): boolean {\n    return this.contextLost;\n  }\n\n  private onContextLost(e: Event): void {\n    e.preventDefault();\n    this.contextLost = true;\n  }\n\n  private onContextRestored(): void {\n    this.contextLost = false;\n    this.applyGlState();\n    this.applyTarget();\n    // Every framebuffer, texture and renderbuffer the pool held died with the\n    // context. `releaseAll` deletes handles that are already gone, which is a\n    // no-op, and drops the bookkeeping that would otherwise hand a dead FBO to\n    // the next group with effects.\n    this.effectTargets.releaseAll();\n    this.paintScratch.release();\n    this.paintResources.release();\n    this.paintResources = createPaintResources();\n    this.pathFill = new ShaderProgram(this.gl, VERT_SRC, FRAG_SRC);\n    this.pathFill.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFill.lookupAttributes(PATH_FILL_ATTRIBUTES);\n    this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);\n    this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);    this.imageFill = new ShaderProgram(this.gl, IMAGE_VERT_SRC, IMAGE_FRAG_SRC);\n    this.imageFill.lookupUniforms(IMAGE_FILL_UNIFORMS);\n    this.imageFill.lookupAttributes(IMAGE_FILL_ATTRIBUTES);\n\n    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);\n    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);\n    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);\n    this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);\n    this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);\n    this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);\n\n    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);\n    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);\n    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);\n    this.glyphPaintPrograms.clear();\n    const aPos = this.pathFill.attribute('a_position');\n    if (aPos === undefined) throw new Error('a_position missing after restore');\n    this.meshCache = new GLMeshCache(this.gl, aPos);\n    this.textureCache = new GLTextureCache(this.gl);\n    this.imageCache.abandon();\n    this.imageCache = new GLImageCache(this.gl, this.imageMinification);\n    this.gradRamps = new GradientRampAtlas(this.gl);\n    markAllFontsNotUploaded();\n\n    this.uploadQuadGeometry();\n    this.drawBatch = new DrawBatch(this.gl, this.batchFill);\n    this.whiteTexture = createWhiteTexture(this.gl);\n    for (const id of this.programRegistry.keys()) {\n      const src = getProgramSource(id);\n      if (!src) continue;\n      try {\n        this.programRegistry.set(id, compileCustomProgram(this.gl, src));\n        this.programSources.set(id, src);\n      } catch (e) {\n        console.error(`weasel: failed to recompile program \"${id}\" after context restore:`, e);\n      }\n    }\n  }\n\n  /** Free every GL resource this renderer created and detach context-loss\n   *  listeners when a canvas was supplied. Idempotent.\n   *\n   *  That covers the built-in and consumer-registered programs (their shaders\n   *  go with them), the shared quad geometry, the batch, the effect targets,\n   *  and every cache: atlas and gradient-ramp textures, bitmap and pattern\n   *  textures, and meshes — transient, persistent, and those whose Path was\n   *  already collected. The context itself is left alone, so a caller-owned\n   *  context can host renderer after renderer without accumulating anything.\n   *\n   *  A disposed renderer ignores further `render()` and `registerProgram()`\n   *  calls. */\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    const gl = this.gl;\n    if (this.canvas) {\n      this.canvas.removeEventListener('webglcontextlost', this.boundOnLost);\n      this.canvas.removeEventListener('webglcontextrestored', this.boundOnRestored);\n    }\n    this.meshCache.dispose();\n    this.paintResources.release();\n    for (const prog of [\n      this.pathFill, this.pathFillVColor, this.imageFill, this.batchFill, this.gradFill, this.patternFill,\n      ...this.glyphPaintPrograms.values(),\n    ]) {\n      gl.deleteProgram(prog.handle);\n    }\n    this.glyphPaintPrograms.clear();\n    for (const prog of this.programRegistry.values()) {\n      gl.deleteProgram(prog.handle);\n    }\n    this.programRegistry.clear();\n    this.programSources.clear();\n    this.textureCache.free();\n    this.imageCache.dispose();\n    this.gradRamps.free();\n    if (this.quadVbo) gl.deleteBuffer(this.quadVbo);\n    if (this.quadIbo) gl.deleteBuffer(this.quadIbo);\n    this.drawBatch.dispose();\n    if (this.whiteTexture) gl.deleteTexture(this.whiteTexture);\n    this.whiteTexture = null;\n    this.effectTargets.releaseAll();\n    this.paintScratch.release();\n  }\n\n  /**\n   * Draw one frame.\n   *\n   * `viewMatrix` is the frame's world→screen transform. It is only consulted\n   * by `units: 'world'` gradients, which fall back to screen space without\n   * it — every other command carries its own transform in the stream, so\n   * callers with no view concept can keep calling `render(commands)`.\n   */\n  render(commands: DrawCommand[], viewMatrix?: GlMat3, opts?: RenderOptions): void {\n    if (this.contextLost || this.disposed) return;\n    const t0 = now();\n    const counters = { drawCalls: 0 };\n    const spanStats: RenderSpanStats[] = [];\n    this.stats = { drawCalls: 0, ms: 0, spans: spanStats };\n    const gl = this.gl;\n    // Free GL resources whose Mesh was GC'd since the last frame. Done here\n    // (top of render, before any draws) because GL state is known clean —\n    // no VAO bound, no draw in flight. Deleting from the FinalizationRegistry\n    // callback directly was racy and caused mid-draw crashes.\n    this.meshCache.drainPendingDeletes();\n    this.refreshPrograms();\n    // New frame: refill the dynamic-glyph synchronous bake budget.\n    resetBakeBudget(this.bakeBudget);\n    this.groupState.reset();\n    this.applyGlState();\n    this.applyTarget();\n    // Ensure all stencil bits are cleared regardless of any mask left over\n    // from the previous frame's clip ops.\n    if (this.target?.clear !== false) {\n      gl.stencilMask(0xFF);\n      gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);\n    }\n    const ctx: DrawContext = {\n      gl,\n      pathFill: this.pathFill,\n      pathFillVColor: this.pathFillVColor,\n      imageFill: this.imageFill,\n      batchFill: this.batchFill,\n      gradFill: this.gradFill,\n      patternFill: this.patternFill,\n      meshCache: this.meshCache,\n      textureCache: this.textureCache,\n      imageCache: this.imageCache,\n      gradRamps: this.gradRamps,\n      programRegistry: this.programRegistry,\n      ensureProgram: (id) => this.ensureProgram(id),\n      glyphPaintProgram: (kind) => this.glyphPaintProgram(kind),\n      quadVbo: this.quadVbo,\n      quadIbo: this.quadIbo,\n      drawBatch: this.drawBatch,\n      whiteTexture: this.whiteTexture,\n      state: this.groupState,\n      widthCss: this.widthCss,\n      heightCss: this.heightCss,\n      clipDepth: 0,\n      flattenTolerance: this.flattenTolerance,\n      textOutlineMinScreenSize: this.textOutlineMinScreenSize,\n      viewMatrix,\n      effectTargets: this.effectTargets,\n      paintScratch: this.paintScratch,\n      renderTarget: null,\n      deviceWidth: Math.round(this.widthCss * this.dpr),\n      deviceHeight: Math.round(this.heightCss * this.dpr),\n      restoreTargetRect: () => this.applyTarget(),\n      paintResources: this.paintResources,\n      stats: counters,\n    };\n    const spans = opts?.spans ?? [];\n    let next = 0;\n    for (let si = 0; si < spans.length; si++) {\n      const span = spans[si];\n      for (; next < span.start; next++) dispatch(ctx, commands[next]);\n      const drawsBefore = counters.drawCalls;\n      const spanT0 = now();\n      for (; next < span.end; next++) dispatch(ctx, commands[next]);\n      // The stream's closing flush belongs to whatever it closes.\n      if (si === spans.length - 1 && next >= commands.length) flushBatch(ctx);\n      spanStats.push({ id: span.id, drawCalls: counters.drawCalls - drawsBefore, ms: now() - spanT0 });\n    }\n    for (; next < commands.length; next++) dispatch(ctx, commands[next]);\n    // The stream ended, so whatever is still staged has nothing left that\n    // could merge with it.\n    flushBatch(ctx);\n    // Free transient resources allocated during this frame (e.g. per-frame\n    // stroke ribbons from tessellateStroke). Done after all draws complete\n    // so we never delete a buffer that's still bound to a pending draw.\n    this.meshCache.freeTransient();\n    this.stats.drawCalls = counters.drawCalls;\n    this.stats.ms = now() - t0;\n  }\n\n  /** What the last `render()` cost: GL draw calls issued and CPU milliseconds\n   *  spent issuing them, in total and per requested span. GPU time is not\n   *  measured; the GPU runs asynchronously. */\n  lastFrameStats(): RenderStats {\n    return this.stats;\n  }\n\n  /** Change the curve-flattening tolerance after construction. `undefined`\n   *  restores the cached `DEFAULT_FLATTEN_TOLERANCE` route. */\n  setFlattenTolerance(tolerance: number | undefined): void {\n    this.flattenTolerance = tolerance;\n  }\n\n  resize(dims: { width: number; height: number; dpr: number }): void {\n    this.widthCss = dims.width;\n    this.heightCss = dims.height;\n    this.dpr = dims.dpr;\n    if (this.canvas) {\n      this.canvas.width = Math.round(dims.width * dims.dpr);\n      this.canvas.height = Math.round(dims.height * dims.dpr);\n      if (this.canvas.style) {\n        this.canvas.style.width = `${dims.width}px`;\n        this.canvas.style.height = `${dims.height}px`;\n      }\n    }\n    this.applyTarget();\n  }\n\n  /** @internal */ _gl(): WebGL2RenderingContext { return this.gl; }\n  /** @internal */ _pathFill(): ShaderProgram { return this.pathFill; }\n  /** @internal */ _pathFillVColor(): ShaderProgram { return this.pathFillVColor; }\n  /** @internal */ _drawBatch(): DrawBatch { return this.drawBatch; }\n  /** @internal */ _imageFill(): ShaderProgram { return this.imageFill; }\n  /** @internal */ _batchFill(): ShaderProgram { return this.batchFill; }\n  /** @internal */ _gradFill(): ShaderProgram { return this.gradFill; }\n  /** @internal */ _patternFill(): ShaderProgram { return this.patternFill; }\n  /** @internal */ _meshCache(): GLMeshCache { return this.meshCache; }\n  /** @internal */ _textureCache(): GLTextureCache { return this.textureCache; }\n  /** @internal */ _imageCache(): GLImageCache { return this.imageCache; }\n  /** @internal */ _gradRamps(): GradientRampAtlas { return this.gradRamps; }\n  /** @internal */ _groupState(): GroupState { return this.groupState; }\n  /** @internal */ _widthCss(): number { return this.widthCss; }\n  /** @internal */ _heightCss(): number { return this.heightCss; }\n  /** @internal */ _dpr(): number { return this.dpr; }\n}\n\n/** The 1x1 opaque white texture a batch flush binds when its run samples no\n *  image. NEAREST both ways: one texel, so there is nothing to filter, and a\n *  mipmap filter on a texture with no mipmaps is incomplete. */\nfunction createWhiteTexture(gl: WebGL2RenderingContext): WebGLTexture | null {\n  const tex = gl.createTexture();\n  if (!tex) return null;\n  gl.bindTexture(gl.TEXTURE_2D, tex);\n  gl.texImage2D(\n    gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE,\n    new Uint8Array([255, 255, 255, 255]),\n  );\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n  gl.bindTexture(gl.TEXTURE_2D, null);\n  return tex;\n}\n"],"mappings":"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"}