@weasel-js/core 1.9.3 → 1.10.0

package/dist/renderer/shaders/imageFill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"imageFill.js","names":["IMAGE_VERT_SRC","IMAGE_FRAG_SRC","IMAGE_FILL_UNIFORMS","IMAGE_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/imageFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for the image / pattern fill shader.\n *\n * Two variants:\n *   - Flat: IMAGE_VERT_SRC + IMAGE_FRAG_SRC, one quad under `u_opacity`.\n *   - VOpacity: IMAGE_VOPACITY_VERT_SRC + IMAGE_VOPACITY_FRAG_SRC, which reads\n *     the same factor off a per-vertex `a_opacity` instead. The batch draws\n *     with it so quads differing only in opacity still share one draw.\n *\n * The fold is exact, not an approximation under conditions the way the solid\n * batch's is: `u_opacity` multiplies the alpha *after* the color matrix, so\n * moving it to an attribute cannot interact with the matrix. Group alpha\n * multiplies there too, which is why the batch folds it into the same\n * attribute and leaves `u_alpha` at 1.\n *\n * Inputs:\n *   a_position  vec2   screen-space x,y of the quad corner\n *   a_uv        vec2   texture coordinate 0..1\n *   a_opacity   float  VOpacity only — replaces `u_opacity` per vertex\n *\n * Uniforms:\n *   u_proj         mat3        screen → clip projection\n *   u_model        mat3        cumulative group transform\n *   u_sampler      sampler2D   image texture (TEXTURE0)\n *   u_opacity      float       flat only — overall opacity, 0..1\n *   u_alpha        float       group alpha, 0..1 (the batch leaves it at 1)\n *   u_colorMatrix  mat4        color transform applied to sampled texel before premultiply\n *   u_colorBias    vec4        bias added after the matrix (identity = zero bias)\n *\n * Output convention §2: PREMULTIPLIED alpha — `vec4(rgb * a, a)`.\n * Pattern fills reuse this shader; wrapping is baked into the texture state.\n */\n\nexport const IMAGE_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nin vec2 a_uv;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nout vec2 v_uv;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_uv = a_uv;\n}\n`;\n\nexport const IMAGE_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_uv;\nuniform sampler2D u_sampler;\nuniform float u_opacity;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 texel = texture(u_sampler, v_uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_opacity * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const IMAGE_VOPACITY_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nin vec2 a_uv;\nin float a_opacity;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nout vec2 v_uv;\nout float v_opacity;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_uv = a_uv;\n  v_opacity = a_opacity;\n}\n`;\n\nexport const IMAGE_VOPACITY_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_uv;\nin float v_opacity;\nuniform sampler2D u_sampler;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 texel = texture(u_sampler, v_uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * v_opacity * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const IMAGE_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_sampler', 'u_opacity', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\nexport const IMAGE_FILL_ATTRIBUTES = ['a_position', 'a_uv'] as const;\n\n/** `u_opacity` is absent: the driver strips a uniform the source never reads,\n *  so looking it up here would cache an undefined location under a live name. */\nexport const IMAGE_VOPACITY_UNIFORMS = [\n  'u_proj', 'u_model', 'u_sampler', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\nexport const IMAGE_VOPACITY_ATTRIBUTES = ['a_position', 'a_uv', 'a_opacity'] as const;\n"],"mappings":";AAiCA,IAAaA,IAA4B,qSAc5BC,IAA4B,+aAmD5BC,IAAsB;CACjC;CAAU;CAAW;CAAa;CAAa;CAC/C;CAAiB;AACnB,GAEaC,IAAwB,CAAC,cAAc,MAAM"}

package/dist/renderer/shaders/pathFill.js

@@ -1,13 +0,0 @@
-//#region src/renderer/shaders/pathFill.ts
-var e = "#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n", t = "#version 300 es\nprecision highp float;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 mapped = clamp(u_colorMatrix * u_color + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n", n = "#version 300 es\nin vec2 a_position;\nin vec4 a_vertexColor;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nout vec4 v_vertexColor;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_vertexColor = a_vertexColor;\n}\n", r = "#version 300 es\nprecision highp float;\nin vec4 v_vertexColor;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 src = u_color * v_vertexColor;\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n", i = [
-	"u_proj",
-	"u_model",
-	"u_color",
-	"u_alpha",
-	"u_colorMatrix",
-	"u_colorBias"
-], a = ["a_position"], o = ["a_position", "a_vertexColor"];
-//#endregion
-export { t as FRAG_SRC, a as PATH_FILL_ATTRIBUTES, i as PATH_FILL_UNIFORMS, o as PATH_FILL_VCOLOR_ATTRIBUTES, r as VCOLOR_FRAG_SRC, n as VCOLOR_VERT_SRC, e as VERT_SRC };
-
-//# sourceMappingURL=pathFill.js.map

package/dist/renderer/shaders/pathFill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pathFill.js","names":["VERT_SRC","FRAG_SRC","VCOLOR_VERT_SRC","VCOLOR_FRAG_SRC","PATH_FILL_UNIFORMS","PATH_FILL_ATTRIBUTES","PATH_FILL_VCOLOR_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/pathFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for the built-in solid-fill path shader.\n *\n * Two variants:\n *   - Flat: VERT_SRC + FRAG_SRC, uses uniform color only.\n *   - VColor: VCOLOR_VERT_SRC + VCOLOR_FRAG_SRC, multiplies a per-vertex\n *     `a_vertexColor` attribute with `u_color`.\n *\n * Both variants take `u_colorMatrix` (mat4) + `u_colorBias` (vec4); the\n * color transform is applied to the straight-alpha SRC color BEFORE\n * premultiplication. Identity matrix + zero bias = pass-through.\n *\n * Output (both variants): PREMULTIPLIED alpha.\n * Blend: caller sets `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)`.\n */\n\nexport const VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n`;\n\nexport const FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 mapped = clamp(u_colorMatrix * u_color + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const VCOLOR_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nin vec4 a_vertexColor;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nout vec4 v_vertexColor;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_vertexColor = a_vertexColor;\n}\n`;\n\nexport const VCOLOR_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec4 v_vertexColor;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 src = u_color * v_vertexColor;\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\n/** Uniforms shared between flat and vertex-color variants. */\nexport const PATH_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_color', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\n/** Attributes for the flat variant. */\nexport const PATH_FILL_ATTRIBUTES = ['a_position'] as const;\n\n/** Attributes for the vertex-color variant. */\nexport const PATH_FILL_VCOLOR_ATTRIBUTES = ['a_position', 'a_vertexColor'] as const;\n"],"mappings":";AAgBA,IAAaA,IAAsB,mPAWtBC,IAAsB,2UActBC,IAA6B,sUAc7BC,IAA6B,sYAiB7BC,IAAqB;CAChC;CAAU;CAAW;CAAW;CAChC;CAAiB;AACnB,GAGaC,IAAuB,CAAC,YAAY,GAGpCC,IAA8B,CAAC,cAAc,eAAe"}

package/dist/renderer/shaders/patternFill.js

@@ -1,24 +0,0 @@
-//#region src/renderer/shaders/patternFill.ts
-var e = "#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n", t = "\nuniform sampler2D u_sampler;\nuniform vec2  u_tileSize;\nuniform float u_opacity;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nvec4 shadePaint(vec2 world) {\n  vec2 uv = world / max(u_tileSize, vec2(0.0001));\n  vec4 texel = texture(u_sampler, uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_opacity * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n", n = `#version 300 es
-precision highp float;
-in vec2 v_world;
-${t}
-out vec4 outColor;
-void main() {
-  outColor = shadePaint(v_world);
-}
-`, r = [
-	"u_proj",
-	"u_model",
-	"u_worldInv",
-	"u_sampler",
-	"u_tileSize",
-	"u_opacity",
-	"u_alpha",
-	"u_colorMatrix",
-	"u_colorBias"
-], i = ["a_position"];
-//#endregion
-export { i as PATTERN_FILL_ATTRIBUTES, r as PATTERN_FILL_UNIFORMS, n as PATTERN_FRAG_SRC, t as PATTERN_PAINT_GLSL, e as PATTERN_VERT_SRC };
-
-//# sourceMappingURL=patternFill.js.map

