@weasel-js/core 1.9.3 → 1.10.0

package/dist/renderer/shaders/ShaderProgram.js

@@ -1,74 +0,0 @@
-//#region src/renderer/shaders/ShaderProgram.ts
-var e = class extends Error {
-	stage;
-	log;
-	constructor(e, t) {
-		super(`shader ${e} failure: ${t}`), this.stage = e, this.log = t, this.name = "ShaderCompileError";
-	}
-}, t = class {
-	gl;
-	handle;
-	uniforms = /* @__PURE__ */ new Map();
-	arrays = /* @__PURE__ */ new Map();
-	attributes = /* @__PURE__ */ new Map();
-	constructor(t, n, r) {
-		this.gl = t;
-		let i = this.compile(t.VERTEX_SHADER, n, "vertex"), a;
-		try {
-			a = this.compile(t.FRAGMENT_SHADER, r, "fragment");
-		} catch (e) {
-			throw t.deleteShader(i), e;
-		}
-		let o = t.createProgram();
-		if (!o) throw t.deleteShader(i), t.deleteShader(a), Error("createProgram returned null");
-		if (t.attachShader(o, i), t.attachShader(o, a), t.linkProgram(o), t.deleteShader(i), t.deleteShader(a), !t.getProgramParameter(o, t.LINK_STATUS)) {
-			let n = t.getProgramInfoLog(o) ?? "";
-			throw t.deleteProgram(o), new e("link", n);
-		}
-		this.handle = o;
-	}
-	compile(t, n, r) {
-		let i = this.gl, a = i.createShader(t);
-		if (!a) throw Error("createShader returned null");
-		if (i.shaderSource(a, n), i.compileShader(a), !i.getShaderParameter(a, i.COMPILE_STATUS)) {
-			let t = i.getShaderInfoLog(a) ?? "";
-			throw i.deleteShader(a), new e(r, t);
-		}
-		return a;
-	}
-	lookupUniforms(e) {
-		for (let t of e) {
-			let e = this.gl.getUniformLocation(this.handle, t);
-			e !== null && this.uniforms.set(t, e);
-		}
-	}
-	lookupUniformArrays(e) {
-		for (let [t, { type: n, size: r }] of e) {
-			let e = `${t}[0]`, i = this.uniforms.get(e) ?? this.gl.getUniformLocation(this.handle, e);
-			i !== null && this.arrays.set(t, {
-				type: n,
-				size: r,
-				location: i
-			});
-		}
-	}
-	lookupAttributes(e) {
-		for (let t of e) {
-			let e = this.gl.getAttribLocation(this.handle, t);
-			e >= 0 && this.attributes.set(t, e);
-		}
-	}
-	uniform(e) {
-		return this.uniforms.get(e);
-	}
-	uniformArray(e) {
-		return this.arrays.get(e);
-	}
-	attribute(e) {
-		return this.attributes.get(e);
-	}
-};
-//#endregion
-export { e as ShaderCompileError, t as ShaderProgram };
-
-//# sourceMappingURL=ShaderProgram.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ShaderProgram.js","names":["ShaderCompileError","stage","log","ShaderProgram","gl","vs","vertSrc","fs","fragSrc","program","shader","type","source","name","names","loc","decls","base","location"],"sources":["../../../src/renderer/shaders/ShaderProgram.ts"],"sourcesContent":["/**\n * Minimal compile/link/lookup wrapper for a GL program. Throws\n * `ShaderCompileError` on compile or link failure with the GL info log\n * embedded in the error message — never returns a half-initialized program.\n *\n * Designed so test code can stub `getShaderParameter` / `getProgramParameter`\n * via the recorder Proxy without further special-casing.\n */\n\nexport type Stage = 'vertex' | 'fragment' | 'link';\n\n/** Thrown when a shader fails to compile or link, carrying which stage failed\n *  and the driver's log. */\nexport class ShaderCompileError extends Error {\n  constructor(public readonly stage: Stage, public readonly log: string) {\n    super(`shader ${stage} failure: ${log}`);\n    this.name = 'ShaderCompileError';\n  }\n}\n\n/** An array uniform a program can be written as a whole: its element type as\n *  declared, its declared length, and the location of slot 0. */\nexport interface UniformArray {\n  readonly type: string;\n  readonly size: number;\n  readonly location: WebGLUniformLocation;\n}\n\n/** A linked GL program with its uniform and attribute locations cached by name. */\nexport class ShaderProgram {\n  readonly handle: WebGLProgram;\n  private readonly uniforms = new Map<string, WebGLUniformLocation>();\n  private readonly arrays = new Map<string, UniformArray>();\n  private readonly attributes = new Map<string, number>();\n\n  constructor(\n    private readonly gl: WebGL2RenderingContext,\n    vertSrc: string,\n    fragSrc: string,\n  ) {\n    const vs = this.compile(gl.VERTEX_SHADER, vertSrc, 'vertex');\n    let fs: WebGLShader;\n    try {\n      fs = this.compile(gl.FRAGMENT_SHADER, fragSrc, 'fragment');\n    } catch (e) {\n      gl.deleteShader(vs);\n      throw e;\n    }\n    const program = gl.createProgram();\n    if (!program) {\n      gl.deleteShader(vs);\n      gl.deleteShader(fs);\n      throw new Error('createProgram returned null');\n    }\n    gl.attachShader(program, vs);\n    gl.attachShader(program, fs);\n    gl.linkProgram(program);\n    // Flagged for deletion, attached shaders live exactly as long as the\n    // program, so `deleteProgram` frees them too.\n    gl.deleteShader(vs);\n    gl.deleteShader(fs);\n    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {\n      const log = gl.getProgramInfoLog(program) ?? '';\n      gl.deleteProgram(program);\n      throw new ShaderCompileError('link', log);\n    }\n    this.handle = program;\n  }\n\n  private compile(type: number, source: string, stage: Stage): WebGLShader {\n    const gl = this.gl;\n    const shader = gl.createShader(type);\n    if (!shader) throw new Error('createShader returned null');\n    gl.shaderSource(shader, source);\n    gl.compileShader(shader);\n    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {\n      const log = gl.getShaderInfoLog(shader) ?? '';\n      gl.deleteShader(shader);\n      throw new ShaderCompileError(stage, log);\n    }\n    return shader;\n  }\n\n  lookupUniforms(names: readonly string[]): void {\n    for (const name of names) {\n      const loc = this.gl.getUniformLocation(this.handle, name);\n      if (loc !== null) this.uniforms.set(name, loc);\n    }\n  }\n\n  /** Record each array's slot-0 location under its bare name. An array the\n   *  driver optimized away has no location and is left out. */\n  lookupUniformArrays(decls: ReadonlyMap<string, { type: string; size: number }>): void {\n    for (const [name, { type, size }] of decls) {\n      const base = `${name}[0]`;\n      const location = this.uniforms.get(base) ?? this.gl.getUniformLocation(this.handle, base);\n      if (location !== null) this.arrays.set(name, { type, size, location });\n    }\n  }\n\n  lookupAttributes(names: readonly string[]): void {\n    for (const name of names) {\n      const loc = this.gl.getAttribLocation(this.handle, name);\n      if (loc >= 0) this.attributes.set(name, loc);\n    }\n  }\n\n  uniform(name: string): WebGLUniformLocation | undefined {\n    return this.uniforms.get(name);\n  }\n\n  uniformArray(name: string): UniformArray | undefined {\n    return this.arrays.get(name);\n  }\n\n  attribute(name: string): number | undefined {\n    return this.attributes.get(name);\n  }\n}\n"],"mappings":";AAaA,IAAaA,IAAb,cAAwC,MAAM;CAChB;CAA8B;CAA1D,YAAY,GAA8B,GAA6B;EAErE,AADA,MAAM,UAAUC,EAAM,YAAYC,GAAK,GADb,KAAA,QAAAD,GAA8B,KAAA,MAAAC,GAExD,KAAK,OAAO;CACd;AACF,GAWaC,IAAb,MAA2B;CAON;CANnB;CACA,2BAA4B,IAAI,IAAkC;CAClE,yBAA0B,IAAI,IAA0B;CACxD,6BAA8B,IAAI,IAAoB;CAEtD,YACE,GACA,GACA,GACA;EAHiB,KAAA,KAAAC;EAIjB,IAAMC,IAAK,KAAK,QAAQD,EAAG,eAAeE,GAAS,QAAQ,GACvDC;EACJ,IAAI;GACF,IAAK,KAAK,QAAQH,EAAG,iBAAiBI,GAAS,UAAU;EAC3D,SAAS,GAAG;GAEV,MADAJ,EAAG,aAAaC,CAAE,GACZ;EACR;EACA,IAAMI,IAAUL,EAAG,cAAc;EACjC,IAAI,CAACK,GAGH,MAFAL,EAAG,aAAaC,CAAE,GAClBD,EAAG,aAAaG,CAAE,GACR,MAAM,6BAA6B;EAS/C,IAPAH,EAAG,aAAaK,GAASJ,CAAE,GAC3BD,EAAG,aAAaK,GAASF,CAAE,GAC3BH,EAAG,YAAYK,CAAO,GAGtBL,EAAG,aAAaC,CAAE,GAClBD,EAAG,aAAaG,CAAE,GACd,CAACH,EAAG,oBAAoBK,GAASL,EAAG,WAAW,GAAG;GACpD,IAAMF,IAAME,EAAG,kBAAkBK,CAAO,KAAK;GAE7C,MADAL,EAAG,cAAcK,CAAO,GAClB,IAAIT,EAAmB,QAAQE,CAAG;EAC1C;EACA,KAAK,SAASO;CAChB;CAEA,QAAgB,GAAc,GAAgB,GAA2B;EACvE,IAAML,IAAK,KAAK,IACVM,IAASN,EAAG,aAAaO,CAAI;EACnC,IAAI,CAACD,GAAQ,MAAU,MAAM,4BAA4B;EAGzD,IAFAN,EAAG,aAAaM,GAAQE,CAAM,GAC9BR,EAAG,cAAcM,CAAM,GACnB,CAACN,EAAG,mBAAmBM,GAAQN,EAAG,cAAc,GAAG;GACrD,IAAMF,IAAME,EAAG,iBAAiBM,CAAM,KAAK;GAE3C,MADAN,EAAG,aAAaM,CAAM,GAChB,IAAIV,EAAmBC,GAAOC,CAAG;EACzC;EACA,OAAOQ;CACT;CAEA,eAAe,GAAgC;EAC7C,KAAK,IAAMG,KAAQC,GAAO;GACxB,IAAMC,IAAM,KAAK,GAAG,mBAAmB,KAAK,QAAQF,CAAI;GACxD,AAAIE,MAAQ,QAAM,KAAK,SAAS,IAAIF,GAAME,CAAG;EAC/C;CACF;CAIA,oBAAoB,GAAkE;EACpF,KAAK,IAAM,CAACF,GAAM,EAAE,SAAM,cAAWG,GAAO;GAC1C,IAAMC,IAAO,GAAGJ,EAAK,MACfK,IAAW,KAAK,SAAS,IAAID,CAAI,KAAK,KAAK,GAAG,mBAAmB,KAAK,QAAQA,CAAI;GACxF,AAAIC,MAAa,QAAM,KAAK,OAAO,IAAIL,GAAM;IAAE;IAAM;IAAM;GAAS,CAAC;EACvE;CACF;CAEA,iBAAiB,GAAgC;EAC/C,KAAK,IAAMA,KAAQC,GAAO;GACxB,IAAMC,IAAM,KAAK,GAAG,kBAAkB,KAAK,QAAQF,CAAI;GACvD,AAAIE,KAAO,KAAG,KAAK,WAAW,IAAIF,GAAME,CAAG;EAC7C;CACF;CAEA,QAAQ,GAAgD;EACtD,OAAO,KAAK,SAAS,IAAIF,CAAI;CAC/B;CAEA,aAAa,GAAwC;EACnD,OAAO,KAAK,OAAO,IAAIA,CAAI;CAC7B;CAEA,UAAU,GAAkC;EAC1C,OAAO,KAAK,WAAW,IAAIA,CAAI;CACjC;AACF"}

