@weasel-js/core 1.9.4 → 1.10.1

package/dist/registerProgram-T9S_PfAX.d.ts

@@ -1,208 +0,0 @@
-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 elements, matching
- * `WebGL2RenderingContext.uniformMatrix3fv` element order so an upload needs
- * no 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 array, laid out as above.
- *
- * Every matrix the kit builds is a `Float64Array`: a view translation far
- * from the origin at high zoom needs more than a float32's 24 bits to hold a
- * fraction of a pixel. A `Float32Array` is accepted wherever one is read.
- * `mat3.toUniform` makes the float32 copy a GL uniform upload wants.
- */
-type GlMat3 = Float32Array | Float64Array;
-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;
-/** A float32 copy of `m`, for `uniformMatrix3fv` or a shader uniform value. */
-declare function toUniform(m: GlMat3): Float32Array;
-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 least any direction is scaled by the linear part — its smaller singular
- *  value. What a screen length is worth in world units, at most. */
-declare function minScaleOf(m: GlMat3): number;
-/** The renderer's 3x3 matrix operations, as one namespace. These work on the
- *  9-element 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;
-    toUniform: typeof toUniform;
-    apply: typeof apply;
-    screenToClip: typeof screenToClip;
-    meanScaleOf: typeof meanScaleOf;
-    minScaleOf: typeof minScaleOf;
-};
-
-/**
- * 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)      |
- * | Float64Array            | as the Float32Array of its values    |
- * | 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 | Float64Array | 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

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

package/dist/renderer/DrawCommand.js.map

@@ -1 +0,0 @@
-{"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 { CommandFill, CommandStroke } from '@weasel-js/paint';\nimport type { TextAlign, TextDirection, 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  /** Solid, pattern, or gradient (linear/radial/conic), resolved for the\n   *  renderer: `commandFill` makes one from a node's `FillStyle`. */\n  fill?: CommandFill;\n  /** Stroke spec. Its `paint` takes what `fill` does. */\n  stroke?: CommandStroke;\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?: TextAlign;\n  /** What `start` / `end` resolve against, and the base direction of bidi\n   *  reordering — see `LayoutRunsOpts.direction`. Default `style`'s. */\n  direction?: TextDirection | 'auto';\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":";AAiKA,IAAaA,IAAgB"}

package/dist/renderer/WeaselRenderer.js