package/dist/renderer/shaders/patternFill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"patternFill.js","names":["PATTERN_VERT_SRC","PATTERN_PAINT_GLSL","PATTERN_FRAG_SRC","PATTERN_FILL_UNIFORMS","PATTERN_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/patternFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for pattern-fill paths.\n *\n * The vertex stage is `gradFill`'s: a path fill mesh carries `a_position`\n * only, so tile-space coordinates are recovered per fragment from the\n * screen position via `u_worldInv` rather than read from a UV attribute.\n * That matrix also carries the tile's origin and transform\n * (`patternTileSpace`). `u_tileSize` then converts to texture space, and\n * `REPEAT` wrapping (set at upload) tiles the result.\n *\n * Output convention §2: PREMULTIPLIED alpha.\n */\n\nexport const PATTERN_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n`;\n\n/**\n * The pattern's color at a paint-space point, premultiplied — the whole of the\n * fragment stage but the point it is asked about, so the glyph program can\n * mask the same paint the path program draws.\n */\nexport const PATTERN_PAINT_GLSL = /* glsl */ `\nuniform sampler2D u_sampler;\nuniform vec2  u_tileSize;\nuniform float u_opacity;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nvec4 shadePaint(vec2 world) {\n  vec2 uv = world / max(u_tileSize, vec2(0.0001));\n  vec4 texel = texture(u_sampler, uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_opacity * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const PATTERN_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\n${PATTERN_PAINT_GLSL}\nout vec4 outColor;\nvoid main() {\n  outColor = shadePaint(v_world);\n}\n`;\n\nexport const PATTERN_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_worldInv', 'u_sampler',\n  'u_tileSize', 'u_opacity', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\nexport const PATTERN_FILL_ATTRIBUTES = ['a_position'] as const;\n"],"mappings":";AAaA,IAAaA,IAA8B,6WAoB9BC,IAAgC,gcAgBhCC,IAA8B;;;EAGzCD,EAAmB;;;;;GAORE,IAAwB;CACnC;CAAU;CAAW;CAAc;CACnC;CAAc;CAAa;CAC3B;CAAiB;AACnB,GAEaC,IAA0B,CAAC,YAAY"}

package/dist/renderer/shaders/registerProgram.js

@@ -1,18 +0,0 @@
-import { createReflectable as e } from "@weasel-js/registry";
-//#region src/renderer/shaders/registerProgram.ts
-var t = e(), n = t.reflection;
-function r(e) {
-	return t.get(e) ?? null;
-}
-var i = () => typeof process < "u" ? process.env.NODE_ENV !== "production" : !0;
-function a(e, n, r) {
-	if (t.has(e) && !i()) throw Error(`weasel registerProgram: duplicate program id "${e}". In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);
-	return t.set(e, {
-		vert: n,
-		frag: r
-	}), { id: e };
-}
-//#endregion
-export { r as getProgramSource, n as programSourceRegistry, a as registerProgram };
-
-//# sourceMappingURL=registerProgram.js.map

package/dist/renderer/shaders/registerProgram.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerProgram.js","names":["registry","createReflectable","programSourceRegistry","getProgramSource","id","isDev","registerProgram"],"sources":["../../../src/renderer/shaders/registerProgram.ts"],"sourcesContent":["/**\n * registerProgram — public API for registering custom shader programs.\n *\n * Stores raw GLSL source strings in a module-level registry. GL compilation\n * happens on each WeaselRenderer via WeaselRenderer.registerProgram(), which\n * calls getProgramSource() and compiles the result. This keeps registerProgram\n * GL-context-agnostic — identical pattern to registerFont storing ImageBitmap.\n *\n * Module-level state = source strings only; compiled GL\n * programs live on each renderer's programRegistry (Map<id, ShaderProgram>).\n *\n * Lifecycle: program sources live for the module lifetime. No unregister in v1.\n */\n\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\nimport { type TextureHandle } from '../textures/registerTexture';\n\nexport type { TextureHandle };\n\n/** Opaque handle to a compiled custom shader program. */\nexport interface ShaderProgramHandle {\n  readonly id: string;\n}\n\n/**\n * A value for one uniform in `ShaderDrawCommand.uniforms`.\n *\n * | TS type                 | GL call                              |\n * |-------------------------|--------------------------------------|\n * | number                  | uniform1f                            |\n * | [n, n]                  | uniform2fv                           |\n * | [n, n, n]               | uniform3fv                           |\n * | [n, n, n, n]            | uniform4fv                           |\n * | Float32Array length 9   | uniformMatrix3fv (column-major)      |\n * | Float32Array length 16  | uniformMatrix4fv (column-major)      |\n * | TextureHandle           | bind to next tex unit + uniform1i    |\n *\n * **Array uniforms.** Keyed by an array's bare name (`u_ripples` for\n * `uniform vec3 u_ripples[8]`), a flat `number[]`, `Float32Array`,\n * `Int32Array` or `Uint32Array` fills the array from slot 0 in one\n * `uniform*v` call chosen by the declared element type (`vec3` →\n * `uniform3fv`, `ivec2` → `uniform2iv`, `mat4` → `uniformMatrix4fv`, …).\n * Its length must be a whole number of elements and at most the declared\n * size; a shorter value leaves the remaining slots as they were. Per-slot\n * keys (`u_ripples[2]`) keep working and take the table above.\n */\nexport type ShaderUniform =\n  | number\n  | [number, number]\n  | [number, number, number]\n  | [number, number, number, number]\n  | readonly number[]\n  | Float32Array\n  | Int32Array\n  | Uint32Array\n  | TextureHandle;\n\n/** A registered program's GLSL source. An empty `vert` means the kit's default vertex shader. */\nexport interface ProgramSource {\n  vert: string;\n  frag: string;\n}\n\nconst registry = createReflectable<ProgramSource>();\n\n/** Every registered program's GLSL source, keyed by program id. */\nexport const programSourceRegistry: Reflection<ProgramSource> = registry.reflection;\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetProgramRegistryForTests(): void {\n  registry.clear();\n}\n\nexport function getProgramSource(id: string): ProgramSource | null {\n  return registry.get(id) ?? null;\n}\n\nconst isDev = (): boolean =>\n  typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n\n/**\n * Register a custom shader program by id.\n *\n * Pass an empty string for `vert` to use the kit's default vertex shader\n * (recommended). The kit's vertex shader exposes `v_uv`, `v_screen`, and\n * `v_world` varyings plus `u_bounds` and `u_view` uniforms.\n *\n * **IMPORTANT — Premultiplied alpha:**\n * Your fragment shader MUST output premultiplied alpha:\n *   `outColor = vec4(rgb * a, a);`  ← correct\n *   `outColor = vec4(rgb, a);`      ← WRONG — over-brightens translucent regions\n *\n * The renderer uses `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)` to match.\n * Opaque fragments (a=1) are unaffected; only fragments with a < 1 differ.\n *\n * **Re-registration behavior:**\n * - Dev mode (`NODE_ENV !== 'production'`): calling with an existing id and new\n *   source replaces it (hot reload). Every renderer that compiled the old source\n *   recompiles on its next frame and deletes the program it replaces; a\n *   `<Canvas shaders>` naming the id repaints to show it. If the new source fails\n *   to compile, the renderer logs the error once and keeps drawing the old one.\n * - Prod mode: calling with an existing id throws.\n *\n * Actual GL compilation and `ShaderCompileError` throwing happen in\n * `WeaselRenderer.registerProgram()`, not here.\n *\n * @experimental API may break before v2.\n */\nexport function registerProgram(\n  id: string,\n  vert: string,\n  frag: string,\n): ShaderProgramHandle {\n  if (registry.has(id) && !isDev()) {\n    throw new Error(`weasel registerProgram: duplicate program id \"${id}\". ` +\n      `In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);\n  }\n  registry.set(id, { vert, frag });\n  return { id };\n}\n"],"mappings":";;AA+DA,IAAMA,IAAWC,EAAiC,GAGrCC,IAAmDF,EAAS;AAOzE,SAAgBG,EAAiB,GAAkC;CACjE,OAAOH,EAAS,IAAII,CAAE,KAAK;AAC7B;AAEA,IAAMC,UACJ,OAAO,UAAY,MAAA,QAAA,IAAA,aAAuC,eAAe;AA8B3E,SAAgBC,EACd,GACA,GACA,GACqB;CACrB,IAAIN,EAAS,IAAII,CAAE,KAAK,CAACC,EAAM,GAC7B,MAAU,MAAM,iDAAiDD,EAAG,wFACoB;CAG1F,OADAJ,EAAS,IAAII,GAAI;EAAE;EAAM;CAAK,CAAC,GACxB,EAAE,MAAG;AACd"}