package/dist/renderer/shaders/batchFill.js

@@ -1,119 +0,0 @@
-import { GLYPH_COVERAGE_GLSL as e } from "@weasel-js/font";
-//#region src/renderer/shaders/batchFill.ts
-var t = 8, n = 0, r = 0, i = 3, a = 4, o = (1 / (2 * Math.PI)).toFixed(10);
-function s(e, n) {
-	return e + t * n;
-}
-var c = {
-	a_position: 0,
-	a_vertexColor: 1,
-	a_uv: 2,
-	a_post: 3,
-	a_texSlot: 4
-}, l = c;
-function u(e) {
-	let t = [];
-	for (let n = 1; n < e; n++) t.push(`  if (slot == ${n}) return texture(u_samplers[${n}], uv);`);
-	return t.join("\n");
-}
-var d = `#version 300 es
-layout(location = ${l.a_position}) in vec2 a_position;
-layout(location = ${l.a_vertexColor}) in vec4 a_vertexColor;
-layout(location = ${l.a_uv}) in vec2 a_uv;
-layout(location = ${l.a_post}) in float a_post;
-layout(location = ${l.a_texSlot}) in float a_texSlot;
-uniform mat3 u_proj;
-uniform mat3 u_model;
-out vec4 v_vertexColor;
-out vec2 v_uv;
-out float v_post;
-flat out int v_texSlot;
-flat out float v_paintMode;
-void main() {
-  vec3 screen = u_model * vec3(a_position, 1.0);
-  vec3 clip = u_proj * vec3(screen.xy, 1.0);
-  gl_Position = vec4(clip.xy, 0.0, 1.0);
-  v_vertexColor = a_vertexColor;
-  v_uv = a_uv;
-  v_post = a_post;
-  // slot + 8 * mode, unpacked — see the file header for why they share a float.
-  int packed = int(a_texSlot + 0.5);
-  v_texSlot = packed % ${t};
-  v_paintMode = float(packed / ${t});
-}
-`, f = `#version 300 es
-precision highp float;
-in vec4 v_vertexColor;
-in vec2 v_uv;
-in float v_post;
-flat in int v_texSlot;
-flat in float v_paintMode;
-uniform sampler2D u_samplers[${t}];
-uniform vec4 u_color;
-uniform float u_alpha;
-uniform float u_synthBold;
-uniform vec2 u_fieldScale[${t}];
-uniform mat4 u_colorMatrix;
-uniform vec4 u_colorBias;
-out vec4 outColor;
-
-vec4 sampleSlot(int slot, vec2 uv) {
-${u(t)}
-  return texture(u_samplers[0], uv);
-}
-${e}
-void main() {
-  float isGrad = step(2.5, v_paintMode);
-  // A radial or conic vertex carries a gradient-space coordinate rather than a
-  // texture coordinate, and its atlas row rather than an alpha. The sample is
-  // split across the branch rather than the coordinate selected before it: an
-  // arm that reads v_uv straight is a fetch the hardware can schedule against a
-  // varying, and one reading a coordinate the shader computed is not. Selecting
-  // the coordinate first and sampling once costs 29-54% of a fragment that is
-  // not a gradient; splitting it is within the measurement's own spread of free
-  // (tests/perf/fill-rate.spec.ts, teitou, 2026-10-05).
-  //
-  // Branching at all is safe here where it would not be around the glyph math:
-  // v_paintMode is flat, so every fragment of a quad takes the same arm, and
-  // nothing in either arm is a derivative.
-  vec4 texel;
-  if (isGrad > 0.5) {
-    float t = v_paintMode > 3.5
-      ? fract(atan(v_uv.y, v_uv.x) * ${o})
-      : length(v_uv);
-    texel = sampleSlot(v_texSlot, vec2(t, v_post));
-  } else {
-    texel = sampleSlot(v_texSlot, v_uv);
-  }
-  float isGlyph = step(0.5, v_paintMode) * step(v_paintMode, 2.5);
-  // Unconditional, and multiplied out afterwards rather than branched around:
-  // see the file header.
-  float coverage = glyphCoverage(texel, v_paintMode, u_synthBold, v_uv, u_fieldScale[v_texSlot]);
-  // A glyph's texel is a distance field, so it takes no part in the color; a
-  // plain vertex multiplies its texel in as it always did.
-  vec4 src = mix(texel, vec4(1.0), isGlyph) * u_color * v_vertexColor;
-  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
-  float a = mapped.a * u_alpha * mix(v_post, 1.0, isGrad) * mix(1.0, coverage, isGlyph);
-  outColor = vec4(mapped.rgb * a, a);
-}
-`, p = [
-	"u_proj",
-	"u_model",
-	"u_samplers",
-	"u_color",
-	"u_alpha",
-	"u_synthBold",
-	"u_fieldScale",
-	"u_colorMatrix",
-	"u_colorBias"
-], m = [
-	"a_position",
-	"a_vertexColor",
-	"a_uv",
-	"a_post",
-	"a_texSlot"
-];
-//#endregion
-export { c as BATCH_ATTRIBUTE_LOCATIONS, m as BATCH_FILL_ATTRIBUTES, p as BATCH_FILL_UNIFORMS, f as BATCH_FRAG_SRC, t as BATCH_TEXTURE_SLOTS, d as BATCH_VERT_SRC, a as PAINT_MODE_CONIC, r as PAINT_MODE_PLAIN, i as PAINT_MODE_RADIAL, n as WHITE_SLOT, s as packSlot };
-
-//# sourceMappingURL=batchFill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"batchFill.js","names":["BATCH_TEXTURE_SLOTS","WHITE_SLOT","PAINT_MODE_PLAIN","PAINT_MODE_RADIAL","PAINT_MODE_CONIC","INV_TAU","packSlot","slot","mode","BATCH_ATTRIBUTE_LOCATIONS","L","sampleChain","arms","i","slots","BATCH_VERT_SRC","BATCH_FRAG_SRC","GLYPH_COVERAGE_GLSL","BATCH_FILL_UNIFORMS","BATCH_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/batchFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 source for the batch program — the one shader a run of solid\n * geometry, image quads and glyphs shares.\n *\n * **Every vertex names the texture it samples.** `a_texSlot` is an index into\n * `u_samplers`, and slot 0 is always the 1x1 white texel, so a solid's\n * `texture() * a_vertexColor` is the vertex color exactly. The multiply is\n * exact: an 8-bit white texel samples to 1.0, and 1.0 * x is x.\n *\n * The slot is per vertex rather than per flush because the run holds several\n * textures at once. Reserving slot 0 for white is what makes a solid's promise\n * true no matter what else joins its run: before this, a solid carried the\n * white texel's UV but the flush bound the run's *image*, so every ground rect\n * beside an atlas quad came out multiplied by whatever texel sat at the middle\n * of that atlas. A wall of white grounds drew olive.\n *\n * **The chain is unrolled because GLSL ES 3.0 will not index a sampler array\n * with a variable** — the index must be a constant expression, so `if (i == 0)\n * … if (i == 1) …` over constants is the only legal form. `v_texSlot` is\n * constant across a primitive, so the branch is uniform within any one\n * triangle; the coordinate it samples is a varying computed before the branch,\n * which is what keeps the implicit derivatives well defined.\n *\n * **The paint mode rides in `a_texSlot`, and the glyph math runs either way.**\n * A glyph vertex names a font atlas whose texel is a distance field rather than\n * a color, so its coverage comes from `glyphCoverage` and its color comes from\n * the vertex alone. That coverage is computed on every fragment, glyph or not,\n * because a derivative in non-uniform control flow is undefined and it\n * has to be taken before anything selects on the mode — see\n * `GLYPH_COVERAGE_GLSL`. Priced head to head at 432M fragments a frame\n * (`tests/perf/fill-rate.spec.ts`, teitou, 2026-10-05), that adds a quarter to\n * a half to a fragment that is not a glyph — 27–48% over four sittings. The\n * figure recorded when text landed was 1.4%, and it was wrong: the control\n * gated its glyph math on a factor the compiler folds to zero, so it timed a\n * shader with that math deleted. Fill is not what a wall is bound by, which is\n * why the conclusion stands even though the number did not.\n *\n * **A gradient is a textured quad off the ramp atlas.** A linear one needs no\n * mode: its ramp position is affine in position, so `a_uv` is (ramp position,\n * atlas row) and the plain path samples it. A radial or conic one carries the\n * gradient-space coordinate instead — affine even where the ramp position is\n * not — with the row in `a_post`, and the fragment takes a `length` or an\n * `atan` of it behind a branch on the flat mode. That branch carries the sample\n * itself, not just the coordinate: a fetch from a varying is one the hardware\n * schedules ahead, and one from a computed coordinate is not: on teitou the\n * computed-coordinate form costs 29–54% of a fragment, and the split one\n * −5–11%, which is the spread of the measurement itself\n * (`tests/perf/fill-rate.spec.ts`, 2026-10-05).\n *\n * **Mode and slot share one attribute because the vertex is the thing that\n * costs.** Both are small enumerations, so `slot + 8 * mode` packs them with\n * room to spare. Carrying the mode as a float of its own instead measured\n * slower at the densest rung of `tests/perf/atlas-wall.spec.ts`, timed then in\n * blocks of frames, a method since retired (`tests/perf/README.md`, \"Timing a\n * frame\"), so the size of it is unknown. The reason holds without the number: the\n * whole batch exists to make one buffer write a frame cheap, and every extra\n * float widens that write for every rect and quad in the run, not just for the\n * glyphs that read it.\n *\n * `a_post` is the alpha factor applied *after* the color matrix. An image quad\n * puts its opacity there, where `u_opacity` used to be — the fold is exact for\n * the same reason the old image shader's was, the matrix cannot see it. Solid\n * geometry and glyphs leave it at 1 and fold their own alpha into\n * `a_vertexColor`, which is only sound under an identity matrix; `draw.ts` owns\n * that condition.\n *\n * Inputs:\n *   a_position     vec2   screen-space x,y of the corner\n *   a_vertexColor  vec4   straight-alpha color; (1,1,1,1) on an image vertex\n *   a_uv           vec2   texture coordinate 0..1; the white texel for solids\n *   a_post         float  alpha factor applied after the color matrix\n *   a_texSlot      float  slot + 8 * paint mode; slot 0 is the white texel\n *\n * Output: PREMULTIPLIED alpha. Blend: `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)`.\n */\n\nimport { GLYPH_COVERAGE_GLSL } from '@weasel-js/font';\n\n/**\n * Texture units the batch program samples, slot 0 being the white texel.\n *\n * Fixed rather than queried: WebGL2 guarantees at least 16 fragment texture\n * units, so 8 is available everywhere without asking, and asking would mean a\n * `getParameter` the GL recorder answers with a recording function rather than\n * a number. Seven textures in one run is what \"a document with a handful of\n * distinct images, and a font or two\" needs; past that the run breaks as it\n * always did, and every extra slot is another compare in the fragment chain.\n */\nexport const BATCH_TEXTURE_SLOTS = 8;\n\n/** Slot every solid vertex carries — the white texel, bound by `flushBatch`. */\nexport const WHITE_SLOT = 0;\n\n/** Paint mode for everything whose texel is a color rather than a field. */\nexport const PAINT_MODE_PLAIN = 0;\n\n/**\n * Paint modes for the two gradients whose ramp position is not affine in\n * position — the ones a vertex cannot simply carry.\n *\n * They sit above the glyph modes (1 and 2), so `isGlyph` is a range rather than\n * a threshold. What a vertex carries in these modes is the *gradient-space\n * coordinate* in `a_uv` and its atlas row in `a_post`: that coordinate is\n * affine even where the ramp position is not, so the CPU folds it to two affine\n * rows and the shader takes a `length` or an `atan` of the result.\n *\n * A linear gradient has neither mode: its ramp position is affine outright, so\n * it is a textured quad off the atlas at `PAINT_MODE_PLAIN` and pays nothing\n * here.\n */\nexport const PAINT_MODE_RADIAL = 3;\nexport const PAINT_MODE_CONIC = 4;\n\n/** 1 / 2π, which turns a conic gradient's angle into a ramp position. */\nconst INV_TAU = (1 / (2 * Math.PI)).toFixed(10);\n\n/** Pack a texture slot and a paint mode into the one `a_texSlot` float. */\nexport function packSlot(slot: number, mode: number): number {\n  return slot + BATCH_TEXTURE_SLOTS * mode;\n}\n\n/** The paint mode packed into an `a_texSlot` value — for the tests, which read\n *  a vertex back out of the buffer it was staged into. */\nexport function paintModeOf(packed: number): number {\n  return Math.floor((packed + 0.5) / BATCH_TEXTURE_SLOTS);\n}\n\n/**\n * Where each batch attribute lives, pinned rather than left to the linker so\n * `glyphPaint`'s program can draw from the same VAO.\n */\nexport const BATCH_ATTRIBUTE_LOCATIONS = {\n  a_position: 0, a_vertexColor: 1, a_uv: 2, a_post: 3, a_texSlot: 4,\n} as const;\n\nconst L = BATCH_ATTRIBUTE_LOCATIONS;\n\nfunction sampleChain(slots: number): string {\n  const arms: string[] = [];\n  for (let i = 1; i < slots; i++) {\n    arms.push(`  if (slot == ${i}) return texture(u_samplers[${i}], uv);`);\n  }\n  return arms.join('\\n');\n}\n\nexport const BATCH_VERT_SRC = /* glsl */ `#version 300 es\nlayout(location = ${L.a_position}) in vec2 a_position;\nlayout(location = ${L.a_vertexColor}) in vec4 a_vertexColor;\nlayout(location = ${L.a_uv}) in vec2 a_uv;\nlayout(location = ${L.a_post}) in float a_post;\nlayout(location = ${L.a_texSlot}) in float a_texSlot;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nout vec4 v_vertexColor;\nout vec2 v_uv;\nout float v_post;\nflat out int v_texSlot;\nflat out float v_paintMode;\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  v_uv = a_uv;\n  v_post = a_post;\n  // slot + 8 * mode, unpacked — see the file header for why they share a float.\n  int packed = int(a_texSlot + 0.5);\n  v_texSlot = packed % ${BATCH_TEXTURE_SLOTS};\n  v_paintMode = float(packed / ${BATCH_TEXTURE_SLOTS});\n}\n`;\n\nexport const BATCH_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec4 v_vertexColor;\nin vec2 v_uv;\nin float v_post;\nflat in int v_texSlot;\nflat in float v_paintMode;\nuniform sampler2D u_samplers[${BATCH_TEXTURE_SLOTS}];\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform float u_synthBold;\nuniform vec2 u_fieldScale[${BATCH_TEXTURE_SLOTS}];\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\n\nvec4 sampleSlot(int slot, vec2 uv) {\n${sampleChain(BATCH_TEXTURE_SLOTS)}\n  return texture(u_samplers[0], uv);\n}\n${GLYPH_COVERAGE_GLSL}\nvoid main() {\n  float isGrad = step(2.5, v_paintMode);\n  // A radial or conic vertex carries a gradient-space coordinate rather than a\n  // texture coordinate, and its atlas row rather than an alpha. The sample is\n  // split across the branch rather than the coordinate selected before it: an\n  // arm that reads v_uv straight is a fetch the hardware can schedule against a\n  // varying, and one reading a coordinate the shader computed is not. Selecting\n  // the coordinate first and sampling once costs 29-54% of a fragment that is\n  // not a gradient; splitting it is within the measurement's own spread of free\n  // (tests/perf/fill-rate.spec.ts, teitou, 2026-10-05).\n  //\n  // Branching at all is safe here where it would not be around the glyph math:\n  // v_paintMode is flat, so every fragment of a quad takes the same arm, and\n  // nothing in either arm is a derivative.\n  vec4 texel;\n  if (isGrad > 0.5) {\n    float t = v_paintMode > ${PAINT_MODE_CONIC - 0.5}\n      ? fract(atan(v_uv.y, v_uv.x) * ${INV_TAU})\n      : length(v_uv);\n    texel = sampleSlot(v_texSlot, vec2(t, v_post));\n  } else {\n    texel = sampleSlot(v_texSlot, v_uv);\n  }\n  float isGlyph = step(0.5, v_paintMode) * step(v_paintMode, 2.5);\n  // Unconditional, and multiplied out afterwards rather than branched around:\n  // see the file header.\n  float coverage = glyphCoverage(texel, v_paintMode, u_synthBold, v_uv, u_fieldScale[v_texSlot]);\n  // A glyph's texel is a distance field, so it takes no part in the color; a\n  // plain vertex multiplies its texel in as it always did.\n  vec4 src = mix(texel, vec4(1.0), isGlyph) * u_color * v_vertexColor;\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha * mix(v_post, 1.0, isGrad) * mix(1.0, coverage, isGlyph);\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const BATCH_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_samplers', 'u_color', 'u_alpha', 'u_synthBold', 'u_fieldScale',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\nexport const BATCH_FILL_ATTRIBUTES = [\n  'a_position', 'a_vertexColor', 'a_uv', 'a_post', 'a_texSlot',\n] as const;\n"],"mappings":";;AAwFA,IAAaA,IAAsB,GAGtBC,IAAa,GAGbC,IAAmB,GAgBnBC,IAAoB,GACpBC,IAAmB,GAG1BC,KAAW,KAAK,IAAI,KAAK,IAAA,CAAK,QAAQ,EAAE;AAG9C,SAAgBC,EAAS,GAAc,GAAsB;CAC3D,OAAOC,IAAOP,IAAsBQ;AACtC;AAYA,IAAaC,IAA4B;CACvC,YAAY;CAAG,eAAe;CAAG,MAAM;CAAG,QAAQ;CAAG,WAAW;AAClE,GAEMC,IAAID;AAEV,SAASE,EAAY,GAAuB;CAC1C,IAAMC,IAAiB,CAAC;CACxB,KAAK,IAAIC,IAAI,GAAGA,IAAIC,GAAO,KACzB,EAAK,KAAK,iBAAiBD,EAAE,8BAA8BA,EAAE,QAAQ;CAEvE,OAAOD,EAAK,KAAK,IAAI;AACvB;AAEA,IAAaG,IAA4B;oBACrBL,EAAE,WAAW;oBACbA,EAAE,cAAc;oBAChBA,EAAE,KAAK;oBACPA,EAAE,OAAO;oBACTA,EAAE,UAAU;;;;;;;;;;;;;;;;;yBAiBPV,EAAoB;iCACZA,EAAoB;;GAIxCgB,IAA4B;;;;;;;+BAOVhB,EAAoB;;;;4BAIvBA,EAAoB;;;;;;EAM9CW,EAAYX,CAAmB,EAAE;;;EAGjCiB,EAAoB;;;;;;;;;;;;;;;;;;uCAkBiBZ,EAAQ;;;;;;;;;;;;;;;;;GAmBlCa,IAAsB;CACjC;CAAU;CAAW;CAAc;CAAW;CAAW;CAAe;CACxE;CAAiB;AACnB,GAEaC,IAAwB;CACnC;CAAc;CAAiB;CAAQ;CAAU;AACnD"}

