@weasel-js/core 1.7.0 → 1.7.1

package/dist/renderer/math/color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.js","names":["parseColor","cached","CACHE","input","result","parseColorUncached","CACHE_MAX","s","parseHex","lower","named","NAMED_COLORS","parsed","parseRgbFunction","parseHslFunction","RESOLVE_COLOR_CACHE_CAP","resolveColorCache","resolveColor","hit","frozen","parseColorToRgba255","r","g","b","normalizeHex","trimmed","body","hexToRgba","rgbaToHex","rgba","a","f","n","base","hex","unwrapFn","name","splitChannels","parts","p","slash","head","alpha","parseChannel","tok","clamp01","max","parseAlpha","channels","h","parseHue","sat","parsePercentOrNumber","lit","hslToRgb","hslToSrgb","out"],"sources":["../../../src/renderer/math/color.ts"],"sourcesContent":["import { hslToSrgb } from '@weasel-js/paint';\n\n/**\n * Parse a CSS color string into [r, g, b, a] with 0..1 components.\n *\n * Supported forms:\n *   - Hex: `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa` (any case)\n *   - `rgb()` / `rgba()` with integer, float, or percent R/G/B; number or\n *     percent alpha; commas or modern space-separated `R G B / A` syntax\n *   - `hsl()` / `hsla()` with hue as a unitless number (deg) or with `deg`,\n *     `rad`, `grad`, `turn` units; saturation/lightness as percent (or\n *     unitless in the modern syntax); same alpha rules and separator rules\n *     as `rgb()`\n *   - The 148 CSS named colors plus `transparent`\n *\n * Not supported: `oklch()`, `lab()`, `color()`, `currentColor`, system\n * colors. Throws on anything unrecognized.\n *\n * Results are cached by input-string identity. Callers MUST treat the\n * returned tuple as read-only — mutation would corrupt the cache.\n */\nexport function parseColor(input: string): [number, number, number, number] {\n  const cached = CACHE.get(input);\n  if (cached !== undefined) return cached;\n  const result = parseColorUncached(input);\n  if (CACHE.size >= CACHE_MAX) CACHE.clear();\n  CACHE.set(input, result);\n  return result;\n}\n\nconst CACHE = new Map<string, [number, number, number, number]>();\nconst CACHE_MAX = 1024;\n\nfunction parseColorUncached(input: string): [number, number, number, number] {\n  const s = input.trim();\n  if (s.startsWith('#')) return parseHex(s);\n\n  const lower = s.toLowerCase();\n\n  // Named colors and `transparent` are checked before fn() forms because the\n  // fn() regexes won't match them anyway and the lookup is cheaper than a\n  // failed regex match.\n  const named = NAMED_COLORS[lower];\n  if (named !== undefined) return named;\n\n  if (lower.startsWith('rgb')) {\n    const parsed = parseRgbFunction(lower);\n    if (parsed) return parsed;\n  }\n  if (lower.startsWith('hsl')) {\n    const parsed = parseHslFunction(lower);\n    if (parsed) return parsed;\n  }\n\n  throw new Error(`parseColor: unrecognized color \"${input}\"`);\n}\n\nconst RESOLVE_COLOR_CACHE_CAP = 1024;\nconst resolveColorCache = new Map<string, readonly [number, number, number, number]>();\n\n/** Cached `parseColor`. Use this from renderer hot paths (per-frame draw\n *  callbacks, gradient ramp builds) so repeated color strings — which are\n *  common when many objects share a fill — don't re-tokenize each frame.\n *\n *  Cache is keyed by input-string identity, capped at ~1024 entries, and\n *  cleared wholesale on overflow (no LRU tracking — simple is fine since\n *  the working set in any one app is typically much smaller than the cap). */\nexport function resolveColor(input: string): readonly [number, number, number, number] {\n  const hit = resolveColorCache.get(input);\n  if (hit) return hit;\n  if (resolveColorCache.size >= RESOLVE_COLOR_CACHE_CAP) {\n    resolveColorCache.clear();\n  }\n  const parsed = parseColor(input);\n  const frozen = parsed as readonly [number, number, number, number];\n  resolveColorCache.set(input, frozen);\n  return frozen;\n}\n\n/** @internal Test-only: drops the resolveColor memoization cache so tests\n *  can assert behavior in isolation. Never call from production code. */\nexport function __resetResolveColorCache(): void {\n  resolveColorCache.clear();\n}\n\n/** Same as `parseColor` but returns integer 0..255 components. */\nexport function parseColorToRgba255(input: string): [number, number, number, number] {\n  const [r, g, b, a] = parseColor(input);\n  return [\n    Math.round(r * 255),\n    Math.round(g * 255),\n    Math.round(b * 255),\n    Math.round(a * 255),\n  ];\n}\n\n/**\n * Canonicalize a hex color string to lowercase `#rrggbb` or `#rrggbbaa`.\n *\n * Accepts: `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`, with or without the\n * leading `#`, any case. Throws on other inputs.\n */\nexport function normalizeHex(input: string): string {\n  const trimmed = input.trim();\n  const body = (trimmed.startsWith('#') ? trimmed.slice(1) : trimmed).toLowerCase();\n  if (!/^[0-9a-f]+$/.test(body)) {\n    throw new Error(`normalizeHex: invalid hex \"${input}\"`);\n  }\n  if (body.length === 3) {\n    return `#${body[0]}${body[0]}${body[1]}${body[1]}${body[2]}${body[2]}`;\n  }\n  if (body.length === 4) {\n    return `#${body[0]}${body[0]}${body[1]}${body[1]}${body[2]}${body[2]}${body[3]}${body[3]}`;\n  }\n  if (body.length === 6 || body.length === 8) {\n    return `#${body}`;\n  }\n  throw new Error(`normalizeHex: invalid hex \"${input}\"`);\n}\n\n/**\n * Parse a hex color into [r, g, b, a] with 0..1 components. Accepts the same\n * forms as `normalizeHex`, including a missing leading `#`.\n */\nexport function hexToRgba(input: string): [number, number, number, number] {\n  return parseHex(normalizeHex(input));\n}\n\n/**\n * Format [r, g, b, a] (0..1 components) as a hex string. Emits `#rrggbb` when\n * alpha is exactly 1 (or omitted), otherwise `#rrggbbaa`.\n */\nexport function rgbaToHex(rgba: readonly [number, number, number, number] | readonly [number, number, number]): string {\n  const [r, g, b] = rgba;\n  const a = rgba.length === 4 ? rgba[3] : 1;\n  const f = (n: number) => Math.max(0, Math.min(255, Math.round(n * 255))).toString(16).padStart(2, '0');\n  const base = `#${f(r)}${f(g)}${f(b)}`;\n  return a >= 1 ? base : `${base}${f(a)}`;\n}\n\nfunction parseHex(s: string): [number, number, number, number] {\n  const hex = s.slice(1);\n  if (hex.length === 3) {\n    return [\n      parseInt(hex[0] + hex[0], 16) / 255,\n      parseInt(hex[1] + hex[1], 16) / 255,\n      parseInt(hex[2] + hex[2], 16) / 255,\n      1,\n    ];\n  }\n  if (hex.length === 4) {\n    return [\n      parseInt(hex[0] + hex[0], 16) / 255,\n      parseInt(hex[1] + hex[1], 16) / 255,\n      parseInt(hex[2] + hex[2], 16) / 255,\n      parseInt(hex[3] + hex[3], 16) / 255,\n    ];\n  }\n  if (hex.length === 6) {\n    return [\n      parseInt(hex.slice(0, 2), 16) / 255,\n      parseInt(hex.slice(2, 4), 16) / 255,\n      parseInt(hex.slice(4, 6), 16) / 255,\n      1,\n    ];\n  }\n  if (hex.length === 8) {\n    return [\n      parseInt(hex.slice(0, 2), 16) / 255,\n      parseInt(hex.slice(2, 4), 16) / 255,\n      parseInt(hex.slice(4, 6), 16) / 255,\n      parseInt(hex.slice(6, 8), 16) / 255,\n    ];\n  }\n  throw new Error(`parseColor: invalid hex \"${s}\"`);\n}\n\n/** Match `name( body )` and return the trimmed body, or null. */\nfunction unwrapFn(s: string, name: string): string | null {\n  if (!s.startsWith(name + '(') || !s.endsWith(')')) return null;\n  return s.slice(name.length + 1, -1).trim();\n}\n\n/**\n * Split a function body into the value tokens (3 channels + optional alpha).\n * Supports both legacy `r, g, b[, a]` and modern `r g b[ / a]` separators.\n * Returns null if the token count is wrong.\n */\nfunction splitChannels(body: string): { rgb: [string, string, string]; alpha: string | null } | null {\n  if (body.includes(',')) {\n    const parts = body.split(',').map((p) => p.trim());\n    if (parts.length !== 3 && parts.length !== 4) return null;\n    return {\n      rgb: [parts[0], parts[1], parts[2]],\n      alpha: parts.length === 4 ? parts[3] : null,\n    };\n  }\n  // Modern syntax: whitespace-separated, with optional `/ alpha` tail.\n  const slash = body.indexOf('/');\n  const head = (slash === -1 ? body : body.slice(0, slash)).trim();\n  const alpha = slash === -1 ? null : body.slice(slash + 1).trim();\n  const parts = head.split(/\\s+/);\n  if (parts.length !== 3) return null;\n  if (alpha !== null && alpha === '') return null;\n  return { rgb: [parts[0], parts[1], parts[2]], alpha };\n}\n\n/** Parse a channel value: integer, float, or percent. Returns 0..1 (with `max` as the integer scale). */\nfunction parseChannel(tok: string, max: number): number | null {\n  if (tok.endsWith('%')) {\n    const n = Number(tok.slice(0, -1));\n    if (!Number.isFinite(n)) return null;\n    return clamp01(n / 100);\n  }\n  const n = Number(tok);\n  if (!Number.isFinite(n)) return null;\n  return clamp01(n / max);\n}\n\n/** Alpha may be a number 0..1 or a percent. */\nfunction parseAlpha(tok: string | null): number {\n  if (tok === null) return 1;\n  if (tok.endsWith('%')) {\n    const n = Number(tok.slice(0, -1));\n    return Number.isFinite(n) ? clamp01(n / 100) : 1;\n  }\n  const n = Number(tok);\n  return Number.isFinite(n) ? clamp01(n) : 1;\n}\n\nfunction parseRgbFunction(s: string): [number, number, number, number] | null {\n  const body = unwrapFn(s, 'rgba') ?? unwrapFn(s, 'rgb');\n  if (body === null) return null;\n  const channels = splitChannels(body);\n  if (!channels) return null;\n  const r = parseChannel(channels.rgb[0], 255);\n  const g = parseChannel(channels.rgb[1], 255);\n  const b = parseChannel(channels.rgb[2], 255);\n  if (r === null || g === null || b === null) return null;\n  return [r, g, b, parseAlpha(channels.alpha)];\n}\n\nfunction parseHslFunction(s: string): [number, number, number, number] | null {\n  const body = unwrapFn(s, 'hsla') ?? unwrapFn(s, 'hsl');\n  if (body === null) return null;\n  const channels = splitChannels(body);\n  if (!channels) return null;\n  const h = parseHue(channels.rgb[0]);\n  const sat = parsePercentOrNumber(channels.rgb[1]);\n  const lit = parsePercentOrNumber(channels.rgb[2]);\n  if (h === null || sat === null || lit === null) return null;\n  const [r, g, b] = hslToRgb(h, sat, lit);\n  return [r, g, b, parseAlpha(channels.alpha)];\n}\n\n/** Parse a hue token: `<number>`, `<number>deg`, `<number>rad`, `<number>grad`, `<number>turn`. Returns degrees 0..360 (modulo). */\nfunction parseHue(tok: string): number | null {\n  let n: number;\n  if (tok.endsWith('deg')) n = Number(tok.slice(0, -3));\n  else if (tok.endsWith('grad')) n = Number(tok.slice(0, -4)) * 0.9; // 400grad = 360deg\n  else if (tok.endsWith('rad')) n = Number(tok.slice(0, -3)) * (180 / Math.PI);\n  else if (tok.endsWith('turn')) n = Number(tok.slice(0, -4)) * 360;\n  else n = Number(tok);\n  if (!Number.isFinite(n)) return null;\n  return ((n % 360) + 360) % 360;\n}\n\n/** Saturation/lightness may be percent (CSS Color 3) or unitless number 0..1 (modern). */\nfunction parsePercentOrNumber(tok: string): number | null {\n  if (tok.endsWith('%')) {\n    const n = Number(tok.slice(0, -1));\n    return Number.isFinite(n) ? clamp01(n / 100) : null;\n  }\n  const n = Number(tok);\n  return Number.isFinite(n) ? clamp01(n) : null;\n}\n\n/**\n * HSL → RGB, all components 0..1 except hue in degrees (0..360). paint's\n * `hslToSrgb` under the name this file's callers use.\n *\n * @internal Not part of the public API; not re-exported from the barrel.\n */\nexport const hslToRgb = hslToSrgb;\n\nfunction clamp01(n: number): number {\n  return n < 0 ? 0 : n > 1 ? 1 : n;\n}\n\n// CSS Color Module Level 4 named colors. Stored as already-resolved tuples so\n// lookup is O(1) and avoids a second parse hop.\nconst NAMED_COLORS: Record<string, [number, number, number, number]> = (() => {\n  const hex: Record<string, number> = {\n    aliceblue: 0xf0f8ff, antiquewhite: 0xfaebd7, aqua: 0x00ffff, aquamarine: 0x7fffd4,\n    azure: 0xf0ffff, beige: 0xf5f5dc, bisque: 0xffe4c4, black: 0x000000,\n    blanchedalmond: 0xffebcd, blue: 0x0000ff, blueviolet: 0x8a2be2, brown: 0xa52a2a,\n    burlywood: 0xdeb887, cadetblue: 0x5f9ea0, chartreuse: 0x7fff00, chocolate: 0xd2691e,\n    coral: 0xff7f50, cornflowerblue: 0x6495ed, cornsilk: 0xfff8dc, crimson: 0xdc143c,\n    cyan: 0x00ffff, darkblue: 0x00008b, darkcyan: 0x008b8b, darkgoldenrod: 0xb8860b,\n    darkgray: 0xa9a9a9, darkgreen: 0x006400, darkgrey: 0xa9a9a9, darkkhaki: 0xbdb76b,\n    darkmagenta: 0x8b008b, darkolivegreen: 0x556b2f, darkorange: 0xff8c00, darkorchid: 0x9932cc,\n    darkred: 0x8b0000, darksalmon: 0xe9967a, darkseagreen: 0x8fbc8f, darkslateblue: 0x483d8b,\n    darkslategray: 0x2f4f4f, darkslategrey: 0x2f4f4f, darkturquoise: 0x00ced1, darkviolet: 0x9400d3,\n    deeppink: 0xff1493, deepskyblue: 0x00bfff, dimgray: 0x696969, dimgrey: 0x696969,\n    dodgerblue: 0x1e90ff, firebrick: 0xb22222, floralwhite: 0xfffaf0, forestgreen: 0x228b22,\n    fuchsia: 0xff00ff, gainsboro: 0xdcdcdc, ghostwhite: 0xf8f8ff, gold: 0xffd700,\n    goldenrod: 0xdaa520, gray: 0x808080, green: 0x008000, greenyellow: 0xadff2f,\n    grey: 0x808080, honeydew: 0xf0fff0, hotpink: 0xff69b4, indianred: 0xcd5c5c,\n    indigo: 0x4b0082, ivory: 0xfffff0, khaki: 0xf0e68c, lavender: 0xe6e6fa,\n    lavenderblush: 0xfff0f5, lawngreen: 0x7cfc00, lemonchiffon: 0xfffacd, lightblue: 0xadd8e6,\n    lightcoral: 0xf08080, lightcyan: 0xe0ffff, lightgoldenrodyellow: 0xfafad2, lightgray: 0xd3d3d3,\n    lightgreen: 0x90ee90, lightgrey: 0xd3d3d3, lightpink: 0xffb6c1, lightsalmon: 0xffa07a,\n    lightseagreen: 0x20b2aa, lightskyblue: 0x87cefa, lightslategray: 0x778899, lightslategrey: 0x778899,\n    lightsteelblue: 0xb0c4de, lightyellow: 0xffffe0, lime: 0x00ff00, limegreen: 0x32cd32,\n    linen: 0xfaf0e6, magenta: 0xff00ff, maroon: 0x800000, mediumaquamarine: 0x66cdaa,\n    mediumblue: 0x0000cd, mediumorchid: 0xba55d3, mediumpurple: 0x9370db, mediumseagreen: 0x3cb371,\n    mediumslateblue: 0x7b68ee, mediumspringgreen: 0x00fa9a, mediumturquoise: 0x48d1cc, mediumvioletred: 0xc71585,\n    midnightblue: 0x191970, mintcream: 0xf5fffa, mistyrose: 0xffe4e1, moccasin: 0xffe4b5,\n    navajowhite: 0xffdead, navy: 0x000080, oldlace: 0xfdf5e6, olive: 0x808000,\n    olivedrab: 0x6b8e23, orange: 0xffa500, orangered: 0xff4500, orchid: 0xda70d6,\n    palegoldenrod: 0xeee8aa, palegreen: 0x98fb98, paleturquoise: 0xafeeee, palevioletred: 0xdb7093,\n    papayawhip: 0xffefd5, peachpuff: 0xffdab9, peru: 0xcd853f, pink: 0xffc0cb,\n    plum: 0xdda0dd, powderblue: 0xb0e0e6, purple: 0x800080, rebeccapurple: 0x663399,\n    red: 0xff0000, rosybrown: 0xbc8f8f, royalblue: 0x4169e1, saddlebrown: 0x8b4513,\n    salmon: 0xfa8072, sandybrown: 0xf4a460, seagreen: 0x2e8b57, seashell: 0xfff5ee,\n    sienna: 0xa0522d, silver: 0xc0c0c0, skyblue: 0x87ceeb, slateblue: 0x6a5acd,\n    slategray: 0x708090, slategrey: 0x708090, snow: 0xfffafa, springgreen: 0x00ff7f,\n    steelblue: 0x4682b4, tan: 0xd2b48c, teal: 0x008080, thistle: 0xd8bfd8,\n    tomato: 0xff6347, turquoise: 0x40e0d0, violet: 0xee82ee, wheat: 0xf5deb3,\n    white: 0xffffff, whitesmoke: 0xf5f5f5, yellow: 0xffff00, yellowgreen: 0x9acd32,\n  };\n  const out: Record<string, [number, number, number, number]> = {\n    transparent: [0, 0, 0, 0],\n  };\n  for (const name in hex) {\n    const n = hex[name];\n    out[name] = [((n >> 16) & 0xff) / 255, ((n >> 8) & 0xff) / 255, (n & 0xff) / 255, 1];\n  }\n  return out;\n})();\n"],"mappings":"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"}

package/dist/renderer/math/mat3.js

@@ -0,0 +1,71 @@
+import { invert as e } from "@weasel-js/geom";
+//#region src/renderer/math/mat3.ts
+function t(e, t, n, r, i, a) {
+	return new Float32Array([
+		e,
+		t,
+		0,
+		n,
+		r,
+		0,
+		i,
+		a,
+		1
+	]);
+}
+function n() {
+	return t(1, 0, 0, 1, 0, 0);
+}
+function r(e, n) {
+	let r = e[0], i = e[1], a = e[3], o = e[4], s = e[6], c = e[7], l = n[0], u = n[1], d = n[3], f = n[4], p = n[6], m = n[7];
+	return t(r * l + a * u, i * l + o * u, r * d + a * f, i * d + o * f, r * p + a * m + s, i * p + o * m + c);
+}
+function i(e, n, i) {
+	return r(e, t(1, 0, 0, 1, n, i));
+}
+function a(e, n, i) {
+	return r(e, t(n, 0, 0, i, 0, 0));
+}
+function o(e) {
+	return [
+		e[0],
+		e[1],
+		e[3],
+		e[4],
+		e[6],
+		e[7]
+	];
+}
+function s(e) {
+	return t(e[0], e[1], e[2], e[3], e[4], e[5]);
+}
+function c(t) {
+	let n = e(o(t));
+	return n && s(n);
+}
+function l(e, t, n) {
+	let r = e[0], i = e[1], a = e[3], o = e[4], s = e[6], c = e[7];
+	return [r * t + a * n + s, i * t + o * n + c];
+}
+function u(e, n) {
+	return t(2 / e, 0, 0, -2 / n, -1, 1);
+}
+function d(e) {
+	return Math.sqrt(Math.abs(e[0] * e[4] - e[1] * e[3]));
+}
+var f = {
+	identity: n,
+	toAffine: o,
+	fromAffine: s,
+	multiply: r,
+	translated: i,
+	scaled: a,
+	invert: c,
+	apply: l,
+	screenToClip: u,
+	meanScaleOf: d
+};
+//#endregion
+export { f as mat3 };
+
+//# sourceMappingURL=mat3.js.map

package/dist/renderer/math/mat3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mat3.js","names":["multiply","invert","invertAffine","create","a","b","c","d","tx","ty","identity","multiply$1","out","ma","m","mb","mc","md","mtx","mty","translated","scaled","sx","sy","toAffine","fromAffine","invert$1","inv","invert","apply","x","y","screenToClip","width","height","meanScaleOf","mat3"],"sources":["../../../src/renderer/math/mat3.ts"],"sourcesContent":["/**\n * 2D affine matrix utilities. Column-major 9-element Float32Array, matching\n * `WebGL2RenderingContext.uniformMatrix3fv` byte order so we can pass the\n * array directly without a transpose flag.\n *\n * Layout (column-major):\n *   [m00, m10, 0,\n *    m01, m11, 0,\n *    tx,  ty,  1]\n *\n * `apply(m, x, y)` returns `[m * (x, y, 1)] = [m00*x + m01*y + tx,\n *                                              m10*x + m11*y + ty]`.\n */\n\nimport { invert as invertAffine, type Mat3 as Affine } from '@weasel-js/geom';\n\n/** A 2D affine transform as a column-major 9-element `Float32Array`, laid out as above. */\nexport type GlMat3 = Float32Array;\n\nfunction create(a: number, b: number, c: number, d: number, tx: number, ty: number): GlMat3 {\n  // Column-major:\n  //   col 0: (a, b, 0)\n  //   col 1: (c, d, 0)\n  //   col 2: (tx, ty, 1)\n  return new Float32Array([a, b, 0, c, d, 0, tx, ty, 1]);\n}\n\nfunction identity(): GlMat3 {\n  return create(1, 0, 0, 1, 0, 0);\n}\n\nfunction multiply(out: GlMat3, m: GlMat3): GlMat3 {\n  // out := out · m  (right-multiply by m).\n  const a = out[0], b = out[1];\n  const c = out[3], d = out[4];\n  const tx = out[6], ty = out[7];\n  const ma = m[0], mb = m[1];\n  const mc = m[3], md = m[4];\n  const mtx = m[6], mty = m[7];\n\n  return create(\n    a * ma + c * mb,                 // new a\n    b * ma + d * mb,                 // new b\n    a * mc + c * md,                 // new c\n    b * mc + d * md,                 // new d\n    a * mtx + c * mty + tx,          // new tx\n    b * mtx + d * mty + ty,          // new ty\n  );\n}\n\n/** `m · T(tx, ty)`: composes onto `m`, where `@weasel-js/geom`'s `translate`\n *  constructs a fresh matrix. */\nfunction translated(m: GlMat3, tx: number, ty: number): GlMat3 {\n  const t = create(1, 0, 0, 1, tx, ty);\n  return multiply(m, t);\n}\n\n/** `m · S(sx, sy)`: composes onto `m`, where geom's `scale` constructs one. */\nfunction scaled(m: GlMat3, sx: number, sy: number): GlMat3 {\n  const s = create(sx, 0, 0, sy, 0, 0);\n  return multiply(m, s);\n}\n\n/** This layout read as the kernel's 6-element affine. The two carry the same\n *  logical order, so the conversion is a repack and nothing else — it exists\n *  so the repack has a name instead of appearing inline at each crossing. */\nfunction toAffine(m: GlMat3): Affine {\n  return [m[0], m[1], m[3], m[4], m[6], m[7]];\n}\n\n/** The kernel's affine in this layout. The inverse of {@link toAffine}, and\n *  what an `SvgGroupNode.transform` (also a kernel affine) becomes on its way\n *  to a `GroupDrawCommand`. */\nfunction fromAffine(a: Affine): GlMat3 {\n  return create(a[0], a[1], a[2], a[3], a[4], a[5]);\n}\n\n/** Inverse of an affine matrix, or `null` when `@weasel-js/geom`'s `invert`\n *  finds it singular — the same rule, read through this layout. */\nfunction invert(m: GlMat3): GlMat3 | null {\n  const inv = invertAffine(toAffine(m));\n  return inv && fromAffine(inv);\n}\n\nfunction apply(m: GlMat3, x: number, y: number): [number, number] {\n  const a = m[0], b = m[1];\n  const c = m[3], d = m[4];\n  const tx = m[6], ty = m[7];\n  return [a * x + c * y + tx, b * x + d * y + ty];\n}\n\n/**\n * Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)\n * into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down\n * matches clip-down).\n */\nfunction screenToClip(width: number, height: number): GlMat3 {\n  return create(\n    2 / width,                       // a\n    0,                               // b\n    0,                               // c\n    -2 / height,                     // d\n    -1,                              // tx\n    1,                               // ty\n  );\n}\n\n/**\n * Uniform-equivalent scale factor: the square root of the absolute\n * determinant of the linear part, i.e. the geometric mean of the two axis\n * scales. Rotation-invariant. Under non-uniform scale it is between the two\n * axes and exact on neither — the same compromise `meanScale` documents.\n */\nfunction meanScaleOf(m: GlMat3): number {\n  return Math.sqrt(Math.abs(m[0] * m[4] - m[1] * m[3]));\n}\n\n/** The renderer's 3x3 matrix operations, as one namespace. These work on the\n *  9-element `Float32Array` form the GL uniform upload wants — distinct from\n *  `@weasel-js/geom`'s 6-element affine `GlMat3`, though the logical element\n *  order is the same. */\nexport const mat3 = {\n  identity,\n  toAffine,\n  fromAffine,\n  multiply,\n  translated,\n  scaled,\n  invert,\n  apply,\n  screenToClip,\n  meanScaleOf,\n};\n"],"mappings":";;AAmBA,SAASG,EAAO,GAAW,GAAW,GAAW,GAAW,GAAY,GAAoB;CAK1F,OAAO,IAAI,aAAa;EAACC;EAAGC;EAAG;EAAGC;EAAGC;EAAG;EAAGC;EAAIC;EAAI;CAAC,CAAC;AACvD;AAEA,SAASC,IAAmB;CAC1B,OAAOP,EAAO,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAChC;AAEA,SAASH,EAAS,GAAa,GAAmB;CAEhD,IAAMI,IAAIQ,EAAI,IAAIP,IAAIO,EAAI,IACpBN,IAAIM,EAAI,IAAIL,IAAIK,EAAI,IACpBJ,IAAKI,EAAI,IAAIH,IAAKG,EAAI,IACtBC,IAAKC,EAAE,IAAIC,IAAKD,EAAE,IAClBE,IAAKF,EAAE,IAAIG,IAAKH,EAAE,IAClBI,IAAMJ,EAAE,IAAIK,IAAML,EAAE;CAE1B,OAAOX,EACLC,IAAIS,IAAKP,IAAIS,GACbV,IAAIQ,IAAKN,IAAIQ,GACbX,IAAIY,IAAKV,IAAIW,GACbZ,IAAIW,IAAKT,IAAIU,GACbb,IAAIc,IAAMZ,IAAIa,IAAMX,GACpBH,IAAIa,IAAMX,IAAIY,IAAMV,CACtB;AACF;AAIA,SAASW,EAAW,GAAW,GAAY,GAAoB;CAE7D,OAAOpB,EAASc,GADNX,EAAO,GAAG,GAAG,GAAG,GAAGK,GAAIC,CACd,CAAC;AACtB;AAGA,SAASY,EAAO,GAAW,GAAY,GAAoB;CAEzD,OAAOrB,EAASc,GADNX,EAAOmB,GAAI,GAAG,GAAGC,GAAI,GAAG,CACf,CAAC;AACtB;AAKA,SAASC,EAAS,GAAmB;CACnC,OAAO;EAACV,EAAE;EAAIA,EAAE;EAAIA,EAAE;EAAIA,EAAE;EAAIA,EAAE;EAAIA,EAAE;CAAE;AAC5C;AAKA,SAASW,EAAW,GAAmB;CACrC,OAAOtB,EAAOC,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE,EAAE;AAClD;AAIA,SAASH,EAAO,GAA0B;CACxC,IAAM0B,IAAMzB,EAAasB,EAASV,CAAC,CAAC;CACpC,OAAOa,KAAOF,EAAWE,CAAG;AAC9B;AAEA,SAASE,EAAM,GAAW,GAAW,GAA6B;CAChE,IAAMzB,IAAIU,EAAE,IAAIT,IAAIS,EAAE,IAChBR,IAAIQ,EAAE,IAAIP,IAAIO,EAAE,IAChBN,IAAKM,EAAE,IAAIL,IAAKK,EAAE;CACxB,OAAO,CAACV,IAAI0B,IAAIxB,IAAIyB,IAAIvB,GAAIH,IAAIyB,IAAIvB,IAAIwB,IAAItB,CAAE;AAChD;AAOA,SAASuB,EAAa,GAAe,GAAwB;CAC3D,OAAO7B,EACL,IAAI8B,GACJ,GACA,GACA,KAAKC,GACL,IACA,CACF;AACF;AAQA,SAASC,EAAY,GAAmB;CACtC,OAAO,KAAK,KAAK,KAAK,IAAIrB,EAAE,KAAKA,EAAE,KAAKA,EAAE,KAAKA,EAAE,EAAE,CAAC;AACtD;AAMA,IAAasB,IAAO;CAClB;CACA;CACA;CACA,UAAAzB;CACA;CACA;CACA,QAAAe;CACA;CACA;CACA;AACF"}

package/dist/renderer/math/patternSpace.js

@@ -0,0 +1,22 @@
+import { mat3 as e } from "./mat3.js";
+//#region src/renderer/math/patternSpace.ts
+function t(t, n, r) {
+	let [i, a, o, s] = r ?? [
+		1,
+		0,
+		0,
+		1
+	], c = e.fromAffine([
+		i,
+		a,
+		o,
+		s,
+		n.x,
+		n.y
+	]), l = e.invert(c);
+	return l && e.multiply(l, t);
+}
+//#endregion
+export { t as patternTileSpace };
+
+//# sourceMappingURL=patternSpace.js.map

package/dist/renderer/math/patternSpace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patternSpace.js","names":["patternTileSpace","a","b","c","d","transform","placement","mat3","origin","unplace","spaceInverse"],"sources":["../../../src/renderer/math/patternSpace.ts"],"sourcesContent":["import type { PatternTransform } from '@weasel-js/paint';\nimport { mat3, type GlMat3 } from './mat3';\n\n/**\n * Screen → tile-space matrix for a pattern fill: `spaceInverse` takes a screen\n * position into the paint's `units` space, then this undoes the tile's\n * placement there, `origin + transform · tile`. Tile space is in paint units,\n * so the shader divides by the tile's size to get a texture coordinate.\n *\n * `null` when `transform` is singular — a tile collapsed to a line has no\n * point to sample for most of the plane, and a paint with no inverse draws\n * nothing, as gradients do.\n */\nexport function patternTileSpace(\n  spaceInverse: GlMat3,\n  origin: { x: number; y: number },\n  transform: PatternTransform | undefined,\n): GlMat3 | null {\n  const [a, b, c, d] = transform ?? [1, 0, 0, 1];\n  const placement = mat3.fromAffine([a, b, c, d, origin.x, origin.y]);\n  const unplace = mat3.invert(placement);\n  return unplace && mat3.multiply(unplace, spaceInverse);\n}\n"],"mappings":";;AAaA,SAAgBA,EACd,GACA,GACA,GACe;CACf,IAAM,CAACC,GAAGC,GAAGC,GAAGC,KAAKC,KAAa;EAAC;EAAG;EAAG;EAAG;CAAC,GACvCC,IAAYC,EAAK,WAAW;EAACN;EAAGC;EAAGC;EAAGC;EAAGI,EAAO;EAAGA,EAAO;CAAC,CAAC,GAC5DC,IAAUF,EAAK,OAAOD,CAAS;CACrC,OAAOG,KAAWF,EAAK,SAASE,GAASC,CAAY;AACvD"}

package/dist/renderer/math/viewToMat3.js

@@ -0,0 +1,19 @@
+//#region src/renderer/math/viewToMat3.ts
+function e(e) {
+	let t = e.scale.x, n = e.scale.y, r = -e.x * t + 0, i = -e.y * n + 0;
+	return new Float32Array([
+		t,
+		0,
+		0,
+		0,
+		n,
+		0,
+		r,
+		i,
+		1
+	]);
+}
+//#endregion
+export { e as viewToMat3 };
+
+//# sourceMappingURL=viewToMat3.js.map

package/dist/renderer/math/viewToMat3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewToMat3.js","names":["viewToMat3","sx","view","sy","tx","ty"],"sources":["../../../src/renderer/math/viewToMat3.ts"],"sourcesContent":["/**\n * View → GlMat3 helper for layer `draw` implementations on world-space layers.\n *\n * `View` is `@weasel-js/routing`'s, the one every viewport action is typed\n * in. A type-only import emits no runtime edge, so there is no reason for the\n * renderer to hold a second structurally-identical declaration and put it in\n * the emitted `.d.ts` anonymously.\n */\n\nimport type { View } from '@weasel-js/routing';\nimport type { GlMat3 } from './mat3';\n\nexport type { View };\n\n/**\n * Build the world→screen transform matrix for a `View`.\n * Use as the `transform` field of a `kind: 'group'` DrawCommand to wrap\n * world-space content emitted from a layer `draw` implementation.\n *\n * Mapping: `screen = (world − {view.x, view.y}) × {view.scale.x, view.scale.y}`.\n *\n * Column-major layout (matches `mat3.identity()`):\n * `[scale.x, 0, 0,  0, scale.y, 0,  -view.x*scale.x, -view.y*scale.y, 1]`.\n */\nexport function viewToMat3(view: View): GlMat3 {\n  const sx = view.scale.x;\n  const sy = view.scale.y;\n  // Add 0 to coerce -0 → 0, matching `mat3.identity()` for the {0,0,1} case.\n  const tx = -view.x * sx + 0;\n  const ty = -view.y * sy + 0;\n  return new Float32Array([\n    sx, 0, 0,\n    0, sy, 0,\n    tx, ty, 1,\n  ]) as GlMat3;\n}\n"],"mappings":";AAwBA,SAAgBA,EAAW,GAAoB;CAC7C,IAAMC,IAAKC,EAAK,MAAM,GAChBC,IAAKD,EAAK,MAAM,GAEhBE,IAAK,CAACF,EAAK,IAAID,IAAK,GACpBI,IAAK,CAACH,EAAK,IAAIC,IAAK;CAC1B,OAAO,IAAI,aAAa;EACtBF;EAAI;EAAG;EACP;EAAGE;EAAI;EACPC;EAAIC;EAAI;CACV,CAAC;AACH"}

package/dist/renderer/paintResources.js

@@ -0,0 +1,18 @@
+//#region src/renderer/paintResources.ts
+function e() {
+	let e = [];
+	return {
+		onRelease(t) {
+			e ? e.push(t) : t();
+		},
+		release() {
+			let t = e;
+			e = null;
+			for (let e of t ?? []) e();
+		}
+	};
+}
+//#endregion
+export { e as createPaintResources };
+
+//# sourceMappingURL=paintResources.js.map

package/dist/renderer/paintResources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paintResources.js","names":["createPaintResources","releases","release","pending"],"sources":["../../src/renderer/paintResources.ts"],"sourcesContent":["import type { PaintResources } from 'core/paintKinds';\n\n/** A {@link PaintResources} with the end of its lifetime in the owner's hands. */\nexport interface OwnedPaintResources extends PaintResources {\n  /** Run every registered release, once. Idempotent. */\n  release(): void;\n}\n\n/** A fresh paint-resource lifetime. The renderer opens one per context\n *  generation and releases it on dispose or context restore. */\nexport function createPaintResources(): OwnedPaintResources {\n  let releases: Array<() => void> | null = [];\n  return {\n    onRelease(release) {\n      if (releases) releases.push(release);\n      else release();\n    },\n    release() {\n      const pending = releases;\n      releases = null;\n      for (const release of pending ?? []) release();\n    },\n  };\n}\n"],"mappings":";AAUA,SAAgBA,IAA4C;CAC1D,IAAIC,IAAqC,CAAC;CAC1C,OAAO;EACL,UAAU,GAAS;GACjB,AAAIA,IAAUA,EAAS,KAAKC,CAAO,IAC9BA,EAAQ;EACf;EACA,UAAU;GACR,IAAMC,IAAUF;GAChB,IAAW;GACX,KAAK,IAAMC,KAAWC,KAAW,CAAC,GAAG,EAAQ;EAC/C;CACF;AACF"}

package/dist/renderer/paintScratch.js

@@ -0,0 +1,37 @@
+//#region src/renderer/paintScratch.ts
+var e = class {
+	gl;
+	target = null;
+	constructor(e) {
+		this.gl = e;
+	}
+	acquire(e, n) {
+		let r = this.target;
+		if (r && r.width >= e && r.height >= n) return r;
+		let i = Math.max(r?.width ?? 0, t(e)), a = Math.max(r?.height ?? 0, t(n));
+		return this.release(), this.target = this.create(i, a), this.target;
+	}
+	release() {
+		this.target &&= (this.gl.deleteFramebuffer(this.target.fbo), this.gl.deleteTexture(this.target.texture), null);
+	}
+	create(e, t) {
+		let n = this.gl, r = n.createTexture();
+		n.bindTexture(n.TEXTURE_2D, r), n.texImage2D(n.TEXTURE_2D, 0, n.RGBA8, e, t, 0, n.RGBA, n.UNSIGNED_BYTE, null), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, n.NEAREST), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, n.NEAREST), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_S, n.CLAMP_TO_EDGE), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_T, n.CLAMP_TO_EDGE), n.bindTexture(n.TEXTURE_2D, null);
+		let i = n.createFramebuffer();
+		return n.bindFramebuffer(n.FRAMEBUFFER, i), n.framebufferTexture2D(n.FRAMEBUFFER, n.COLOR_ATTACHMENT0, n.TEXTURE_2D, r, 0), n.bindFramebuffer(n.FRAMEBUFFER, null), {
+			fbo: i,
+			texture: r,
+			width: e,
+			height: t
+		};
+	}
+};
+function t(e) {
+	let t = 64;
+	for (; t < e;) t *= 2;
+	return t;
+}
+//#endregion
+export { e as PaintScratch };
+
+//# sourceMappingURL=paintScratch.js.map