package/dist/renderer/spriteSheet.js

@@ -1,14 +0,0 @@
-//#region src/renderer/spriteSheet.ts
-function e(e, t) {
-	let { frameWidth: n, frameHeight: r, columns: i } = e, a = e.margin ?? 0, o = e.spacing ?? 0, s = t % i, c = Math.floor(t / i);
-	return {
-		x: a + s * (n + o),
-		y: a + c * (r + o),
-		w: n,
-		h: r
-	};
-}
-//#endregion
-export { e as frameRect };
-
-//# sourceMappingURL=spriteSheet.js.map

package/dist/renderer/spriteSheet.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"spriteSheet.js","names":["frameRect","sheet","margin","spacing","col","index","columns","row","frameWidth","frameHeight"],"sources":["../../src/renderer/spriteSheet.ts"],"sourcesContent":["/**\n * Uniform-grid sprite sheet layout — frame index to the source rect an\n * `ImageDrawCommand` samples. Pure arithmetic over the grid description; it\n * never touches the bitmap.\n */\n\n/** A sprite sheet's grid. `margin` and `spacing` follow the Tiled / Aseprite\n *  tileset convention, so a sheet exported from either describes itself here. */\nexport interface SpriteSheet {\n  frameWidth: number;\n  frameHeight: number;\n  columns: number;\n  /** Empty pixels around the whole grid. Default 0. */\n  margin?: number;\n  /** Empty pixels between adjacent cells — the gutter that keeps linear\n   *  sampling off the neighboring frame. Default 0. */\n  spacing?: number;\n}\n\n/**\n * Row-major source rect for frame `index`, counting from 0 at the top-left.\n *\n * `index` is not range-checked and does not wrap: past the last cell this\n * returns a rect below the sheet, which draws as an edge smear. Wrapping is\n * the animation's business (`frameRect(sheet, tick % count)`) — a sheet does\n * not know how many of its cells are filled.\n */\nexport function frameRect(\n  sheet: SpriteSheet,\n  index: number,\n): { x: number; y: number; w: number; h: number } {\n  const { frameWidth, frameHeight, columns } = sheet;\n  const margin = sheet.margin ?? 0;\n  const spacing = sheet.spacing ?? 0;\n  const col = index % columns;\n  const row = Math.floor(index / columns);\n  return {\n    x: margin + col * (frameWidth + spacing),\n    y: margin + row * (frameHeight + spacing),\n    w: frameWidth,\n    h: frameHeight,\n  };\n}\n"],"mappings":";AA2BA,SAAgBA,EACd,GACA,GACgD;CAChD,IAAM,EAAE,eAAY,gBAAa,eAAYC,GACvCC,IAASD,EAAM,UAAU,GACzBE,IAAUF,EAAM,WAAW,GAC3BG,IAAMC,IAAQC,GACdC,IAAM,KAAK,MAAMF,IAAQC,CAAO;CACtC,OAAO;EACL,GAAGJ,IAASE,KAAOI,IAAaL;EAChC,GAAGD,IAASK,KAAOE,IAAcN;EACjC,GAAGK;EACH,GAAGC;CACL;AACF"}

package/dist/renderer/state/GroupState.js

@@ -1,77 +0,0 @@
-import { mat3 as e } from "../math/mat3.js";
-//#region src/renderer/state/GroupState.ts
-var t = new Float32Array([
-	1,
-	0,
-	0,
-	0,
-	0,
-	0,
-	1,
-	0,
-	0,
-	0,
-	0,
-	0,
-	1,
-	0,
-	0,
-	0,
-	0,
-	0,
-	1,
-	0
-]);
-function n(e, t) {
-	let n = /* @__PURE__ */ new Float32Array(20);
-	for (let r = 0; r < 4; r++) {
-		for (let i = 0; i < 4; i++) {
-			let a = 0;
-			for (let n = 0; n < 4; n++) a += e[r * 5 + n] * t[n * 5 + i];
-			n[r * 5 + i] = a;
-		}
-		let i = e[r * 5 + 4];
-		for (let n = 0; n < 4; n++) i += e[r * 5 + n] * t[n * 5 + 4];
-		n[r * 5 + 4] = i;
-	}
-	return n;
-}
-var r = class {
-	transformStack = [e.identity()];
-	alphaStack = [1];
-	colorMatrixStack = [t];
-	get transform() {
-		return this.transformStack[this.transformStack.length - 1];
-	}
-	get alpha() {
-		return this.alphaStack[this.alphaStack.length - 1];
-	}
-	get colorMatrix() {
-		return this.colorMatrixStack[this.colorMatrixStack.length - 1];
-	}
-	push(t) {
-		let r = this.transform, i = t.transform ? e.multiply(r, t.transform) : r, a = t.alpha === void 0 ? this.alpha : this.alpha * t.alpha, o = t.colorMatrix ? n(this.colorMatrix, t.colorMatrix instanceof Float32Array ? t.colorMatrix : new Float32Array(t.colorMatrix)) : this.colorMatrix;
-		this.transformStack.push(i), this.alphaStack.push(a), this.colorMatrixStack.push(o);
-	}
-	pushIsolated(n) {
-		this.push(n);
-		let r = {
-			alpha: this.alpha,
-			colorMatrix: this.colorMatrix
-		};
-		this.pop();
-		let i = this.transform;
-		return this.transformStack.push(n.transform ? e.multiply(i, n.transform) : i), this.alphaStack.push(1), this.colorMatrixStack.push(t), r;
-	}
-	reset() {
-		this.transformStack.length = 1, this.alphaStack.length = 1, this.colorMatrixStack.length = 1;
-	}
-	pop() {
-		if (this.transformStack.length <= 1) throw Error("GroupState.pop: cannot pop root frame");
-		this.transformStack.pop(), this.alphaStack.pop(), this.colorMatrixStack.pop();
-	}
-};
-//#endregion
-export { r as GroupState, t as IDENTITY_COLOR_MATRIX };
-
-//# sourceMappingURL=GroupState.js.map