package/dist/renderer/shaders/customPrelude.js

@@ -1,34 +0,0 @@
-//#region src/renderer/shaders/customPrelude.ts
-var e = "#version 300 es\nin vec2 a_position;\nin vec2 a_uv;\nuniform vec4 u_bounds;\nuniform mat3 u_view;\nuniform mat3 u_proj;\nout vec2 v_uv;\nout vec2 v_screen;\nout vec2 v_world;\n\nvoid main() {\n  float sx = u_bounds.x + a_uv.x * u_bounds.z;\n  float sy = u_bounds.y + a_uv.y * u_bounds.w;\n  v_screen = vec2(sx, sy);\n  v_uv = a_uv;\n\n  float det = u_view[0][0] * u_view[1][1] - u_view[0][1] * u_view[1][0];\n  // A flat view has no inverse: every fragment reads the world origin, not a plausible wrong mapping.\n  float invDet = det != 0.0 ? 1.0 / det : 0.0;\n  v_world = vec2(\n    ((sx - u_view[2][0]) *  u_view[1][1] + (sy - u_view[2][1]) * -u_view[0][1]) * invDet,\n    ((sx - u_view[2][0]) * -u_view[1][0] + (sy - u_view[2][1]) *  u_view[0][0]) * invDet\n  );\n\n  vec3 clip = u_proj * vec3(sx, sy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n", t = ["a_position", "a_uv"], n = [
-	"u_bounds",
-	"u_view",
-	"u_proj"
-], r = new Float32Array([
-	-1,
-	-1,
-	0,
-	0,
-	1,
-	-1,
-	1,
-	0,
-	1,
-	1,
-	1,
-	1,
-	-1,
-	1,
-	0,
-	1
-]), i = new Uint16Array([
-	0,
-	1,
-	2,
-	0,
-	2,
-	3
-]);
-//#endregion
-export { t as CUSTOM_ATTRIBUTES, n as CUSTOM_KIT_UNIFORMS, e as CUSTOM_VERT_SRC, i as QUAD_INDICES, r as QUAD_VERTICES };
-
-//# sourceMappingURL=customPrelude.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"customPrelude.js","names":["CUSTOM_VERT_SRC","CUSTOM_ATTRIBUTES","CUSTOM_KIT_UNIFORMS","QUAD_VERTICES","QUAD_INDICES"],"sources":["../../../src/renderer/shaders/customPrelude.ts"],"sourcesContent":["/**\n * Kit-supplied vertex shader for kind:'shader' DrawCommands.\n *\n * Consumers write only fragment shaders. The vertex shader is fixed:\n * it generates a quad covering the DrawCommand's `bounds` rect and\n * exposes three varyings the fragment shader can consume.\n *\n * PUBLIC CONTRACT (varyings and kit uniforms):\n *\n *   in vec2  a_position   -1..1 NDC quad (set by the kit)\n *   in vec2  a_uv         0..1 across the bounds rect\n *\n *   uniform vec4 u_bounds  x, y, w, h in screen-space CSS pixels (set by kit)\n *   uniform mat3 u_view    weasel View matrix, world→screen (set by kit)\n *   uniform mat3 u_proj    screen→clip projection (internal, not documented)\n *\n *   out vec2 v_uv          0..1 across the bounds rect (top-left origin)\n *   out vec2 v_screen      screen-space pixel coordinate of this fragment\n *   out vec2 v_world       approximate world-space coordinate (via view inverse)\n *\n * PREMULTIPLIED ALPHA REQUIREMENT:\n * The canvas uses premultipliedAlpha:true (the WebGL2 default). Consumer\n * fragment shaders MUST output premultiplied alpha:\n *\n *   outColor = vec4(rgb * a, a);   // CORRECT\n *   outColor = vec4(rgb, a);       // WRONG — over-brightens translucent pixels\n *\n * The renderer uses gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA) to match.\n */\n\n/**\n * Kit-supplied vertex shader source for custom programs.\n *\n * @remarks\n * **PREMULTIPLIED ALPHA:** Your fragment shader MUST output `vec4(rgb * a, a)`,\n * not `vec4(rgb, a)`. The canvas is composited with premultipliedAlpha:true;\n * straight-alpha output causes over-bright rendering for any fragment with a < 1.\n */\nexport const CUSTOM_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nin vec2 a_uv;\nuniform vec4 u_bounds;\nuniform mat3 u_view;\nuniform mat3 u_proj;\nout vec2 v_uv;\nout vec2 v_screen;\nout vec2 v_world;\n\nvoid main() {\n  float sx = u_bounds.x + a_uv.x * u_bounds.z;\n  float sy = u_bounds.y + a_uv.y * u_bounds.w;\n  v_screen = vec2(sx, sy);\n  v_uv = a_uv;\n\n  float det = u_view[0][0] * u_view[1][1] - u_view[0][1] * u_view[1][0];\n  // A flat view has no inverse: every fragment reads the world origin, not a plausible wrong mapping.\n  float invDet = det != 0.0 ? 1.0 / det : 0.0;\n  v_world = vec2(\n    ((sx - u_view[2][0]) *  u_view[1][1] + (sy - u_view[2][1]) * -u_view[0][1]) * invDet,\n    ((sx - u_view[2][0]) * -u_view[1][0] + (sy - u_view[2][1]) *  u_view[0][0]) * invDet\n  );\n\n  vec3 clip = u_proj * vec3(sx, sy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n`;\n\n/**\n * Attribute names used by the custom vertex shader.\n * The renderer looks these up after compile.\n */\nexport const CUSTOM_ATTRIBUTES = ['a_position', 'a_uv'] as const;\n\n/**\n * Kit-managed uniform names for custom shader programs.\n * These are set per-draw by drawShader(); consumers must NOT redeclare them.\n */\nexport const CUSTOM_KIT_UNIFORMS = ['u_bounds', 'u_view', 'u_proj'] as const;\n\n/**\n * Auto-quad geometry: 4 vertices covering NDC (-1..1) and UV (0..1).\n *\n * Layout per vertex: [a_position.x, a_position.y, a_uv.x, a_uv.y]\n *\n * Vertex order (UV space, screen y-down):\n *   0: top-left     (-1, -1, 0, 0)\n *   1: top-right    ( 1, -1, 1, 0)\n *   2: bottom-right ( 1,  1, 1, 1)\n *   3: bottom-left  (-1,  1, 0, 1)\n */\nexport const QUAD_VERTICES = new Float32Array([\n  -1, -1,  0, 0,\n   1, -1,  1, 0,\n   1,  1,  1, 1,\n  -1,  1,  0, 1,\n]);\n\nexport const QUAD_INDICES = new Uint16Array([0, 1, 2, 0, 2, 3]);\n"],"mappings":";AAsCA,IAAaA,IAA6B,61BAiC7BC,IAAoB,CAAC,cAAc,MAAM,GAMzCC,IAAsB;CAAC;CAAY;CAAU;AAAQ,GAarDC,IAAgB,IAAI,aAAa;CAC5C;CAAI;CAAK;CAAG;CACX;CAAG;CAAK;CAAG;CACX;CAAI;CAAI;CAAG;CACZ;CAAK;CAAI;CAAG;AACd,CAAC,GAEYC,IAAe,IAAI,YAAY;CAAC;CAAG;CAAG;CAAG;CAAG;CAAG;AAAC,CAAC"}