package/dist/renderer/paintScratch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paintScratch.js","names":["PaintScratch","gl","have","width","height","w","pow2","h","texture","fbo","side","n"],"sources":["../../src/renderer/paintScratch.ts"],"sourcesContent":["/**\n * The offscreen color buffer a registered paint kind renders into when what it\n * fills is not a path: atlas glyphs, whose coverage then masks what it drew.\n *\n * One per renderer, grown in powers of two to the largest region asked of it\n * and never shrunk, so a frame of differently sized text groups reallocates a\n * few times and then not at all. The region is clamped to the drawing buffer,\n * which bounds the buffer too. It has no stencil: nothing drawn into it is\n * clipped — the clip applies to the glyphs sampling it.\n */\n\nexport interface PaintScratchTarget {\n  readonly fbo: WebGLFramebuffer;\n  readonly texture: WebGLTexture;\n  /** Texture size, at least the region asked for. */\n  readonly width: number;\n  readonly height: number;\n}\n\nconst MIN_SIDE = 64;\n\nexport class PaintScratch {\n  private readonly gl: WebGL2RenderingContext;\n  private target: PaintScratchTarget | null = null;\n\n  constructor(gl: WebGL2RenderingContext) {\n    this.gl = gl;\n  }\n\n  /** A buffer at least `width` × `height` device pixels. Its contents are\n   *  whatever the last user left; the caller clears the region it uses. */\n  acquire(width: number, height: number): PaintScratchTarget {\n    const have = this.target;\n    if (have && have.width >= width && have.height >= height) return have;\n    const w = Math.max(have?.width ?? 0, pow2(width));\n    const h = Math.max(have?.height ?? 0, pow2(height));\n    this.release();\n    this.target = this.create(w, h);\n    return this.target;\n  }\n\n  /** Drop the buffer. Called on dispose and on context restore, where the\n   *  handles are already dead and only the bookkeeping has to go. */\n  release(): void {\n    if (!this.target) return;\n    this.gl.deleteFramebuffer(this.target.fbo);\n    this.gl.deleteTexture(this.target.texture);\n    this.target = null;\n  }\n\n  private create(width: number, height: number): PaintScratchTarget {\n    const gl = this.gl;\n    const texture = gl.createTexture()!;\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);\n    // The region is laid on the device-pixel grid, so every fragment reading\n    // it lands on a texel center and NEAREST is exact.\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n    gl.bindTexture(gl.TEXTURE_2D, null);\n\n    const fbo = gl.createFramebuffer()!;\n    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);\n    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n    gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n    return { fbo, texture, width, height };\n  }\n}\n\nfunction pow2(n: number): number {\n  let side = MIN_SIDE;\n  while (side < n) side *= 2;\n  return side;\n}\n"],"mappings":";AAmBA,IAEaA,IAAb,MAA0B;CACxB;CACA,SAA4C;CAE5C,YAAY,GAA4B;EACtC,KAAK,KAAKC;CACZ;CAIA,QAAQ,GAAe,GAAoC;EACzD,IAAMC,IAAO,KAAK;EAClB,IAAIA,KAAQA,EAAK,SAASC,KAASD,EAAK,UAAUE,GAAQ,OAAOF;EACjE,IAAMG,IAAI,KAAK,IAAIH,GAAM,SAAS,GAAGI,EAAKH,CAAK,CAAC,GAC1CI,IAAI,KAAK,IAAIL,GAAM,UAAU,GAAGI,EAAKF,CAAM,CAAC;EAGlD,OAFA,KAAK,QAAQ,GACb,KAAK,SAAS,KAAK,OAAOC,GAAGE,CAAC,GACvB,KAAK;CACd;CAIA,UAAgB;EACd,AAGA,KAAK,YAFL,KAAK,GAAG,kBAAkB,KAAK,OAAO,GAAG,GACzC,KAAK,GAAG,cAAc,KAAK,OAAO,OAAO,GAC3B;CAChB;CAEA,OAAe,GAAe,GAAoC;EAChE,IAAMN,IAAK,KAAK,IACVO,IAAUP,EAAG,cAAc;EASjC,AARAA,EAAG,YAAYA,EAAG,YAAYO,CAAO,GACrCP,EAAG,WAAWA,EAAG,YAAY,GAAGA,EAAG,OAAOE,GAAOC,GAAQ,GAAGH,EAAG,MAAMA,EAAG,eAAe,IAAI,GAG3FA,EAAG,cAAcA,EAAG,YAAYA,EAAG,oBAAoBA,EAAG,OAAO,GACjEA,EAAG,cAAcA,EAAG,YAAYA,EAAG,oBAAoBA,EAAG,OAAO,GACjEA,EAAG,cAAcA,EAAG,YAAYA,EAAG,gBAAgBA,EAAG,aAAa,GACnEA,EAAG,cAAcA,EAAG,YAAYA,EAAG,gBAAgBA,EAAG,aAAa,GACnEA,EAAG,YAAYA,EAAG,YAAY,IAAI;EAElC,IAAMQ,IAAMR,EAAG,kBAAkB;EAIjC,OAHAA,EAAG,gBAAgBA,EAAG,aAAaQ,CAAG,GACtCR,EAAG,qBAAqBA,EAAG,aAAaA,EAAG,mBAAmBA,EAAG,YAAYO,GAAS,CAAC,GACvFP,EAAG,gBAAgBA,EAAG,aAAa,IAAI,GAChC;GAAE;GAAK;GAAS;GAAO;EAAO;CACvC;AACF;AAEA,SAASK,EAAK,GAAmB;CAC/B,IAAII,IAAO;CACX,OAAOA,IAAOC,IAAG,KAAQ;CACzB,OAAOD;AACT"}

package/dist/renderer/shaders/ShaderProgram.js

@@ -0,0 +1,74 @@
+//#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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,118 @@
+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 65% of a fragment that is not
+  // a gradient; splitting it costs 5% (tests/perf/fill-rate.spec.ts).
+  //
+  // 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

@@ -0,0 +1 @@
+{"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`), that roughly doubles a fragment that is not\n * a glyph — the figure recorded when text landed was 1.4%, and it was wrong:\n * the control gated its glyph math on a factor the compiler folds to zero, so\n * it timed a shader with that math deleted. Fill is not what a wall is bound\n * by, which is 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, which is 65% of\n * a fragment against 5%.\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 measures 9%\n * slower at the densest rung of `tests/perf/atlas-wall.spec.ts` — 1.78 ms\n * against 1.63 for 7,500 commands, taken ABBA in one sitting — because 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 65% of a fragment that is not\n  // a gradient; splitting it costs 5% (tests/perf/fill-rate.spec.ts).\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":";;AAoFA,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;;;;;;;;;;;;;;;;;uCAiBiBZ,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

@@ -0,0 +1,34 @@
+//#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

@@ -0,0 +1 @@
+{"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"}