package/dist/renderer/state/GroupState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GroupState.js","names":["IDENTITY_COLOR_MATRIX","compose4x5","result","row","col","sum","k","outer","inner","biasSum","GroupState","mat3","current","nextTransform","frame","nextAlpha","nextCM","composited"],"sources":["../../../src/renderer/state/GroupState.ts"],"sourcesContent":["import { mat3, type GlMat3 } from '../math/mat3';\n\n/** Row-major 4×5 color matrix identity. */\nexport const IDENTITY_COLOR_MATRIX = new Float32Array([\n  1, 0, 0, 0, 0,\n  0, 1, 0, 0, 0,\n  0, 0, 1, 0, 0,\n  0, 0, 0, 1, 0,\n]);\n\nexport interface GroupFrame {\n  transform?: GlMat3;\n  alpha?: number;\n  /** Row-major 4×5 color matrix (20 floats). Absent leaves the stack unchanged. */\n  colorMatrix?: Float32Array | number[];\n}\n\n/**\n * Compose two 4×5 color matrices: out = outer ∘ inner (inner applied first).\n *\n *   composed(x) = M_outer * (M_inner * x + b_inner) + b_outer\n *               = (M_outer * M_inner) * x + (M_outer * b_inner + b_outer)\n *\n * Each matrix is row-major. The 4×4 portion occupies indices\n * [0..3, 5..8, 10..13, 15..18]; bias column at [4, 9, 14, 19].\n */\nfunction compose4x5(outer: Float32Array, inner: Float32Array): Float32Array {\n  const result = new Float32Array(20);\n  for (let row = 0; row < 4; row++) {\n    for (let col = 0; col < 4; col++) {\n      let sum = 0;\n      for (let k = 0; k < 4; k++) {\n        sum += outer[row * 5 + k] * inner[k * 5 + col];\n      }\n      result[row * 5 + col] = sum;\n    }\n    let biasSum = outer[row * 5 + 4];\n    for (let k = 0; k < 4; k++) {\n      biasSum += outer[row * 5 + k] * inner[k * 5 + 4];\n    }\n    result[row * 5 + 4] = biasSum;\n  }\n  return result;\n}\n\nexport class GroupState {\n  private transformStack: GlMat3[] = [mat3.identity()];\n  private alphaStack: number[] = [1];\n  private colorMatrixStack: Float32Array[] = [IDENTITY_COLOR_MATRIX];\n\n  get transform(): GlMat3 {\n    return this.transformStack[this.transformStack.length - 1];\n  }\n\n  get alpha(): number {\n    return this.alphaStack[this.alphaStack.length - 1];\n  }\n\n  get colorMatrix(): Float32Array {\n    return this.colorMatrixStack[this.colorMatrixStack.length - 1];\n  }\n\n  push(frame: GroupFrame): void {\n    const current = this.transform;\n    const nextTransform = frame.transform ? mat3.multiply(current, frame.transform) : current;\n    const nextAlpha = frame.alpha !== undefined ? this.alpha * frame.alpha : this.alpha;\n    const nextCM = frame.colorMatrix\n      ? compose4x5(\n          this.colorMatrix,\n          frame.colorMatrix instanceof Float32Array\n            ? frame.colorMatrix\n            : new Float32Array(frame.colorMatrix),\n        )\n      : this.colorMatrix;\n    this.transformStack.push(nextTransform);\n    this.alphaStack.push(nextAlpha);\n    this.colorMatrixStack.push(nextCM);\n  }\n\n  /**\n   * Push a frame whose children paint into a surface of their own.\n   *\n   * The transform still accumulates — the children draw where they would have\n   * drawn. Alpha and colour do not: they describe how the finished surface\n   * joins the frame, and applying them on the way in as well would fade the\n   * pixels an effect is about to read, then fade them again on the way out.\n   *\n   * Returns the pair the caller must apply at composite time — what `push`\n   * would have left on the stack — so the composition rules live here and not\n   * in the dispatcher.\n   */\n  pushIsolated(frame: GroupFrame): { alpha: number; colorMatrix: Float32Array } {\n    this.push(frame);\n    const composited = { alpha: this.alpha, colorMatrix: this.colorMatrix };\n    this.pop();\n    const current = this.transform;\n    this.transformStack.push(frame.transform ? mat3.multiply(current, frame.transform) : current);\n    this.alphaStack.push(1);\n    this.colorMatrixStack.push(IDENTITY_COLOR_MATRIX);\n    return composited;\n  }\n\n  /** Drop every pushed frame, leaving the root. A frame that throws part-way\n   *  down the tree never pops, and the next frame would draw under leftovers. */\n  reset(): void {\n    this.transformStack.length = 1;\n    this.alphaStack.length = 1;\n    this.colorMatrixStack.length = 1;\n  }\n\n  pop(): void {\n    if (this.transformStack.length <= 1) {\n      throw new Error('GroupState.pop: cannot pop root frame');\n    }\n    this.transformStack.pop();\n    this.alphaStack.pop();\n    this.colorMatrixStack.pop();\n  }\n}\n"],"mappings":";;AAGA,IAAaA,IAAwB,IAAI,aAAa;CACpD;CAAG;CAAG;CAAG;CAAG;CACZ;CAAG;CAAG;CAAG;CAAG;CACZ;CAAG;CAAG;CAAG;CAAG;CACZ;CAAG;CAAG;CAAG;CAAG;AACd,CAAC;AAkBD,SAASC,EAAW,GAAqB,GAAmC;CAC1E,IAAMC,oBAAS,IAAI,aAAa,EAAE;CAClC,KAAK,IAAIC,IAAM,GAAGA,IAAM,GAAG,KAAO;EAChC,KAAK,IAAIC,IAAM,GAAGA,IAAM,GAAG,KAAO;GAChC,IAAIC,IAAM;GACV,KAAK,IAAIC,IAAI,GAAGA,IAAI,GAAG,KACrB,KAAOC,EAAMJ,IAAM,IAAIG,KAAKE,EAAMF,IAAI,IAAIF;GAE5C,EAAOD,IAAM,IAAIC,KAAOC;EAC1B;EACA,IAAII,IAAUF,EAAMJ,IAAM,IAAI;EAC9B,KAAK,IAAIG,IAAI,GAAGA,IAAI,GAAG,KACrB,KAAWC,EAAMJ,IAAM,IAAIG,KAAKE,EAAMF,IAAI,IAAI;EAEhD,EAAOH,IAAM,IAAI,KAAKM;CACxB;CACA,OAAOP;AACT;AAEA,IAAaQ,IAAb,MAAwB;CACtB,iBAAmC,CAACC,EAAK,SAAS,CAAC;CACnD,aAA+B,CAAC,CAAC;CACjC,mBAA2C,CAACX,CAAqB;CAEjE,IAAI,YAAoB;EACtB,OAAO,KAAK,eAAe,KAAK,eAAe,SAAS;CAC1D;CAEA,IAAI,QAAgB;EAClB,OAAO,KAAK,WAAW,KAAK,WAAW,SAAS;CAClD;CAEA,IAAI,cAA4B;EAC9B,OAAO,KAAK,iBAAiB,KAAK,iBAAiB,SAAS;CAC9D;CAEA,KAAK,GAAyB;EAC5B,IAAMY,IAAU,KAAK,WACfC,IAAgBC,EAAM,YAAYH,EAAK,SAASC,GAASE,EAAM,SAAS,IAAIF,GAC5EG,IAAYD,EAAM,UAAU,KAAA,IAAuC,KAAK,QAAhC,KAAK,QAAQA,EAAM,OAC3DE,IAASF,EAAM,cACjBb,EACE,KAAK,aACLa,EAAM,uBAAuB,eACzBA,EAAM,cACN,IAAI,aAAaA,EAAM,WAAW,CACxC,IACA,KAAK;EAGT,AAFA,KAAK,eAAe,KAAKD,CAAa,GACtC,KAAK,WAAW,KAAKE,CAAS,GAC9B,KAAK,iBAAiB,KAAKC,CAAM;CACnC;CAcA,aAAa,GAAiE;EAC5E,KAAK,KAAKF,CAAK;EACf,IAAMG,IAAa;GAAE,OAAO,KAAK;GAAO,aAAa,KAAK;EAAY;EACtE,KAAK,IAAI;EACT,IAAML,IAAU,KAAK;EAIrB,OAHA,KAAK,eAAe,KAAKE,EAAM,YAAYH,EAAK,SAASC,GAASE,EAAM,SAAS,IAAIF,CAAO,GAC5F,KAAK,WAAW,KAAK,CAAC,GACtB,KAAK,iBAAiB,KAAKZ,CAAqB,GACzCiB;CACT;CAIA,QAAc;EAGZ,AAFA,KAAK,eAAe,SAAS,GAC7B,KAAK,WAAW,SAAS,GACzB,KAAK,iBAAiB,SAAS;CACjC;CAEA,MAAY;EACV,IAAI,KAAK,eAAe,UAAU,GAChC,MAAU,MAAM,uCAAuC;EAIzD,AAFA,KAAK,eAAe,IAAI,GACxB,KAAK,WAAW,IAAI,GACpB,KAAK,iBAAiB,IAAI;CAC5B;AACF"}