package/dist/renderer/shaders/extractUniformNames.js

@@ -1,184 +0,0 @@
-//#region src/renderer/shaders/extractUniformNames.ts
-var e = /* @__PURE__ */ new Set([
-	"lowp",
-	"mediump",
-	"highp",
-	"precise",
-	"invariant",
-	"centroid",
-	"flat",
-	"smooth",
-	"noperspective"
-]), t = /^[A-Za-z_]\w*$/, n = 16;
-function r(e) {
-	return [...a(e).names];
-}
-function i(e) {
-	return a(e).arrays;
-}
-function a(r) {
-	let { code: i, defines: a } = o(r), c = s(i), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Map(), m = (e, t) => {
-		if (t > n) return null;
-		let r = null;
-		for (let n of a.get(e) ?? []) {
-			let e = l(s(n), (e) => m(e, t + 1));
-			e !== null && (r === null || e > r) && (r = e);
-		}
-		return r ?? u.get(e) ?? null;
-	}, h = (e, t) => l(c.slice(e, t), (e) => m(e, 0)), g = (e) => {
-		let t = 0;
-		for (let n = e; n < c.length; n++) if (c[n] === "(" || c[n] === "[" || c[n] === "{") t++;
-		else if ((c[n] === ")" || c[n] === "]" || c[n] === "}") && --t === 0) return n;
-		return c.length;
-	}, _ = (e) => {
-		if (c[e] !== "[") return [void 0, e];
-		let t = g(e);
-		return [h(e + 1, t), t + 1];
-	}, v = (e, n) => {
-		let r = [];
-		for (; e < c.length && c[e] !== ";" && c[e] !== "}";) {
-			let i = c[e], [a, o] = _(e + 1);
-			for (e = o, t.test(i) && r.push({
-				name: i,
-				size: a === void 0 ? n : a
-			}); e < c.length && c[e] !== "," && c[e] !== ";" && c[e] !== "}";) e = c[e] === "(" || c[e] === "[" || c[e] === "{" ? g(e) + 1 : e + 1;
-			c[e] === "," && e++;
-		}
-		return [r, e];
-	}, y = (t) => {
-		let n = t + 1, r = c[n] === "{" ? void 0 : c[n++], i = [];
-		if (c[n] !== "{") return [i, n];
-		let a = g(n);
-		for (n++; n < a;) {
-			for (; e.has(c[n]);) n++;
-			let t;
-			c[n] === "struct" ? [t, n] = y(n) : t = c[n++];
-			let [r, a] = _(n), [o, s] = v(a, r);
-			for (let e of o) e.size !== null && i.push({
-				type: t,
-				name: e.name,
-				size: e.size ?? null
-			});
-			n = s + 1;
-		}
-		if (r) {
-			let e = d.get(r) ?? [];
-			for (let t of i) e.some((e) => e.name === t.name) || e.push(t);
-			d.set(r, e);
-		}
-		return [i, a + 1];
-	}, b = (e, t, r, i) => {
-		if (i > n) return;
-		if (r !== null) {
-			if (typeof t == "string" && !d.has(t)) {
-				let n = p.get(e);
-				(!n || r > n.size) && p.set(e, {
-					type: t,
-					size: r
-				});
-			}
-			for (let n = 0; n < r; n++) b(`${e}[${n}]`, t, null, i + 1);
-			return;
-		}
-		let a = typeof t == "string" ? d.get(t) : t;
-		if (!a) {
-			f.add(e);
-			return;
-		}
-		for (let t of a) b(`${e}.${t.name}`, t.type, t.size, i + 1);
-	}, x = 0;
-	for (let n = 0; n < c.length; n++) {
-		let r = c[n];
-		if (r === "{") x++;
-		else if (r === "}") x--;
-		else if (r === "struct") n = y(n)[1] - 1;
-		else if (x === 0 && r === "const") {
-			let r = n + 1;
-			for (; e.has(c[r]);) r++;
-			if ((c[r] === "int" || c[r] === "uint") && t.test(c[r + 1] ?? "") && c[r + 2] === "=") {
-				let e = r + 3;
-				for (; e < c.length && c[e] !== ";";) e++;
-				let t = h(r + 3, e), n = u.get(c[r + 1]);
-				t !== null && (n === void 0 || t > n) && u.set(c[r + 1], t);
-			}
-		} else if (x === 0 && r === "uniform") {
-			let t = n + 1;
-			for (; e.has(c[t]);) t++;
-			let r;
-			if (c[t] === "struct") [r, t] = y(t);
-			else if (c[t + 1] === "{") {
-				for (t = g(t + 1) + 1; t < c.length && c[t] !== ";";) t++;
-				n = t;
-				continue;
-			} else r = c[t++];
-			let [i, a] = _(t), [o, s] = v(a, i);
-			for (let e of o) e.size !== null && b(e.name, r, e.size ?? null, 0);
-			n = s;
-		}
-	}
-	return {
-		names: f,
-		arrays: p
-	};
-}
-function o(e) {
-	let t = e.replace(/\\\r?\n/g, ""), n = "";
-	for (let e = 0; e < t.length; e++) if (t[e] === "/" && t[e + 1] === "/") {
-		for (; e < t.length && t[e] !== "\n";) e++;
-		n += "\n";
-	} else if (t[e] === "/" && t[e + 1] === "*") {
-		let r = t.indexOf("*/", e + 2);
-		e = r < 0 ? t.length : r + 1, n += " ";
-	} else n += t[e];
-	let r = /* @__PURE__ */ new Map();
-	return {
-		code: n.split("\n").map((e) => {
-			if (!/^\s*#/.test(e)) return e;
-			let t = /^\s*#\s*define\s+([A-Za-z_]\w*)(\(?)(.*)$/.exec(e);
-			return t && !t[2] && r.set(t[1], [...r.get(t[1]) ?? [], t[3].trim()]), "";
-		}).join("\n"),
-		defines: r
-	};
-}
-function s(e) {
-	return e.match(/[A-Za-z_]\w*|\d[\w.]*|\S/g) ?? [];
-}
-function c(e) {
-	let t = /^(?:0[xX]([0-9a-fA-F]+)|(0[0-7]*)|([1-9]\d*))[uU]?$/.exec(e);
-	return t ? t[1] === void 0 ? t[2] === void 0 ? parseInt(t[3], 10) : parseInt(t[2], 8) : parseInt(t[1], 16) : null;
-}
-function l(e, n) {
-	let r = 0, i = () => {
-		let a = e[r++];
-		if (a === "(") {
-			let t = o();
-			return e[r++] === ")" ? t : null;
-		}
-		if (a === "-") {
-			let e = i();
-			return e === null ? null : -e;
-		}
-		return a === "+" ? i() : a === void 0 ? null : c(a) ?? (t.test(a) ? n(a) : null);
-	}, a = () => {
-		let t = i();
-		for (; t !== null && (e[r] === "*" || e[r] === "/" || e[r] === "%");) {
-			let n = e[r++], a = i();
-			if (a === null || n !== "*" && a === 0) return null;
-			t = n === "*" ? t * a : n === "/" ? Math.trunc(t / a) : t % a;
-		}
-		return t;
-	}, o = () => {
-		let t = a();
-		for (; t !== null && (e[r] === "+" || e[r] === "-");) {
-			let n = e[r++], i = a();
-			if (i === null) return null;
-			t = n === "+" ? t + i : t - i;
-		}
-		return t;
-	}, s = o();
-	return r === e.length && s !== null && s >= 0 ? s : null;
-}
-//#endregion
-export { i as extractUniformArrays, r as extractUniformNames };
-
-//# sourceMappingURL=extractUniformNames.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"extractUniformNames.js","names":["QUALIFIERS","IDENT","MAX_DEPTH","extractUniformNames","scanUniforms","glsl","extractUniformArrays","preprocess","toks","tokenize","code","consts","structs","out","arrays","resolveName","depth","best","body","defines","name","v","evalInt","n","evalSize","from","to","closer","k","open","arraySuffix","j","end","declarators","found","size","next","typeSize","structSpecifier","i","members","type","afterType","decls","term","d","prior","m","p","expand","t","spliced","stripped","line","def","src","intLiteral","tok","primary","sum","lookup","product","op","r"],"sources":["../../../src/renderer/shaders/extractUniformNames.ts"],"sourcesContent":["/** Qualifiers GLSL allows between `uniform` and the type name, and before a\n *  struct member's type. */\nconst QUALIFIERS = new Set([\n  'lowp', 'mediump', 'highp', 'precise', 'invariant',\n  'centroid', 'flat', 'smooth', 'noperspective',\n]);\n\nconst IDENT = /^[A-Za-z_]\\w*$/;\nconst MAX_DEPTH = 16;\n\ninterface Member {\n  readonly type: string | readonly Member[];\n  readonly name: string;\n  /** `null` for a non-array. */\n  readonly size: number | null;\n}\n\n/**\n * The names a program's uniforms answer to in `getUniformLocation`: array\n * uniforms per slot (`u_ripples[0]`), struct uniforms per leaf\n * (`u_lights[1].pos`), nested structs and array members included.\n *\n * A declaration scanner over a token stream, not a GLSL parser. Comments are\n * stripped; interface blocks are skipped, since a UBO's members are bound\n * through a buffer rather than a location. Array sizes resolve through integer\n * literals, `#define`s and top-level `const int`s, with `+ - * / %` between\n * them; a size it cannot resolve drops that declarator, and a later write to\n * it warns.\n */\nexport function extractUniformNames(glsl: string): string[] {\n  return [...scanUniforms(glsl).names];\n}\n\n/** An array uniform of a basic type: its element type as spelled (`vec3`,\n *  `int`, `mat4`) and its declared length. */\nexport interface UniformArrayDecl {\n  readonly type: string;\n  readonly size: number;\n}\n\n/**\n * Every array of a basic type a program declares, keyed by the name its slots\n * hang off (`u_ripples` for `u_ripples[0]`). An array inside a struct is keyed\n * by its full path (`u_lights[1].weights`); an array of structs is not an\n * entry, since it has no single element type.\n */\nexport function extractUniformArrays(glsl: string): Map<string, UniformArrayDecl> {\n  return scanUniforms(glsl).arrays;\n}\n\nfunction scanUniforms(glsl: string): { names: Set<string>; arrays: Map<string, UniformArrayDecl> } {\n  const { code, defines } = preprocess(glsl);\n  const toks = tokenize(code);\n  const consts = new Map<string, number>();\n  const structs = new Map<string, Member[]>();\n  const out = new Set<string>();\n  const arrays = new Map<string, UniformArrayDecl>();\n\n  const resolveName = (name: string, depth: number): number | null => {\n    if (depth > MAX_DEPTH) return null;\n    let best: number | null = null;\n    for (const body of defines.get(name) ?? []) {\n      const v = evalInt(tokenize(body), (n) => resolveName(n, depth + 1));\n      if (v !== null && (best === null || v > best)) best = v;\n    }\n    return best ?? consts.get(name) ?? null;\n  };\n  const evalSize = (from: number, to: number) => evalInt(toks.slice(from, to), (n) => resolveName(n, 0));\n\n  /** Index of the token closing the bracket opened at `open`. */\n  const closer = (open: number): number => {\n    let depth = 0;\n    for (let k = open; k < toks.length; k++) {\n      if (toks[k] === '(' || toks[k] === '[' || toks[k] === '{') depth++;\n      else if (toks[k] === ')' || toks[k] === ']' || toks[k] === '}') {\n        if (--depth === 0) return k;\n      }\n    }\n    return toks.length;\n  };\n\n  /** Parses `[size]` at `j` if present: the size (undefined if absent, null\n   *  if unresolvable) and where scanning resumes. */\n  const arraySuffix = (j: number): [number | null | undefined, number] => {\n    if (toks[j] !== '[') return [undefined, j];\n    const end = closer(j);\n    return [evalSize(j + 1, end), end + 1];\n  };\n\n  /** Declarators `a, b[2], c` up to the terminating `;` (or `}`), after the\n   *  type at `j`. Returns them and the index of the terminator. */\n  const declarators = (\n    j: number,\n    typeSize: number | null | undefined,\n  ): [{ name: string; size: number | null | undefined }[], number] => {\n    const found: { name: string; size: number | null | undefined }[] = [];\n    while (j < toks.length && toks[j] !== ';' && toks[j] !== '}') {\n      const name = toks[j];\n      const [size, next] = arraySuffix(j + 1);\n      j = next;\n      if (IDENT.test(name)) found.push({ name, size: size === undefined ? typeSize : size });\n      // Skip an initializer, or anything else, to the next declarator.\n      while (j < toks.length && toks[j] !== ',' && toks[j] !== ';' && toks[j] !== '}') {\n        j = toks[j] === '(' || toks[j] === '[' || toks[j] === '{' ? closer(j) + 1 : j + 1;\n      }\n      if (toks[j] === ',') j++;\n    }\n    return [found, j];\n  };\n\n  /** `struct Name? { members }` at `i`; records a named struct. */\n  const structSpecifier = (i: number): [Member[], number] => {\n    let j = i + 1;\n    const name = toks[j] !== '{' ? toks[j++] : undefined;\n    const members: Member[] = [];\n    if (toks[j] !== '{') return [members, j];\n    const end = closer(j);\n    j++;\n    while (j < end) {\n      while (QUALIFIERS.has(toks[j])) j++;\n      let type: string | Member[];\n      if (toks[j] === 'struct') [type, j] = structSpecifier(j);\n      else type = toks[j++];\n      const [typeSize, afterType] = arraySuffix(j);\n      const [decls, term] = declarators(afterType, typeSize);\n      for (const d of decls) if (d.size !== null) members.push({ type, name: d.name, size: d.size ?? null });\n      j = term + 1;\n    }\n    if (name) {\n      // A struct redefined in another preprocessor branch keeps both members lists.\n      const prior = structs.get(name) ?? [];\n      for (const m of members) if (!prior.some((p) => p.name === m.name)) prior.push(m);\n      structs.set(name, prior);\n    }\n    return [members, end + 1];\n  };\n\n  const expand = (name: string, type: string | readonly Member[], size: number | null, depth: number): void => {\n    if (depth > MAX_DEPTH) return;\n    if (size !== null) {\n      if (typeof type === 'string' && !structs.has(type)) {\n        const prior = arrays.get(name);\n        if (!prior || size > prior.size) arrays.set(name, { type, size });\n      }\n      for (let k = 0; k < size; k++) expand(`${name}[${k}]`, type, null, depth + 1);\n      return;\n    }\n    const members = typeof type === 'string' ? structs.get(type) : type;\n    if (!members) {\n      out.add(name);\n      return;\n    }\n    for (const m of members) expand(`${name}.${m.name}`, m.type, m.size, depth + 1);\n  };\n\n  let depth = 0;\n  for (let i = 0; i < toks.length; i++) {\n    const t = toks[i];\n    if (t === '{') depth++;\n    else if (t === '}') depth--;\n    else if (t === 'struct') i = structSpecifier(i)[1] - 1;\n    else if (depth === 0 && t === 'const') {\n      let j = i + 1;\n      while (QUALIFIERS.has(toks[j])) j++;\n      if ((toks[j] === 'int' || toks[j] === 'uint') && IDENT.test(toks[j + 1] ?? '') && toks[j + 2] === '=') {\n        let end = j + 3;\n        while (end < toks.length && toks[end] !== ';') end++;\n        const v = evalSize(j + 3, end);\n        const prior = consts.get(toks[j + 1]);\n        if (v !== null && (prior === undefined || v > prior)) consts.set(toks[j + 1], v);\n      }\n    } else if (depth === 0 && t === 'uniform') {\n      let j = i + 1;\n      while (QUALIFIERS.has(toks[j])) j++;\n      let type: string | Member[];\n      if (toks[j] === 'struct') {\n        [type, j] = structSpecifier(j);\n      } else if (toks[j + 1] === '{') {\n        // An interface block: skip it and its instance name.\n        j = closer(j + 1) + 1;\n        while (j < toks.length && toks[j] !== ';') j++;\n        i = j;\n        continue;\n      } else {\n        type = toks[j++];\n      }\n      const [typeSize, afterType] = arraySuffix(j);\n      const [decls, term] = declarators(afterType, typeSize);\n      for (const d of decls) if (d.size !== null) expand(d.name, type, d.size ?? null, 0);\n      i = term;\n    }\n  }\n  return { names: out, arrays };\n}\n\n/** Comments stripped and directives removed. Every conditional branch is kept:\n *  an extra name only looks up a null location, a missing one drops writes. */\nfunction preprocess(glsl: string): { code: string; defines: Map<string, string[]> } {\n  const spliced = glsl.replace(/\\\\\\r?\\n/g, '');\n  let stripped = '';\n  for (let k = 0; k < spliced.length; k++) {\n    if (spliced[k] === '/' && spliced[k + 1] === '/') {\n      while (k < spliced.length && spliced[k] !== '\\n') k++;\n      stripped += '\\n';\n    } else if (spliced[k] === '/' && spliced[k + 1] === '*') {\n      const end = spliced.indexOf('*/', k + 2);\n      k = end < 0 ? spliced.length : end + 1;\n      stripped += ' ';\n    } else {\n      stripped += spliced[k];\n    }\n  }\n  const defines = new Map<string, string[]>();\n  const lines = stripped.split('\\n').map((line) => {\n    if (!/^\\s*#/.test(line)) return line;\n    const def = /^\\s*#\\s*define\\s+([A-Za-z_]\\w*)(\\(?)(.*)$/.exec(line);\n    if (def && !def[2]) defines.set(def[1], [...(defines.get(def[1]) ?? []), def[3].trim()]);\n    return '';\n  });\n  return { code: lines.join('\\n'), defines };\n}\n\nfunction tokenize(src: string): string[] {\n  return src.match(/[A-Za-z_]\\w*|\\d[\\w.]*|\\S/g) ?? [];\n}\n\nfunction intLiteral(tok: string): number | null {\n  const m = /^(?:0[xX]([0-9a-fA-F]+)|(0[0-7]*)|([1-9]\\d*))[uU]?$/.exec(tok);\n  if (!m) return null;\n  if (m[1] !== undefined) return parseInt(m[1], 16);\n  if (m[2] !== undefined) return parseInt(m[2], 8);\n  return parseInt(m[3], 10);\n}\n\n/** Integer constant expression over `+ - * / %` and parentheses. */\nfunction evalInt(toks: readonly string[], lookup: (name: string) => number | null): number | null {\n  let p = 0;\n  const primary = (): number | null => {\n    const t = toks[p++];\n    if (t === '(') {\n      const v = sum();\n      return toks[p++] === ')' ? v : null;\n    }\n    if (t === '-') {\n      const v = primary();\n      return v === null ? null : -v;\n    }\n    if (t === '+') return primary();\n    if (t === undefined) return null;\n    return intLiteral(t) ?? (IDENT.test(t) ? lookup(t) : null);\n  };\n  const product = (): number | null => {\n    let v = primary();\n    while (v !== null && (toks[p] === '*' || toks[p] === '/' || toks[p] === '%')) {\n      const op = toks[p++];\n      const r = primary();\n      if (r === null || (op !== '*' && r === 0)) return null;\n      v = op === '*' ? v * r : op === '/' ? Math.trunc(v / r) : v % r;\n    }\n    return v;\n  };\n  const sum = (): number | null => {\n    let v = product();\n    while (v !== null && (toks[p] === '+' || toks[p] === '-')) {\n      const op = toks[p++];\n      const r = product();\n      if (r === null) return null;\n      v = op === '+' ? v + r : v - r;\n    }\n    return v;\n  };\n  const v = sum();\n  return p === toks.length && v !== null && v >= 0 ? v : null;\n}\n"],"mappings":"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"}

package/dist/renderer/shaders/glyphPaint.js

@@ -1,61 +0,0 @@
-import { BATCH_ATTRIBUTE_LOCATIONS as e, BATCH_TEXTURE_SLOTS as t } from "./batchFill.js";
-import { GRAD_FILL_UNIFORMS as n, GRAD_PAINT_GLSL as r } from "./gradFill.js";
-import { PATTERN_FILL_UNIFORMS as i, PATTERN_PAINT_GLSL as a } from "./patternFill.js";
-import { GLYPH_COVERAGE_GLSL as o } from "@weasel-js/font";
-//#region src/renderer/shaders/glyphPaint.ts
-var s = e, c = `#version 300 es
-layout(location = ${s.a_position}) in vec2 a_position;
-layout(location = ${s.a_uv}) in vec2 a_uv;
-layout(location = ${s.a_texSlot}) in float a_texSlot;
-uniform mat3 u_proj;
-uniform mat3 u_model;
-uniform mat3 u_worldInv;
-out vec2 v_world;
-out vec2 v_uv;
-flat out float v_glyphMode;
-void main() {
-  vec3 screen = u_model * vec3(a_position, 1.0);
-  vec3 clip = u_proj * vec3(screen.xy, 1.0);
-  gl_Position = vec4(clip.xy, 0.0, 1.0);
-  v_world = (u_worldInv * vec3(screen.xy, 1.0)).xy;
-  v_uv = a_uv;
-  v_glyphMode = float(int(a_texSlot + 0.5) / ${t});
-}
-`;
-function l(e) {
-	return `#version 300 es
-precision highp float;
-in vec2 v_world;
-in vec2 v_uv;
-flat in float v_glyphMode;
-uniform sampler2D u_atlas;
-uniform float u_synthBold;
-uniform vec2 u_fieldScale;
-${e}
-${o}
-out vec4 outColor;
-void main() {
-  float coverage = glyphCoverage(texture(u_atlas, v_uv), v_glyphMode, u_synthBold, v_uv, u_fieldScale);
-  outColor = shadePaint(v_world) * coverage;
-}
-`;
-}
-var u = "\nuniform sampler2D u_sampler;\nvec4 shadePaint(vec2 uv) {\n  return texture(u_sampler, uv);\n}\n", d = l(a), f = l(r), p = l(u), m = [
-	"u_atlas",
-	"u_synthBold",
-	"u_fieldScale"
-], h = [...i, ...m], g = [...n, ...m], _ = [
-	"u_proj",
-	"u_model",
-	"u_worldInv",
-	"u_sampler",
-	...m
-], v = [
-	"a_position",
-	"a_uv",
-	"a_texSlot"
-];
-//#endregion
-export { f as GLYPH_GRAD_FRAG_SRC, g as GLYPH_GRAD_UNIFORMS, v as GLYPH_PAINT_ATTRIBUTES, c as GLYPH_PAINT_VERT_SRC, d as GLYPH_PATTERN_FRAG_SRC, h as GLYPH_PATTERN_UNIFORMS, p as GLYPH_TEXTURE_FRAG_SRC, _ as GLYPH_TEXTURE_UNIFORMS };
-
-//# sourceMappingURL=glyphPaint.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"glyphPaint.js","names":["L","BATCH_ATTRIBUTE_LOCATIONS","GLYPH_PAINT_VERT_SRC","BATCH_TEXTURE_SLOTS","fragSrc","paintGlsl","GLYPH_COVERAGE_GLSL","TEXTURE_PAINT_GLSL","GLYPH_PATTERN_FRAG_SRC","PATTERN_PAINT_GLSL","GLYPH_GRAD_FRAG_SRC","GRAD_PAINT_GLSL","GLYPH_TEXTURE_FRAG_SRC","GLYPH_UNIFORMS","GLYPH_PATTERN_UNIFORMS","PATTERN_FILL_UNIFORMS","GLYPH_GRAD_UNIFORMS","GRAD_FILL_UNIFORMS","GLYPH_TEXTURE_UNIFORMS","GLYPH_PAINT_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/glyphPaint.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for atlas glyphs filled by a texture paint — a pattern, a\n * gradient or a registered kind — rather than one color.\n *\n * **The glyph is a mask over the paint.** The fragment takes its coverage from\n * the distance field exactly as the batch program does, and its color from the\n * same `shadePaint` the path program for that paint runs, at the same\n * paint-space point: `u_worldInv` applied to the screen position. An outline\n * glyph is a path, so it goes through that path program — which is what makes\n * a paint read the same on either side of the outline-tier threshold.\n *\n * **The vertices are the batch's.** A glyph run stages into `DrawBatch` as\n * usual and this program draws it in place of the batch program, so the\n * attribute locations are pinned to the batch shader's and one VAO serves\n * both. Positions arrive already in screen space, so `u_model` is identity.\n *\n * Coverage is taken before `shadePaint` runs, and outside any branch: `fwidth`\n * in non-uniform control flow is undefined. The gradient's branches are on a\n * uniform, so they could not make it so, but the order keeps it from mattering.\n *\n * Output: PREMULTIPLIED alpha, the paint's own scaled by coverage.\n */\n\nimport { GLYPH_COVERAGE_GLSL } from '@weasel-js/font';\nimport { BATCH_ATTRIBUTE_LOCATIONS, BATCH_TEXTURE_SLOTS } from './batchFill';\nimport { GRAD_FILL_UNIFORMS, GRAD_PAINT_GLSL } from './gradFill';\nimport { PATTERN_FILL_UNIFORMS, PATTERN_PAINT_GLSL } from './patternFill';\n\nconst L = BATCH_ATTRIBUTE_LOCATIONS;\n\nexport const GLYPH_PAINT_VERT_SRC = /* glsl */ `#version 300 es\nlayout(location = ${L.a_position}) in vec2 a_position;\nlayout(location = ${L.a_uv}) in vec2 a_uv;\nlayout(location = ${L.a_texSlot}) in float a_texSlot;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nout vec2 v_uv;\nflat out float v_glyphMode;\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_world = (u_worldInv * vec3(screen.xy, 1.0)).xy;\n  v_uv = a_uv;\n  v_glyphMode = float(int(a_texSlot + 0.5) / ${BATCH_TEXTURE_SLOTS});\n}\n`;\n\nfunction fragSrc(paintGlsl: string): string {\n  return /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\nin vec2 v_uv;\nflat in float v_glyphMode;\nuniform sampler2D u_atlas;\nuniform float u_synthBold;\nuniform vec2 u_fieldScale;\n${paintGlsl}\n${GLYPH_COVERAGE_GLSL}\nout vec4 outColor;\nvoid main() {\n  float coverage = glyphCoverage(texture(u_atlas, v_uv), v_glyphMode, u_synthBold, v_uv, u_fieldScale);\n  outColor = shadePaint(v_world) * coverage;\n}\n`;\n}\n\n/**\n * A registered paint kind binds a whole program of its own, which nothing can\n * wrap in a mask, so it renders into an offscreen buffer first and the glyphs\n * sample that. `u_worldInv` takes the screen position straight to the\n * buffer's texture coordinate, and the texel is already premultiplied and\n * faded — the kind's own program did both.\n */\nconst TEXTURE_PAINT_GLSL = /* glsl */ `\nuniform sampler2D u_sampler;\nvec4 shadePaint(vec2 uv) {\n  return texture(u_sampler, uv);\n}\n`;\n\nexport const GLYPH_PATTERN_FRAG_SRC = fragSrc(PATTERN_PAINT_GLSL);\nexport const GLYPH_GRAD_FRAG_SRC = fragSrc(GRAD_PAINT_GLSL);\nexport const GLYPH_TEXTURE_FRAG_SRC = fragSrc(TEXTURE_PAINT_GLSL);\n\nconst GLYPH_UNIFORMS = ['u_atlas', 'u_synthBold', 'u_fieldScale'] as const;\nexport const GLYPH_PATTERN_UNIFORMS = [...PATTERN_FILL_UNIFORMS, ...GLYPH_UNIFORMS] as const;\nexport const GLYPH_GRAD_UNIFORMS = [...GRAD_FILL_UNIFORMS, ...GLYPH_UNIFORMS] as const;\nexport const GLYPH_TEXTURE_UNIFORMS = [\n  'u_proj', 'u_model', 'u_worldInv', 'u_sampler', ...GLYPH_UNIFORMS,\n] as const;\nexport const GLYPH_PAINT_ATTRIBUTES = ['a_position', 'a_uv', 'a_texSlot'] as const;\n"],"mappings":";;;;;AA4BA,IAAMA,IAAIC,GAEGC,IAAkC;oBAC3BF,EAAE,WAAW;oBACbA,EAAE,KAAK;oBACPA,EAAE,UAAU;;;;;;;;;;;;;+CAaeG,EAAoB;;;AAInE,SAASC,EAAQ,GAA2B;CAC1C,OAAkB;;;;;;;;EAQlBC,EAAU;EACVC,EAAoB;;;;;;;AAOtB;AASA,IAAMC,IAAgC,qGAOzBC,IAAyBJ,EAAQK,CAAkB,GACnDC,IAAsBN,EAAQO,CAAe,GAC7CC,IAAyBR,EAAQG,CAAkB,GAE1DM,IAAiB;CAAC;CAAW;CAAe;AAAc,GACnDC,IAAyB,CAAC,GAAGC,GAAuB,GAAGF,CAAc,GACrEG,IAAsB,CAAC,GAAGC,GAAoB,GAAGJ,CAAc,GAC/DK,IAAyB;CACpC;CAAU;CAAW;CAAc;CAAa,GAAGL;AACrD,GACaM,IAAyB;CAAC;CAAc;CAAQ;AAAW"}

package/dist/renderer/shaders/gradFill.js

@@ -1,30 +0,0 @@
-//#region src/renderer/shaders/gradFill.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_ramp;\nuniform float u_rampV;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nuniform float u_opacity;\nuniform int   u_gradKind;\nuniform vec2  u_gradP0;\nuniform vec2  u_gradDir;\nuniform float u_gradLen;\nuniform float u_gradRadius;\nuniform float u_gradAngle;\n\nconst float PI = 3.14159265358979323846;\n\nvec4 shadePaint(vec2 world) {\n  float t;\n  if (u_gradKind == 0) {\n    vec2 d = world - u_gradP0;\n    t = dot(d, u_gradDir) / max(u_gradLen, 0.0001);\n  } else if (u_gradKind == 1) {\n    t = length(world - u_gradP0) / max(u_gradRadius, 0.0001);\n  } else {\n    float a = atan(world.y - u_gradP0.y, world.x - u_gradP0.x) - u_gradAngle;\n    t = fract(a / (2.0 * PI));\n  }\n  t = clamp(t, 0.0, 1.0);\n  vec4 rampColor = texture(u_ramp, vec2(t, u_rampV));\n  // Fill opacity into the alpha channel before the matrix, which is where the\n  // batch program's vertex alpha sits. The two have to agree, since a linear\n  // gradient goes through that one and a radial through this.\n  vec4 src = vec4(rampColor.rgb, rampColor.a * u_opacity);\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * 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_ramp",
-	"u_rampV",
-	"u_alpha",
-	"u_opacity",
-	"u_colorMatrix",
-	"u_colorBias",
-	"u_gradKind",
-	"u_gradP0",
-	"u_gradDir",
-	"u_gradLen",
-	"u_gradRadius",
-	"u_gradAngle"
-], i = ["a_position"];
-//#endregion
-export { i as GRAD_FILL_ATTRIBUTES, r as GRAD_FILL_UNIFORMS, n as GRAD_FRAG_SRC, t as GRAD_PAINT_GLSL, e as GRAD_VERT_SRC };
-
-//# sourceMappingURL=gradFill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gradFill.js","names":["GRAD_VERT_SRC","GRAD_PAINT_GLSL","GRAD_FRAG_SRC","GRAD_FILL_UNIFORMS","GRAD_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/gradFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for gradient-fill paths (linear, radial, conic).\n *\n * Three gradient kinds via u_gradKind (0=linear, 1=radial, 2=conic).\n * The branch value is uniform across all fragments in one draw call — GPU\n * branch predictor handles uniform-value branches without warp divergence.\n *\n * Output convention §2: PREMULTIPLIED alpha.\n *\n * `u_ramp` is `GradientRampAtlas`'s texture, which holds every baked ramp in\n * the frame, one per row; `u_rampV` picks this fill's row.\n *\n * Step-4 limitation: u_worldInv is identity in v1 since draw.ts doesn't yet\n * receive a view matrix. Gradient coords therefore render in screen space.\n * Step 7 (port createPathLayer) wires the actual view-inverse through layers.\n */\n\nexport const GRAD_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 gradient's color at a gradient-space point, premultiplied — the whole\n * of the fragment stage but the point it is asked about, so the glyph program\n * can mask the same paint the path program draws.\n */\nexport const GRAD_PAINT_GLSL = /* glsl */ `\nuniform sampler2D u_ramp;\nuniform float u_rampV;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nuniform float u_opacity;\nuniform int   u_gradKind;\nuniform vec2  u_gradP0;\nuniform vec2  u_gradDir;\nuniform float u_gradLen;\nuniform float u_gradRadius;\nuniform float u_gradAngle;\n\nconst float PI = 3.14159265358979323846;\n\nvec4 shadePaint(vec2 world) {\n  float t;\n  if (u_gradKind == 0) {\n    vec2 d = world - u_gradP0;\n    t = dot(d, u_gradDir) / max(u_gradLen, 0.0001);\n  } else if (u_gradKind == 1) {\n    t = length(world - u_gradP0) / max(u_gradRadius, 0.0001);\n  } else {\n    float a = atan(world.y - u_gradP0.y, world.x - u_gradP0.x) - u_gradAngle;\n    t = fract(a / (2.0 * PI));\n  }\n  t = clamp(t, 0.0, 1.0);\n  vec4 rampColor = texture(u_ramp, vec2(t, u_rampV));\n  // Fill opacity into the alpha channel before the matrix, which is where the\n  // batch program's vertex alpha sits. The two have to agree, since a linear\n  // gradient goes through that one and a radial through this.\n  vec4 src = vec4(rampColor.rgb, rampColor.a * u_opacity);\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const GRAD_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\n${GRAD_PAINT_GLSL}\nout vec4 outColor;\nvoid main() {\n  outColor = shadePaint(v_world);\n}\n`;\n\nexport const GRAD_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_worldInv', 'u_ramp', 'u_rampV',\n  'u_alpha', 'u_opacity', 'u_colorMatrix', 'u_colorBias',\n  'u_gradKind', 'u_gradP0', 'u_gradDir', 'u_gradLen', 'u_gradRadius', 'u_gradAngle',\n] as const;\n\nexport const GRAD_FILL_ATTRIBUTES = ['a_position'] as const;\n"],"mappings":";AAiBA,IAAaA,IAA2B,6WAoB3BC,IAA6B,uuCAuC7BC,IAA2B;;;EAGtCD,EAAgB;;;;;GAOLE,IAAqB;CAChC;CAAU;CAAW;CAAc;CAAU;CAC7C;CAAW;CAAa;CAAiB;CACzC;CAAc;CAAY;CAAa;CAAa;CAAgB;AACtE,GAEaC,IAAuB,CAAC,YAAY"}

package/dist/renderer/shaders/imageFill.js

@@ -1,14 +0,0 @@
-//#region src/renderer/shaders/imageFill.ts
-var e = "#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", t = "#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 = [
-	"u_proj",
-	"u_model",
-	"u_sampler",
-	"u_opacity",
-	"u_alpha",
-	"u_colorMatrix",
-	"u_colorBias"
-], r = ["a_position", "a_uv"];
-//#endregion
-export { r as IMAGE_FILL_ATTRIBUTES, n as IMAGE_FILL_UNIFORMS, t as IMAGE_FRAG_SRC, e as IMAGE_VERT_SRC };
-
-//# sourceMappingURL=imageFill.js.map