@@ -1,333 +0,0 @@
-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 { BATCH_FILL_ATTRIBUTES as l, BATCH_FILL_UNIFORMS as u, BATCH_FRAG_SRC as d, BATCH_VERT_SRC as f } from "./shaders/batchFill.js";
-import { GRAD_FILL_ATTRIBUTES as p, GRAD_FILL_UNIFORMS as m, GRAD_FRAG_SRC as h, GRAD_VERT_SRC as g } from "./shaders/gradFill.js";
-import { PATTERN_FILL_ATTRIBUTES as _, PATTERN_FILL_UNIFORMS as v, PATTERN_FRAG_SRC as y, PATTERN_VERT_SRC as b } from "./shaders/patternFill.js";
-import { GLYPH_GRAD_FRAG_SRC as x, GLYPH_GRAD_UNIFORMS as S, GLYPH_PAINT_ATTRIBUTES as C, GLYPH_PAINT_VERT_SRC as w, GLYPH_PATTERN_FRAG_SRC as T, GLYPH_PATTERN_UNIFORMS as E, GLYPH_TEXTURE_FRAG_SRC as D, GLYPH_TEXTURE_UNIFORMS as ee } from "./shaders/glyphPaint.js";
-import { PaintScratch as te } from "./paintScratch.js";
-import { GLMeshCache as O } from "./cache/GLMeshCache.js";
-import { GLTextureCache as k } from "./cache/GLTextureCache.js";
-import { textureRegistry as A } from "./textures/registerTexture.js";
-import { GLImageCache as j } from "./cache/GLImageCache.js";
-import { GradientRampAtlas as M } from "./cache/GradientRampAtlas.js";
-import { GroupState as N } from "./state/GroupState.js";
-import { getProgramSource as P } from "./shaders/registerProgram.js";
-import { flushBatch as F } from "./draw/flushBatch.js";
-import { OUTLINE_MIN_SCREEN_PX as I } from "./draw/text.js";
-import { dispatch as L } from "./draw.js";
-import { DrawBatch as R } from "./drawBatch.js";
-import { CUSTOM_ATTRIBUTES as z, CUSTOM_KIT_UNIFORMS as B, CUSTOM_VERT_SRC as V, QUAD_INDICES as H, QUAD_VERTICES as U } from "./shaders/customPrelude.js";
-import { EffectTargets as W } from "./effects/EffectTargets.js";
-import { extractUniformArrays as G, extractUniformNames as K } from "./shaders/extractUniformNames.js";
-import { DEFAULT_BAKE_BUDGET as q, markAllFontsNotUploaded as J, resetBakeBudget as Y } from "@weasel-js/font";
-//#region src/renderer/WeaselRenderer.ts
-function X(e, t) {
-	return [
-		...B,
-		...K(e),
-		...K(t)
-	];
-}
-function Z(e, n) {
-	let r = n.vert === "" ? V : n.vert, i = new t(e, r, n.frag);
-	return i.lookupUniforms(X(r, n.frag)), i.lookupUniformArrays(new Map([...G(r), ...G(n.frag)])), i.lookupAttributes(z), i;
-}
-function Q() {
-	return typeof performance < "u" ? performance.now() : Date.now();
-}
-var ne = {
-	pattern: [T, E],
-	gradient: [x, S],
-	texture: [D, ee]
-}, re = class {
-	gl;
-	stats = {
-		drawCalls: 0,
-		ms: 0,
-		spans: []
-	};
-	pathFill;
-	pathFillVColor;
-	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 N();
-	widthCss;
-	heightCss;
-	dpr;
-	canvas = null;
-	lossTarget = 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 x = e.gl ?? e.canvas.getContext("webgl2", { stencil: !0 });
-		if (!x) throw Error("WeaselRenderer: WebGL2 not available");
-		this.gl = x, this.effectTargets = new W(this.gl), this.paintScratch = new te(this.gl);
-		let S = typeof this.gl.getContextAttributes == "function" ? this.gl.getContextAttributes() : null;
-		if (S && S.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 ?? q, this.textOutlineMinScreenSize = e.textOutlineMinScreenSize ?? I, 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`));
-		let C = this.canvas ?? this.gl.canvas ?? null;
-		C && typeof C.addEventListener == "function" && (this.lossTarget = C, this.lossTarget.addEventListener("webglcontextlost", this.boundOnLost), this.lossTarget.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.batchFill = new t(this.gl, f, d), this.batchFill.lookupUniforms(u), this.batchFill.lookupAttributes(l), this.gradFill = new t(this.gl, g, h), this.gradFill.lookupUniforms(m), this.gradFill.lookupAttributes(p), this.patternFill = new t(this.gl, b, y), this.patternFill.lookupUniforms(v), this.patternFill.lookupAttributes(_), this.meshCache = new O(this.gl), this.textureCache = new k(this.gl), this.imageCache = new j(this.gl, this.imageMinification), this.gradRamps = new M(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, U, e.STATIC_DRAW), e.bindBuffer(e.ARRAY_BUFFER, null), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.quadIbo), e.bufferData(e.ELEMENT_ARRAY_BUFFER, H, e.STATIC_DRAW), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, null);
-	}
-	registerProgram(e) {
-		if (this.disposed) return;
-		let t = P(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 = P(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 || !P(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] = ne[e], a = new t(this.gl, w, r);
-		return a.lookupUniforms(i), a.lookupAttributes(C), 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), e.colorMask(!0, !0, !0, !0), e.bindVertexArray(null), e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL, !1);
-	}
-	deviceRect() {
-		let e = this.target?.origin.x ?? 0, t = this.target?.origin.y ?? 0, n = Math.round(e * this.dpr), r = Math.round(t * this.dpr);
-		return {
-			x: n,
-			y: r,
-			width: Math.round((e + this.widthCss) * this.dpr) - n,
-			height: Math.round((t + this.heightCss) * this.dpr) - r
-		};
-	}
-	applyTarget() {
-		let e = this.gl, { x: t, y: n, width: r, height: i } = this.deviceRect();
-		if (!this.target) {
-			e.disable(e.SCISSOR_TEST), e.viewport(0, 0, r, i);
-			return;
-		}
-		let a = e.drawingBufferHeight - n - i;
-		e.viewport(t, a, r, i), e.scissor(t, a, r, i), 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.batchFill = new t(this.gl, f, d), this.batchFill.lookupUniforms(u), this.batchFill.lookupAttributes(l), this.gradFill = new t(this.gl, g, h), this.gradFill.lookupUniforms(m), this.gradFill.lookupAttributes(p), this.patternFill = new t(this.gl, b, y), this.patternFill.lookupUniforms(v), this.patternFill.lookupAttributes(_), this.glyphPaintPrograms.clear(), this.meshCache = new O(this.gl), this.textureCache = new k(this.gl), this.imageCache.abandon(), this.imageCache = new j(this.gl, this.imageMinification), this.gradRamps = new M(this.gl), J(), this.uploadQuadGeometry(), this.drawBatch = new R(this.gl, this.batchFill), this.whiteTexture = $(this.gl);
-		for (let e of this.programRegistry.keys()) {
-			let t = P(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.lossTarget && (this.lossTarget.removeEventListener("webglcontextlost", this.boundOnLost), this.lossTarget.removeEventListener("webglcontextrestored", this.boundOnRestored)), this.meshCache.dispose(), this.paintResources.release();
-		for (let t of [
-			this.pathFill,
-			this.pathFillVColor,
-			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.imageCache.drainPendingDeletes(), this.textureCache.sweep(A), this.refreshPrograms(), Y(this.bakeBudget), this.groupState.reset(), this.drawBatch.reset(), this.effectTargets.reclaim(), o.bindFramebuffer(o.FRAMEBUFFER, null), this.applyGlState(), this.applyTarget(), this.target?.clear !== !1 && (o.stencilMask(255), o.clear(o.COLOR_BUFFER_BIT | o.STENCIL_BUFFER_BIT));
-		let s = this.deviceRect(), c = {
-			gl: o,
-			pathFill: this.pathFill,
-			pathFillVColor: this.pathFillVColor,
-			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,
-			clipStack: [],
-			flattenTolerance: this.flattenTolerance,
-			textOutlineMinScreenSize: this.textOutlineMinScreenSize,
-			viewMatrix: t,
-			effectTargets: this.effectTargets,
-			paintScratch: this.paintScratch,
-			renderTarget: null,
-			deviceWidth: s.width,
-			deviceHeight: s.height,
-			restoreTargetRect: () => this.applyTarget(),
-			paintResources: this.paintResources,
-			stats: i
-		};
-		this.drawBatch.clip = null;
-		let l = n?.spans ?? [], u = 0;
-		for (let t = 0; t < l.length; t++) {
-			let n = l[t];
-			for (; u < n.start; u++) L(c, e[u]);
-			let r = i.drawCalls, o = Q();
-			for (; u < n.end; u++) L(c, e[u]);
-			t === l.length - 1 && u >= e.length && F(c), a.push({
-				id: n.id,
-				drawCalls: i.drawCalls - r,
-				ms: Q() - o
-			});
-		}
-		for (; u < e.length; u++) L(c, e[u]);
-		F(c), 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;
-	}
-	_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 { re as WeaselRenderer };
-
-//# sourceMappingURL=WeaselRenderer.js.map