package/dist/renderer/strokeLengths.js

@@ -1,50 +0,0 @@
-import { strokeSpaceOf as e } from "../features/paths/tessellate/metric.js";
-import { resolveStrokeWidth as t } from "../features/paths/tessellate/stroke.js";
-import { resolveMarkerSize as n } from "../core/markerInset.js";
-import { quantizeStrokeScale as r } from "./cache/strokeMeshCache.js";
-//#region src/renderer/strokeLengths.ts
-var i = {};
-function a(n, a) {
-	let c = a.stroke, { markerStart: l, markerMid: u, markerEnd: d } = c;
-	if (typeof c.width != "object" && !o(l) && !o(u) && !o(d)) return {
-		cmd: a,
-		spaces: i
-	};
-	let f = { ...c }, { scale: p, metric: m } = e(n[0], n[1], n[3], n[4]), h = (e) => m === null ? void 0 : {
-		metric: m,
-		pxPerUnit: e
-	}, g;
-	if (typeof c.width == "object") {
-		let e = r(c.width.px, p);
-		f.width = t(c.width, e), c.dash && e > 0 && (f.dash = c.dash.map((t) => t / e)), g = h(e);
-	}
-	let _ = (e) => {
-		if (e === void 0 || typeof e == "string" || e.size === void 0) return g;
-		if (typeof e.size != "number") return h(r(e.size.px, p));
-	}, v = {
-		ribbon: g,
-		start: _(l),
-		mid: _(u),
-		end: _(d)
-	};
-	return o(l) && (f.markerStart = s(l, p)), o(u) && (f.markerMid = s(u, p)), o(d) && (f.markerEnd = s(d, p)), {
-		cmd: {
-			...a,
-			stroke: f
-		},
-		spaces: v
-	};
-}
-function o(e) {
-	return typeof e == "object" && typeof e.size == "object";
-}
-function s(e, t) {
-	return {
-		...e,
-		size: n(e, 0, r(e.size.px, t))
-	};
-}
-//#endregion
-export { a as resolveStrokeLengths };
-
-//# sourceMappingURL=strokeLengths.js.map

package/dist/renderer/strokeLengths.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strokeLengths.js","names":["WORLD","resolveStrokeLengths","stroke","cmd","isPxMarker","markerStart","markerMid","markerEnd","resolved","strokeSpaceOf","transform","screen","metric","ribbon","pxPerUnit","quantizeStrokeScale","scale","resolveStrokeWidth","d","head","ref","spaces","resolvedMarker","resolveMarkerSize"],"sources":["../../src/renderer/strokeLengths.ts"],"sourcesContent":["import type { FillStyle, MarkerRef, Stroke } from '@weasel-js/paint';\nimport type { PathDrawCommand } from './DrawCommand';\nimport type { GlMat3 } from './math/mat3';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport {\n  strokeSpaceOf, type ScreenSpace, type StrokeSpaces,\n} from 'features/paths/tessellate/metric';\nimport { quantizeStrokeScale } from './cache/strokeMeshCache';\nimport { resolveMarkerSize } from '../core/markerInset';\n\n/** A path command whose stroke paints. */\nexport type StrokedPathCommand = PathDrawCommand & { stroke: Stroke & { paint: FillStyle } };\n\n/** A stroke command ready to tessellate, and the spaces to tessellate it in. */\nexport interface ResolvedStrokeCommand {\n  cmd: StrokedPathCommand;\n  /** Where the ribbon and each head are built; every length in `cmd` is\n   *  measured in the space of the part it belongs to. */\n  spaces: StrokeSpaces;\n}\n\nconst WORLD: StrokeSpaces = {};\n\n/**\n * `cmd` with its `{ px }` lengths — the stroke width, any marker size, and on a\n * `{ px }` stroke its dashes — resolved against the accumulated transform's\n * quantized scale, so everything downstream (the ribbon cache key, the insets,\n * the heads) sees plain numbers.\n *\n * Under a transform that stretches one direction more than another, each\n * screen-sized part is also built in the transform's stretch, where lengths\n * measure as they do on screen, so it is exact across, down and on every\n * diagonal rather than right only on average. World-sized parts stay in world.\n */\nexport function resolveStrokeLengths(transform: GlMat3, cmd: StrokedPathCommand): ResolvedStrokeCommand {\n  const stroke = cmd.stroke;\n  const { markerStart, markerMid, markerEnd } = stroke;\n  if (typeof stroke.width !== 'object' && !isPxMarker(markerStart)\n    && !isPxMarker(markerMid) && !isPxMarker(markerEnd)) {\n    return { cmd, spaces: WORLD };\n  }\n  const resolved: Stroke & { paint: FillStyle } = { ...stroke };\n  const { scale, metric } = strokeSpaceOf(transform[0], transform[1], transform[3], transform[4]);\n  const screen = (pxPerUnit: number): ScreenSpace | undefined =>\n    metric === null ? undefined : { metric, pxPerUnit };\n  let ribbon: ScreenSpace | undefined;\n  if (typeof stroke.width === 'object') {\n    const pxPerUnit = quantizeStrokeScale(stroke.width.px, scale);\n    resolved.width = resolveStrokeWidth(stroke.width, pxPerUnit);\n    if (stroke.dash && pxPerUnit > 0) resolved.dash = stroke.dash.map((d) => d / pxPerUnit);\n    ribbon = screen(pxPerUnit);\n  }\n  const head = (ref: MarkerRef | undefined): ScreenSpace | undefined => {\n    if (ref === undefined || typeof ref === 'string' || ref.size === undefined) return ribbon;\n    if (typeof ref.size === 'number') return undefined;\n    return screen(quantizeStrokeScale(ref.size.px, scale));\n  };\n  const spaces = { ribbon, start: head(markerStart), mid: head(markerMid), end: head(markerEnd) };\n  if (isPxMarker(markerStart)) resolved.markerStart = resolvedMarker(markerStart, scale);\n  if (isPxMarker(markerMid)) resolved.markerMid = resolvedMarker(markerMid, scale);\n  if (isPxMarker(markerEnd)) resolved.markerEnd = resolvedMarker(markerEnd, scale);\n  return { cmd: { ...cmd, stroke: resolved }, spaces };\n}\n\ntype PxMarker = Exclude<MarkerRef, string> & { size: { px: number } };\n\nfunction isPxMarker(ref: MarkerRef | undefined): ref is PxMarker {\n  return typeof ref === 'object' && typeof ref.size === 'object';\n}\n\nfunction resolvedMarker(ref: PxMarker, scale: number): MarkerRef {\n  return { ...ref, size: resolveMarkerSize(ref, 0, quantizeStrokeScale(ref.size.px, scale)) };\n}\n"],"mappings":";;;;;AAqBA,IAAMA,IAAsB,CAAC;AAa7B,SAAgBC,EAAqB,GAAmB,GAAgD;CACtG,IAAMC,IAASC,EAAI,QACb,EAAE,gBAAa,cAAW,iBAAcD;CAC9C,IAAI,OAAOA,EAAO,SAAU,YAAY,CAACE,EAAWC,CAAW,KAC1D,CAACD,EAAWE,CAAS,KAAK,CAACF,EAAWG,CAAS,GAClD,OAAO;EAAE;EAAK,QAAQP;CAAM;CAE9B,IAAMQ,IAA0C,EAAE,GAAGN,EAAO,GACtD,EAAE,UAAO,cAAWO,EAAcC,EAAU,IAAIA,EAAU,IAAIA,EAAU,IAAIA,EAAU,EAAE,GACxFC,KAAU,MACdC,MAAW,OAAO,KAAA,IAAY;EAAE;EAAQ;CAAU,GAChDC;CACJ,IAAI,OAAOX,EAAO,SAAU,UAAU;EACpC,IAAMY,IAAYC,EAAoBb,EAAO,MAAM,IAAIc,CAAK;EAG5D,AAFA,EAAS,QAAQC,EAAmBf,EAAO,OAAOY,CAAS,GACvDZ,EAAO,QAAQY,IAAY,MAAG,EAAS,OAAOZ,EAAO,KAAK,KAAK,MAAMgB,IAAIJ,CAAS,IACtF,IAASH,EAAOG,CAAS;CAC3B;CACA,IAAMK,KAAQ,MAAwD;EACpE,IAAIC,MAAQ,KAAA,KAAa,OAAOA,KAAQ,YAAYA,EAAI,SAAS,KAAA,GAAW,OAAOP;EACnF,IAAI,OAAOO,EAAI,QAAS,UACxB,OAAOT,EAAOI,EAAoBK,EAAI,KAAK,IAAIJ,CAAK,CAAC;CACvD,GACMK,IAAS;EAAE;EAAQ,OAAOF,EAAKd,CAAW;EAAG,KAAKc,EAAKb,CAAS;EAAG,KAAKa,EAAKZ,CAAS;CAAE;CAI9F,OAHIH,EAAWC,CAAW,MAAG,EAAS,cAAciB,EAAejB,GAAaW,CAAK,IACjFZ,EAAWE,CAAS,MAAG,EAAS,YAAYgB,EAAehB,GAAWU,CAAK,IAC3EZ,EAAWG,CAAS,MAAG,EAAS,YAAYe,EAAef,GAAWS,CAAK,IACxE;EAAE,KAAK;GAAE,GAAGb;GAAK,QAAQK;EAAS;EAAG;CAAO;AACrD;AAIA,SAASJ,EAAW,GAA6C;CAC/D,OAAO,OAAOgB,KAAQ,YAAY,OAAOA,EAAI,QAAS;AACxD;AAEA,SAASE,EAAe,GAAe,GAA0B;CAC/D,OAAO;EAAE,GAAGF;EAAK,MAAMG,EAAkBH,GAAK,GAAGL,EAAoBK,EAAI,KAAK,IAAIJ,CAAK,CAAC;CAAE;AAC5F"}

package/dist/renderer/syntheticItalic.js

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

package/dist/renderer/syntheticItalic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntheticItalic.js","names":["SYNTHETIC_ITALIC_RADIANS"],"sources":["../../src/renderer/syntheticItalic.ts"],"sourcesContent":["/**\n * Synthetic-oblique angle, in radians — 12°, the conventional CSS\n * `font-style: oblique`. Shared by everything that fakes an italic: the SDF\n * tier skews quads by it, the outline tier shears glyph geometry by it, and\n * `textToPath` bakes the same shear into extracted outlines. One constant so a\n * face that falls back to the upright atlas leans the same amount however it\n * ends up being drawn.\n */\nexport const SYNTHETIC_ITALIC_RADIANS = 0.2094;\n"],"mappings":";AAQA,IAAaA,IAA2B"}

package/dist/renderer/textures/registerTexture.js

@@ -1,14 +0,0 @@
-import { createReflectable as e } from "@weasel-js/registry";
-//#region src/renderer/textures/registerTexture.ts
-var t = 0, n = e(), r = n.reflection;
-function i(e) {
-	return n.get(e) ?? null;
-}
-function a(e) {
-	let r = `tex_${++t}`;
-	return n.set(r, { source: e }), { id: r };
-}
-//#endregion
-export { i as getTexture, a as registerTexture, r as textureRegistry };
-
-//# sourceMappingURL=registerTexture.js.map

package/dist/renderer/textures/registerTexture.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerTexture.js","names":["counter","registry","createReflectable","textureRegistry","getTexture","id","registerTexture","image"],"sources":["../../../src/renderer/textures/registerTexture.ts"],"sourcesContent":["/**\n * registerTexture — accepts an image source, assigns an opaque id, stores in\n * a module-level registry. Actual GL upload happens lazily at draw time in\n * drawShader() via GLTextureCache.upload (which is idempotent).\n *\n * Lifecycle: textures live for the renderer's lifetime. No unregister in v1.\n *\n * Convention §9: this registry stores image data only — no per-renderer state.\n * Each WeaselRenderer's GLTextureCache does its own dedup via has(id).\n */\n\nimport type { TextureHandle } from '@weasel-js/paint';\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\n\nexport type { TextureHandle };\n\n/** A registered texture's image source, uploaded to GL lazily at first draw. */\nexport interface TextureEntry {\n  source: HTMLImageElement | ImageBitmap;\n}\n\nlet counter = 0;\nconst registry = createReflectable<TextureEntry>();\n\n/** Every registered texture, keyed by its handle id. */\nexport const textureRegistry: Reflection<TextureEntry> = registry.reflection;\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetTextureRegistryForTests(): void {\n  registry.clear();\n  counter = 0;\n}\n\nexport function getTexture(id: string): TextureEntry | null {\n  return registry.get(id) ?? null;\n}\n\n/**\n * Register an image for use as a shader texture uniform.\n *\n * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.\n * The handle is valid for the lifetime of the renderer it will be used with.\n *\n * @param image  The image to register. HTMLImageElement must be fully loaded.\n * @returns      Opaque TextureHandle.\n */\nexport function registerTexture(\n  image: HTMLImageElement | ImageBitmap,\n): TextureHandle {\n  const id = `tex_${++counter}`;\n  registry.set(id, { source: image });\n  return { id };\n}\n"],"mappings":";;AAqBA,IAAIA,IAAU,GACRC,IAAWC,EAAgC,GAGpCC,IAA4CF,EAAS;AAQlE,SAAgBG,EAAW,GAAiC;CAC1D,OAAOH,EAAS,IAAII,CAAE,KAAK;AAC7B;AAWA,SAAgBC,EACd,GACe;CACf,IAAMD,IAAK,OAAO,EAAEL;CAEpB,OADAC,EAAS,IAAII,GAAI,EAAE,QAAQE,EAAM,CAAC,GAC3B,EAAE,MAAG;AACd"}

package/dist/scheduling/useVisibleRaf.js

@@ -1,69 +0,0 @@
-import { useCallback as e, useLayoutEffect as t, useMemo as n, useRef as r } from "react";
-import { useLatest as i } from "@weasel-js/react";
-//#region src/scheduling/useVisibleRaf.ts
-var a = () => typeof document < "u" && document.hidden, o = (e) => typeof e == "function" ? e() : e?.current ?? null;
-function s(s, c = {}) {
-	let l = i(s), u = i(c), d = r(null), f = r(!1), p = r(!1), m = r(!0), h = r(!0), g = r(null), _ = r(null), v = e(() => u.current.dangerouslyRunWhenHidden === !0 || !a() && h.current, [u]), y = e(() => {
-		d.current !== null && ((u.current.cancelFrame ?? cancelAnimationFrame)(d.current), d.current = null);
-	}, [u]), b = e(() => {
-		d.current === null && m.current && (d.current = (u.current.requestFrame ?? requestAnimationFrame)((e) => {
-			d.current = null, m.current && f.current && v() && (f.current = !1, l.current(e));
-		}));
-	}, [
-		l,
-		v,
-		u
-	]), x = e(() => {
-		let e = g.current;
-		if (!e) return;
-		let t = o(u.current.target);
-		t !== _.current && (_.current && e.unobserve(_.current), _.current = t, h.current = !0, t && e.observe(t));
-	}, [u]), S = e(() => {
-		if (!v()) {
-			if (p.current) return;
-			p.current = !0, y();
-			return;
-		}
-		p.current && (p.current = !1, m.current && (u.current.onResume?.(), f.current && b()));
-	}, [
-		y,
-		v,
-		u,
-		b
-	]), C = e(() => {
-		if (m.current) {
-			if (x(), f.current = !0, !v()) {
-				p.current = !0;
-				return;
-			}
-			b();
-		}
-	}, [
-		v,
-		b,
-		x
-	]), w = e(() => {
-		f.current = !1, y();
-	}, [y]);
-	return t(() => (m.current = !0, document.addEventListener("visibilitychange", S), typeof IntersectionObserver < "u" && (g.current = new IntersectionObserver((e) => {
-		h.current = e.some((e) => e.isIntersecting), S();
-	}), x()), () => {
-		m.current = !1, document.removeEventListener("visibilitychange", S), g.current?.disconnect(), g.current = null, _.current = null, h.current = !0, y(), f.current = !1, p.current = !1;
-	}), [
-		y,
-		S,
-		x
-	]), n(() => ({
-		request: C,
-		cancel: w,
-		isVisible: v
-	}), [
-		C,
-		w,
-		v
-	]);
-}
-//#endregion
-export { s as useVisibleRaf };
-
-//# sourceMappingURL=useVisibleRaf.js.map

package/dist/scheduling/useVisibleRaf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useVisibleRaf.js","names":["documentHidden","resolveTarget","target","useVisibleRaf","frameRef","useLatest","frame","optsRef","options","rafRef","useRef","pendingRef","suspendedRef","aliveRef","intersectingRef","observerRef","observedRef","isVisible","useCallback","cancelRaf","scheduleRaf","time","syncObserver","io","el","syncGate","request","cancel","useLayoutEffect","entries","useMemo"],"sources":["../../src/scheduling/useVisibleRaf.ts"],"sourcesContent":["/**\n * The one place weasel decides whether a frame may run, so that \"a loop does no\n * work nobody can see\" holds by construction rather than by every loop author\n * remembering. Nothing runs while the document is hidden; a loop that names an\n * element also stops while that element is outside the viewport.\n *\n * A request made while suspended is held, not dropped, and re-armed when the\n * surface comes back — so a loop never needs to poll visibility itself.\n */\n\nimport { type RefObject, useCallback, useLayoutEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\n\n/** What a loop names as its element, resolved every time the gate is consulted\n *  so a ref filled in after mount still starts the observer. */\nexport type VisibleRafTarget = RefObject<Element | null> | (() => Element | null);\n\n/** Options for {@link useVisibleRaf}. */\nexport interface VisibleRafOptions {\n  /** Also gate on this element's intersection with the viewport. Omit it and\n   *  the loop is gated on document visibility alone. */\n  target?: VisibleRafTarget;\n  /**\n   * Run frames regardless of visibility. The escape hatch for a loop that is\n   * not painting for a viewer — an offscreen recording, an export driving its\n   * own frames. It is the wrong fix for a loop that stalls after a tab switch:\n   * that is a missing `request()`, and setting this hides it.\n   */\n  dangerouslyRunWhenHidden?: boolean;\n  /** Frame clock. Read live, so a test may inject one after mount. */\n  requestFrame?: (cb: FrameRequestCallback) => number;\n  cancelFrame?: (handle: number) => void;\n  /**\n   * Runs once when the loop leaves suspension, before the frame that follows\n   * it. Where a loop that measures elapsed time drops the interval it spent\n   * suspended — without it, an hour hidden arrives as one hour-long frame.\n   */\n  onResume?: () => void;\n}\n\n/** The handle {@link useVisibleRaf} returns. Nothing runs until `request()` is called. */\nexport interface VisibleRaf {\n  /** Ask for a frame. Idempotent while one is outstanding, and held rather than\n   *  dropped while suspended. Identity is stable for the component's lifetime. */\n  request(): void;\n  /** Drop the outstanding request, held or scheduled. */\n  cancel(): void;\n  /** Whether a frame would run right now. */\n  isVisible(): boolean;\n}\n\nconst documentHidden = (): boolean => typeof document !== 'undefined' && document.hidden;\n\nconst resolveTarget = (target: VisibleRafTarget | undefined): Element | null =>\n  typeof target === 'function' ? target() : (target?.current ?? null);\n\n/**\n * @param frame Runs on the frame, with the timestamp the clock supplied.\n *   A continuous loop calls `request()` again from inside it; a one-shot loop\n *   does not.\n */\nexport function useVisibleRaf(\n  frame: (time: number) => void,\n  options: VisibleRafOptions = {},\n): VisibleRaf {\n  const frameRef = useLatest(frame);\n  const optsRef = useLatest(options);\n\n  const rafRef = useRef<number | null>(null);\n  const pendingRef = useRef(false);\n  const suspendedRef = useRef(false);\n  const aliveRef = useRef(true);\n  const intersectingRef = useRef(true);\n  const observerRef = useRef<IntersectionObserver | null>(null);\n  const observedRef = useRef<Element | null>(null);\n\n  const isVisible = useCallback(\n    (): boolean =>\n      optsRef.current.dangerouslyRunWhenHidden === true ||\n      (!documentHidden() && intersectingRef.current),\n    [optsRef],\n  );\n\n  const cancelRaf = useCallback(() => {\n    if (rafRef.current === null) return;\n    (optsRef.current.cancelFrame ?? cancelAnimationFrame)(rafRef.current);\n    rafRef.current = null;\n  }, [optsRef]);\n\n  const scheduleRaf = useCallback(() => {\n    if (rafRef.current !== null || !aliveRef.current) return;\n    rafRef.current = (optsRef.current.requestFrame ?? requestAnimationFrame)((time) => {\n      // Released before the frame runs, so a `request()` issued from inside it\n      // schedules the next one instead of being swallowed.\n      rafRef.current = null;\n      if (!aliveRef.current || !pendingRef.current || !isVisible()) return;\n      pendingRef.current = false;\n      frameRef.current(time);\n    });\n  }, [frameRef, isVisible, optsRef]);\n\n  /** Attaches the observer once the named element exists. Ref callbacks and\n   *  lazily-mounted hosts fill their refs after this hook's effect has run. */\n  const syncObserver = useCallback(() => {\n    const io = observerRef.current;\n    if (!io) return;\n    const el = resolveTarget(optsRef.current.target);\n    if (el === observedRef.current) return;\n    if (observedRef.current) io.unobserve(observedRef.current);\n    observedRef.current = el;\n    // An element that has gone away stops gating rather than stopping the loop.\n    intersectingRef.current = true;\n    if (el) io.observe(el);\n  }, [optsRef]);\n\n  /** Re-reads the gate after something that could have changed it. Suspending\n   *  drops the outstanding frame but keeps the request; resuming hands the\n   *  loop its rebase before re-arming. */\n  const syncGate = useCallback(() => {\n    if (!isVisible()) {\n      if (suspendedRef.current) return;\n      suspendedRef.current = true;\n      cancelRaf();\n      return;\n    }\n    if (!suspendedRef.current) return;\n    suspendedRef.current = false;\n    if (!aliveRef.current) return;\n    optsRef.current.onResume?.();\n    if (pendingRef.current) scheduleRaf();\n  }, [cancelRaf, isVisible, optsRef, scheduleRaf]);\n\n  const request = useCallback(() => {\n    if (!aliveRef.current) return;\n    syncObserver();\n    pendingRef.current = true;\n    if (!isVisible()) {\n      suspendedRef.current = true;\n      return;\n    }\n    scheduleRaf();\n  }, [isVisible, scheduleRaf, syncObserver]);\n\n  const cancel = useCallback(() => {\n    pendingRef.current = false;\n    cancelRaf();\n  }, [cancelRaf]);\n\n  // Re-armed in setup because the refs survive StrictMode's simulated remount, and\n  // a layout effect so the arming precedes the host's own layout effects — a loop\n  // driven from one of those would otherwise be declined on the second mount.\n  useLayoutEffect(() => {\n    aliveRef.current = true;\n    document.addEventListener('visibilitychange', syncGate);\n    if (typeof IntersectionObserver !== 'undefined') {\n      observerRef.current = new IntersectionObserver((entries) => {\n        intersectingRef.current = entries.some((e) => e.isIntersecting);\n        syncGate();\n      });\n      syncObserver();\n    }\n    return () => {\n      aliveRef.current = false;\n      document.removeEventListener('visibilitychange', syncGate);\n      observerRef.current?.disconnect();\n      observerRef.current = null;\n      observedRef.current = null;\n      intersectingRef.current = true;\n      cancelRaf();\n      pendingRef.current = false;\n      suspendedRef.current = false;\n    };\n  }, [cancelRaf, syncGate, syncObserver]);\n\n  // Stable identity: `requestRedraw` and friends outlive the render that made\n  // them, and consumers capture the handle.\n  return useMemo(() => ({ request, cancel, isVisible }), [request, cancel, isVisible]);\n}\n"],"mappings":";;;AAmDA,IAAMA,UAAgC,OAAO,WAAa,OAAe,SAAS,QAE5EC,KAAiB,MACrB,OAAOC,KAAW,aAAaA,EAAO,IAAKA,GAAQ,WAAW;AAOhE,SAAgBC,EACd,GACA,IAA6B,CAAC,GAClB;CACZ,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAUF,EAAUG,CAAO,GAE3BC,IAASC,EAAsB,IAAI,GACnCC,IAAaD,EAAO,EAAK,GACzBE,IAAeF,EAAO,EAAK,GAC3BG,IAAWH,EAAO,EAAI,GACtBI,IAAkBJ,EAAO,EAAI,GAC7BK,IAAcL,EAAoC,IAAI,GACtDM,IAAcN,EAAuB,IAAI,GAEzCO,IAAYC,QAEdX,EAAQ,QAAQ,6BAA6B,MAC5C,CAACP,EAAe,KAAKc,EAAgB,SACxC,CAACP,CAAO,CACV,GAEMY,IAAYD,QAAkB;EAClC,AAAIT,EAAO,YAAY,UACtBF,EAAQ,QAAQ,eAAe,qBAAA,CAAsBE,EAAO,OAAO,GACpE,EAAO,UAAU;CACnB,GAAG,CAACF,CAAO,CAAC,GAENa,IAAcF,QAAkB;EACpC,AAAIT,EAAO,YAAY,QAASI,EAAS,YACzC,EAAO,WAAWN,EAAQ,QAAQ,gBAAgB,sBAAA,EAAwB,MAAS;GAIjF,AADA,EAAO,UAAU,MACZM,EAAS,WAAYF,EAAW,WAAYM,EAAU,MAC3D,EAAW,UAAU,IACrBb,EAAS,QAAQiB,CAAI;EACvB,CAAC;CACH,GAAG;EAACjB;EAAUa;EAAWV;CAAO,CAAC,GAI3Be,IAAeJ,QAAkB;EACrC,IAAMK,IAAKR,EAAY;EACvB,IAAI,CAACQ,GAAI;EACT,IAAMC,IAAKvB,EAAcM,EAAQ,QAAQ,MAAM;EAC/C,AAAIiB,MAAOR,EAAY,YACnBA,EAAY,WAASO,EAAG,UAAUP,EAAY,OAAO,GACzD,EAAY,UAAUQ,GAEtB,EAAgB,UAAU,IACtBA,KAAID,EAAG,QAAQC,CAAE;CACvB,GAAG,CAACjB,CAAO,CAAC,GAKNkB,IAAWP,QAAkB;EACjC,IAAI,CAACD,EAAU,GAAG;GAChB,IAAIL,EAAa,SAAS;GAE1B,AADA,EAAa,UAAU,IACvBO,EAAU;GACV;EACF;EACA,AAAKP,EAAa,YAClB,EAAa,UAAU,IAClBC,EAAS,YACdN,EAAQ,QAAQ,WAAW,GACvBI,EAAW,WAASS,EAAY;CACtC,GAAG;EAACD;EAAWF;EAAWV;EAASa;CAAW,CAAC,GAEzCM,IAAUR,QAAkB;EAChC,IAAKL,EAAS,SAGd;OAFAS,EAAa,GACb,EAAW,UAAU,IACjB,CAACL,EAAU,GAAG;IAChB,EAAa,UAAU;IACvB;GACF;GACA,EAAY;EADZ;CAEF,GAAG;EAACA;EAAWG;EAAaE;CAAY,CAAC,GAEnCK,IAAST,QAAkB;EAE/B,AADA,EAAW,UAAU,IACrBC,EAAU;CACZ,GAAG,CAACA,CAAS,CAAC;CA8Bd,OAzBAS,SACE,EAAS,UAAU,IACnB,SAAS,iBAAiB,oBAAoBH,CAAQ,GAClD,OAAO,uBAAyB,QAClC,EAAY,UAAU,IAAI,sBAAsB,MAAY;EAE1D,AADA,EAAgB,UAAUI,EAAQ,MAAM,MAAM,EAAE,cAAc,GAC9DJ,EAAS;CACX,CAAC,GACDH,EAAa,UAEF;EASX,AARA,EAAS,UAAU,IACnB,SAAS,oBAAoB,oBAAoBG,CAAQ,GACzDV,EAAY,SAAS,WAAW,GAChC,EAAY,UAAU,MACtB,EAAY,UAAU,MACtB,EAAgB,UAAU,IAC1BI,EAAU,GACV,EAAW,UAAU,IACrB,EAAa,UAAU;CACzB,IACC;EAACA;EAAWM;EAAUH;CAAY,CAAC,GAI/BQ,SAAe;EAAE;EAAS;EAAQ;CAAU,IAAI;EAACJ;EAASC;EAAQV;CAAS,CAAC;AACrF"}