@weasel-js/core 1.9.4 → 1.10.1

package/dist/renderer/draw/paintBind.js

@@ -1,70 +0,0 @@
-import { createPaintResources as e } from "../paintResources.js";
-import { getTexture as t } from "../textures/registerTexture.js";
-import { mat3 as n } from "../math/mat3.js";
-import { setAlphaUniform as r, setColorMatrixUniforms as i, setProjAndModel as a } from "./uniforms.js";
-import { gradientSpaceInverse as o, spaceToDevice as s } from "./gradient.js";
-import { patternTileSpace as c } from "../math/patternSpace.js";
-//#region src/renderer/draw/paintBind.ts
-function l(e) {
-	let t = u.get(e);
-	if (t) return t;
-	let n = {
-		gl: e.gl,
-		get alpha() {
-			return e.state.alpha;
-		},
-		program: (t) => e.ensureProgram?.(t) ?? e.programRegistry.get(t) ?? null,
-		setProjAndModel: (t) => a(e, t),
-		spaceInverse: (t) => o(e, t),
-		spaceToDevice: (t) => s(e, t),
-		get maxTextureSize() {
-			return e.imageCache.maxTextureSide;
-		},
-		resources: e.paintResources ?? f(e.gl),
-		bindRamp: (t, n, r) => {
-			let i = e.gradRamps.upload(t, r);
-			return e.gradRamps.bind(n), e.gradRamps.rowV(i);
-		}
-	};
-	return u.set(e, n), n;
-}
-var u = /* @__PURE__ */ new WeakMap(), d = /* @__PURE__ */ new WeakMap();
-function f(t) {
-	let n = d.get(t);
-	return n || (n = e(), d.set(t, n)), n;
-}
-function p(e, s, l, u) {
-	let d = l.pattern, f = t(d.id);
-	if (!f) return (typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel: pattern TextureHandle "${d.id}" not registered`), null;
-	let p = o(e, l.units);
-	if (!p) return null;
-	let h = c(p, l.origin ?? {
-		x: 0,
-		y: 0
-	}, l.transform);
-	if (!h) return null;
-	e.textureCache.uploadRegistered(d.id, f.source, "repeat");
-	let g = e.gl;
-	g.useProgram(s.handle), a(e, s, u), i(e, s), g.uniformMatrix3fv(s.uniform("u_worldInv"), !1, n.toUniform(h));
-	let [_, v] = m(f.source);
-	return g.uniform2f(s.uniform("u_tileSize"), _, v), e.textureCache.bind(d.id, 0), g.uniform1i(s.uniform("u_sampler"), 0), g.uniform1f(s.uniform("u_opacity"), l.opacity ?? 1), r(e, s, e.state.alpha), s;
-}
-function m(e) {
-	let t = "naturalWidth" in e ? e.naturalWidth : e.width, n = "naturalHeight" in e ? e.naturalHeight : e.height;
-	return [t || 1, n || 1];
-}
-function h(e, t, s, c) {
-	let l = o(e, s.units);
-	if (!l) return null;
-	let u = e.gl, d = e.gradRamps.upload(s.stops, s.interpolate ?? "rgb");
-	if (u.useProgram(t.handle), a(e, t, c), u.uniformMatrix3fv(t.uniform("u_worldInv"), !1, n.toUniform(l)), i(e, t), e.gradRamps.bind(0), u.uniform1i(t.uniform("u_ramp"), 0), u.uniform1f(t.uniform("u_rampV"), e.gradRamps.rowV(d)), r(e, t, e.state.alpha), u.uniform1f(t.uniform("u_opacity"), s.opacity ?? 1), s.fill === "linear-gradient") {
-		u.uniform1i(t.uniform("u_gradKind"), 0);
-		let e = s.to.x - s.from.x, n = s.to.y - s.from.y, r = Math.hypot(e, n) || 1;
-		u.uniform2f(t.uniform("u_gradP0"), s.from.x, s.from.y), u.uniform2f(t.uniform("u_gradDir"), e / r, n / r), u.uniform1f(t.uniform("u_gradLen"), r), u.uniform1f(t.uniform("u_gradRadius"), 0), u.uniform1f(t.uniform("u_gradAngle"), 0);
-	} else s.fill === "radial-gradient" ? (u.uniform1i(t.uniform("u_gradKind"), 1), u.uniform2f(t.uniform("u_gradP0"), s.center.x, s.center.y), u.uniform2f(t.uniform("u_gradDir"), 0, 0), u.uniform1f(t.uniform("u_gradLen"), 0), u.uniform1f(t.uniform("u_gradRadius"), s.radius), u.uniform1f(t.uniform("u_gradAngle"), 0)) : (u.uniform1i(t.uniform("u_gradKind"), 2), u.uniform2f(t.uniform("u_gradP0"), s.center.x, s.center.y), u.uniform2f(t.uniform("u_gradDir"), 0, 0), u.uniform1f(t.uniform("u_gradLen"), 0), u.uniform1f(t.uniform("u_gradRadius"), 0), u.uniform1f(t.uniform("u_gradAngle"), s.angle));
-	return t;
-}
-//#endregion
-export { h as bindGradient, p as bindPattern, l as paintBindContext };
-
-//# sourceMappingURL=paintBind.js.map

package/dist/renderer/draw/paintBind.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paintBind.js","names":["paintBindContext","cached","BIND_CONTEXTS","ctx","made","id","setProjAndModel","prog","gradientSpaceInverse","units","spaceToDevice","unownedPaintResources","row","stops","space","unit","UNOWNED_RESOURCES","gl","createPaintResources","bindPattern","tex","fill","entry","getTexture","inverse","tileSpace","patternTileSpace","model","setColorMatrixUniforms","mat3","tw","th","textureSize","setAlphaUniform","w","source","h","bindGradient","dx","dy","len"],"sources":["../../../src/renderer/draw/paintBind.ts"],"sourcesContent":["import type { FillStyle } from '@weasel-js/paint';\nimport type { PaintBindContext, PaintResources } from 'core/paintKinds';\nimport { createPaintResources } from '../paintResources';\nimport { getTexture, type TextureHandle } from '../textures/registerTexture';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport { mat3, type GlMat3 } from '../math/mat3';\nimport { patternTileSpace } from '../math/patternSpace';\nimport type { DrawContext } from './drawContext';\nimport { setAlphaUniform, setColorMatrixUniforms, setProjAndModel } from './uniforms';\nimport { gradientSpaceInverse, spaceToDevice } from './gradient';\n\n/** The narrow renderer surface a registered paint kind binds against, built\n *  once per frame context. `DrawContext` is not consumer surface. */\nexport function paintBindContext(ctx: DrawContext): PaintBindContext {\n  const cached = BIND_CONTEXTS.get(ctx);\n  if (cached) return cached;\n  const made: PaintBindContext = {\n    gl: ctx.gl,\n    get alpha() { return ctx.state.alpha; },\n    program: (id) => ctx.ensureProgram?.(id) ?? ctx.programRegistry.get(id) ?? null,\n    setProjAndModel: (prog) => setProjAndModel(ctx, prog),\n    spaceInverse: (units) => gradientSpaceInverse(ctx, units),\n    spaceToDevice: (units) => spaceToDevice(ctx, units),\n    get maxTextureSize() { return ctx.imageCache.maxTextureSide; },\n    resources: ctx.paintResources ?? unownedPaintResources(ctx.gl),\n    bindRamp: (stops, unit, space) => {\n      const row = ctx.gradRamps.upload(stops, space);\n      ctx.gradRamps.bind(unit);\n      return ctx.gradRamps.rowV(row);\n    },\n  };\n  BIND_CONTEXTS.set(ctx, made);\n  return made;\n}\n\nconst BIND_CONTEXTS = new WeakMap<DrawContext, PaintBindContext>();\n\nconst UNOWNED_RESOURCES = new WeakMap<WebGL2RenderingContext, PaintResources>();\n\nfunction unownedPaintResources(gl: WebGL2RenderingContext): PaintResources {\n  let made = UNOWNED_RESOURCES.get(gl);\n  if (!made) {\n    made = createPaintResources();\n    UNOWNED_RESOURCES.set(gl, made);\n  }\n  return made;\n}\n\n/** Bind `prog` — the path program or the glyph one, which share every paint\n *  uniform — to draw `fill` under `model`. */\nexport function bindPattern(\n  ctx: DrawContext,\n  prog: ShaderProgram,\n  fill: Extract<FillStyle, { fill: 'pattern' }>,\n  model: GlMat3,\n): ShaderProgram | null {\n  const tex = fill.pattern as TextureHandle;\n  const entry = getTexture(tex.id);\n  if (!entry) {\n    const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n    if (isDev) console.warn(`weasel: pattern TextureHandle \"${tex.id}\" not registered`);\n    return null;\n  }\n  const inverse = gradientSpaceInverse(ctx, fill.units);\n  if (!inverse) return null;\n  const tileSpace = patternTileSpace(inverse, fill.origin ?? { x: 0, y: 0 }, fill.transform);\n  if (!tileSpace) return null;\n  ctx.textureCache.uploadRegistered(tex.id, entry.source, 'repeat');\n\n  // A path fill mesh carries a_position only, so the tile coordinate is\n  // recovered per fragment from the screen position — the same route\n  // gradients take through `u_worldInv`, and the reason this can't reuse\n  // the image-fill shader, whose a_uv such a mesh leaves unbound.\n  const gl = ctx.gl;\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog, model);\n  setColorMatrixUniforms(ctx, prog);\n  gl.uniformMatrix3fv(prog.uniform('u_worldInv')!, false, mat3.toUniform(tileSpace));\n  const [tw, th] = textureSize(entry.source);\n  gl.uniform2f(prog.uniform('u_tileSize')!, tw, th);\n  ctx.textureCache.bind(tex.id, 0);\n  gl.uniform1i(prog.uniform('u_sampler')!, 0);\n  gl.uniform1f(prog.uniform('u_opacity')!, fill.opacity ?? 1);\n  setAlphaUniform(ctx, prog, ctx.state.alpha);\n  return prog;\n}\n\n/** Tile extent in paint-space units — one tile spans this many units of\n *  whatever space `units` names. */\nfunction textureSize(source: HTMLImageElement | ImageBitmap): [number, number] {\n  const w = 'naturalWidth' in source ? source.naturalWidth : source.width;\n  const h = 'naturalHeight' in source ? source.naturalHeight : source.height;\n  return [w || 1, h || 1];\n}\n\n/** The gradient counterpart of `bindPattern`. */\nexport function bindGradient(\n  ctx: DrawContext,\n  prog: ShaderProgram,\n  fill: Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>,\n  model: GlMat3,\n): ShaderProgram | null {\n  const inverse = gradientSpaceInverse(ctx, fill.units);\n  if (!inverse) return null;\n  const gl = ctx.gl;\n  const row = ctx.gradRamps.upload(fill.stops, fill.interpolate ?? 'rgb');\n\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog, model);\n\n  gl.uniformMatrix3fv(prog.uniform('u_worldInv')!, false, mat3.toUniform(inverse));\n  setColorMatrixUniforms(ctx, prog);\n\n  ctx.gradRamps.bind(0);\n  gl.uniform1i(prog.uniform('u_ramp')!, 0);\n  gl.uniform1f(prog.uniform('u_rampV')!, ctx.gradRamps.rowV(row));\n  setAlphaUniform(ctx, prog, ctx.state.alpha);\n  gl.uniform1f(prog.uniform('u_opacity')!, fill.opacity ?? 1);\n\n  if (fill.fill === 'linear-gradient') {\n    gl.uniform1i(prog.uniform('u_gradKind')!, 0);\n    const dx = fill.to.x - fill.from.x;\n    const dy = fill.to.y - fill.from.y;\n    const len = Math.hypot(dx, dy) || 1;\n    gl.uniform2f(prog.uniform('u_gradP0')!, fill.from.x, fill.from.y);\n    gl.uniform2f(prog.uniform('u_gradDir')!, dx / len, dy / len);\n    gl.uniform1f(prog.uniform('u_gradLen')!, len);\n    gl.uniform1f(prog.uniform('u_gradRadius')!, 0);\n    gl.uniform1f(prog.uniform('u_gradAngle')!, 0);\n  } else if (fill.fill === 'radial-gradient') {\n    gl.uniform1i(prog.uniform('u_gradKind')!, 1);\n    gl.uniform2f(prog.uniform('u_gradP0')!, fill.center.x, fill.center.y);\n    gl.uniform2f(prog.uniform('u_gradDir')!, 0, 0);\n    gl.uniform1f(prog.uniform('u_gradLen')!, 0);\n    gl.uniform1f(prog.uniform('u_gradRadius')!, fill.radius);\n    gl.uniform1f(prog.uniform('u_gradAngle')!, 0);\n  } else {\n    // conic\n    gl.uniform1i(prog.uniform('u_gradKind')!, 2);\n    gl.uniform2f(prog.uniform('u_gradP0')!, fill.center.x, fill.center.y);\n    gl.uniform2f(prog.uniform('u_gradDir')!, 0, 0);\n    gl.uniform1f(prog.uniform('u_gradLen')!, 0);\n    gl.uniform1f(prog.uniform('u_gradRadius')!, 0);\n    gl.uniform1f(prog.uniform('u_gradAngle')!, fill.angle);\n  }\n\n  return prog;\n}\n"],"mappings":";;;;;;;AAaA,SAAgBA,EAAiB,GAAoC;CACnE,IAAMC,IAASC,EAAc,IAAIC,CAAG;CACpC,IAAIF,GAAQ,OAAOA;CACnB,IAAMG,IAAyB;EAC7B,IAAID,EAAI;EACR,IAAI,QAAQ;GAAE,OAAOA,EAAI,MAAM;EAAO;EACtC,UAAU,MAAOA,EAAI,gBAAgBE,CAAE,KAAKF,EAAI,gBAAgB,IAAIE,CAAE,KAAK;EAC3E,kBAAkB,MAASC,EAAgBH,GAAKI,CAAI;EACpD,eAAe,MAAUC,EAAqBL,GAAKM,CAAK;EACxD,gBAAgB,MAAUC,EAAcP,GAAKM,CAAK;EAClD,IAAI,iBAAiB;GAAE,OAAON,EAAI,WAAW;EAAgB;EAC7D,WAAWA,EAAI,kBAAkBQ,EAAsBR,EAAI,EAAE;EAC7D,WAAW,GAAO,GAAM,MAAU;GAChC,IAAMS,IAAMT,EAAI,UAAU,OAAOU,GAAOC,CAAK;GAE7C,OADAX,EAAI,UAAU,KAAKY,CAAI,GAChBZ,EAAI,UAAU,KAAKS,CAAG;EAC/B;CACF;CAEA,OADAV,EAAc,IAAIC,GAAKC,CAAI,GACpBA;AACT;AAEA,IAAMF,oBAAgB,IAAI,QAAuC,GAE3Dc,oBAAoB,IAAI,QAAgD;AAE9E,SAASL,EAAsB,GAA4C;CACzE,IAAIP,IAAOY,EAAkB,IAAIC,CAAE;CAKnC,OAJKb,MACH,IAAOc,EAAqB,GAC5BF,EAAkB,IAAIC,GAAIb,CAAI,IAEzBA;AACT;AAIA,SAAgBe,EACd,GACA,GACA,GACA,GACsB;CACtB,IAAMC,IAAMC,EAAK,SACXC,IAAQC,EAAWH,EAAI,EAAE;CAC/B,IAAI,CAACE,GAGH,QAFc,OAAO,UAAY,OAAA,QAAA,IAAA,aAAuC,iBAC7D,QAAQ,KAAK,kCAAkCF,EAAI,GAAG,iBAAiB,GAC3E;CAET,IAAMI,IAAUhB,EAAqBL,GAAKkB,EAAK,KAAK;CACpD,IAAI,CAACG,GAAS,OAAO;CACrB,IAAMC,IAAYC,EAAiBF,GAASH,EAAK,UAAU;EAAE,GAAG;EAAG,GAAG;CAAE,GAAGA,EAAK,SAAS;CACzF,IAAI,CAACI,GAAW,OAAO;CACvB,EAAI,aAAa,iBAAiBL,EAAI,IAAIE,EAAM,QAAQ,QAAQ;CAMhE,IAAML,IAAKd,EAAI;CAIf,AAHAc,EAAG,WAAWV,EAAK,MAAM,GACzBD,EAAgBH,GAAKI,GAAMoB,CAAK,GAChCC,EAAuBzB,GAAKI,CAAI,GAChCU,EAAG,iBAAiBV,EAAK,QAAQ,YAAY,GAAI,IAAOsB,EAAK,UAAUJ,CAAS,CAAC;CACjF,IAAM,CAACK,GAAIC,KAAMC,EAAYV,EAAM,MAAM;CAMzC,OALAL,EAAG,UAAUV,EAAK,QAAQ,YAAY,GAAIuB,GAAIC,CAAE,GAChD5B,EAAI,aAAa,KAAKiB,EAAI,IAAI,CAAC,GAC/BH,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAI,CAAC,GAC1CU,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAIc,EAAK,WAAW,CAAC,GAC1DY,EAAgB9B,GAAKI,GAAMJ,EAAI,MAAM,KAAK,GACnCI;AACT;AAIA,SAASyB,EAAY,GAA0D;CAC7E,IAAME,IAAI,kBAAkBC,IAASA,EAAO,eAAeA,EAAO,OAC5DC,IAAI,mBAAmBD,IAASA,EAAO,gBAAgBA,EAAO;CACpE,OAAO,CAACD,KAAK,GAAGE,KAAK,CAAC;AACxB;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACsB;CACtB,IAAMb,IAAUhB,EAAqBL,GAAKkB,EAAK,KAAK;CACpD,IAAI,CAACG,GAAS,OAAO;CACrB,IAAMP,IAAKd,EAAI,IACTS,IAAMT,EAAI,UAAU,OAAOkB,EAAK,OAAOA,EAAK,eAAe,KAAK;CActE,IAZAJ,EAAG,WAAWV,EAAK,MAAM,GACzBD,EAAgBH,GAAKI,GAAMoB,CAAK,GAEhCV,EAAG,iBAAiBV,EAAK,QAAQ,YAAY,GAAI,IAAOsB,EAAK,UAAUL,CAAO,CAAC,GAC/EI,EAAuBzB,GAAKI,CAAI,GAEhCJ,EAAI,UAAU,KAAK,CAAC,GACpBc,EAAG,UAAUV,EAAK,QAAQ,QAAQ,GAAI,CAAC,GACvCU,EAAG,UAAUV,EAAK,QAAQ,SAAS,GAAIJ,EAAI,UAAU,KAAKS,CAAG,CAAC,GAC9DqB,EAAgB9B,GAAKI,GAAMJ,EAAI,MAAM,KAAK,GAC1Cc,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAIc,EAAK,WAAW,CAAC,GAEtDA,EAAK,SAAS,mBAAmB;EACnC,EAAG,UAAUd,EAAK,QAAQ,YAAY,GAAI,CAAC;EAC3C,IAAM+B,IAAKjB,EAAK,GAAG,IAAIA,EAAK,KAAK,GAC3BkB,IAAKlB,EAAK,GAAG,IAAIA,EAAK,KAAK,GAC3BmB,IAAM,KAAK,MAAMF,GAAIC,CAAE,KAAK;EAKlC,AAJAtB,EAAG,UAAUV,EAAK,QAAQ,UAAU,GAAIc,EAAK,KAAK,GAAGA,EAAK,KAAK,CAAC,GAChEJ,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAI+B,IAAKE,GAAKD,IAAKC,CAAG,GAC3DvB,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAIiC,CAAG,GAC5CvB,EAAG,UAAUV,EAAK,QAAQ,cAAc,GAAI,CAAC,GAC7CU,EAAG,UAAUV,EAAK,QAAQ,aAAa,GAAI,CAAC;CAC9C,OAAO,AAAIc,EAAK,SAAS,qBACvBJ,EAAG,UAAUV,EAAK,QAAQ,YAAY,GAAI,CAAC,GAC3CU,EAAG,UAAUV,EAAK,QAAQ,UAAU,GAAIc,EAAK,OAAO,GAAGA,EAAK,OAAO,CAAC,GACpEJ,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAI,GAAG,CAAC,GAC7CU,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAI,CAAC,GAC1CU,EAAG,UAAUV,EAAK,QAAQ,cAAc,GAAIc,EAAK,MAAM,GACvDJ,EAAG,UAAUV,EAAK,QAAQ,aAAa,GAAI,CAAC,MAG5CU,EAAG,UAAUV,EAAK,QAAQ,YAAY,GAAI,CAAC,GAC3CU,EAAG,UAAUV,EAAK,QAAQ,UAAU,GAAIc,EAAK,OAAO,GAAGA,EAAK,OAAO,CAAC,GACpEJ,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAI,GAAG,CAAC,GAC7CU,EAAG,UAAUV,EAAK,QAAQ,WAAW,GAAI,CAAC,GAC1CU,EAAG,UAAUV,EAAK,QAAQ,cAAc,GAAI,CAAC,GAC7CU,EAAG,UAAUV,EAAK,QAAQ,aAAa,GAAIc,EAAK,KAAK;CAGvD,OAAOd;AACT"}

package/dist/renderer/draw/pathPaint.js

@@ -1,142 +0,0 @@
-import { drawTriangles as e } from "./drawTriangles.js";
-import { ancestorMask as t, applyClipTest as n, beginParityMask as r, endParityMask as i } from "./stencil.js";
-import { setColorMatrixUniforms as a, setProjAndModel as o, setSolidPaintUniforms as s } from "./uniforms.js";
-import { fillMesh as c, fillMeshHandle as l, meshHandle as u } from "./mesh.js";
-import { flushForOwnDraw as d } from "./clip.js";
-import { getPaintKind as f } from "../../core/paintKinds.js";
-import { metricKeepsRects as p } from "../../features/paths/tessellate/metric.js";
-import { resolveStrokeWidth as m } from "../../features/paths/tessellate/stroke.js";
-import { strokeMesh as h } from "../cache/strokeMeshCache.js";
-import { resolveStrokeLengths as g } from "../strokeLengths.js";
-import { cachedMarkerCommands as _ } from "../cache/markerCommandCache.js";
-import { batchPaint as v } from "./gradient.js";
-import { pushRampRect as y, pushRect as b, tryStageFill as x } from "./batch.js";
-import { bindGradient as S, bindPattern as C, paintBindContext as w } from "./paintBind.js";
-//#region src/renderer/draw/pathPaint.ts
-function T(e, t) {
-	t.fill && E(e, t), t.stroke?.paint && L(e, t);
-}
-function E(e, t) {
-	let n = t.fill, r = n.fill === void 0 || n.fill === "solid", i = !!(t.vertexColors && t.vertexColors.length > 0), a = n, o = v(e, n, i);
-	if (o === null) return;
-	if (o !== void 0 && t.path.kind === "rect") {
-		o.kind === "ramp" ? y(e, t.path, o) : b(e, t.path, o);
-		return;
-	}
-	let s = c(e, t.path);
-	if (x(e, s, o)) return;
-	let l = u(e, s);
-	r && i ? A(e, t, a, l) : l.requiresStencil ? I(e, n, l) : M(e, n, l);
-}
-function D(e, t, n, r) {
-	let i = e.createBuffer();
-	if (!i) throw Error("attachVertexColors: createBuffer returned null");
-	e.bindBuffer(e.ARRAY_BUFFER, i), e.bufferData(e.ARRAY_BUFFER, k(n, r), e.DYNAMIC_DRAW);
-	let a = t.attribute("a_vertexColor");
-	return a !== void 0 && (e.enableVertexAttribArray(a), e.vertexAttribPointer(a, 4, e.FLOAT, !1, 0, 0)), {
-		vbo: i,
-		location: a
-	};
-}
-function O(e, { vbo: t, location: n }) {
-	n !== void 0 && e.disableVertexAttribArray(n), e.deleteBuffer(t);
-}
-function k(e, t) {
-	let n = t.anchorA, r = t.anchorB, i = t.anchorT;
-	if (!n || !r || !i) return new Float32Array(e);
-	let a = n.length, o = new Float32Array(a * 4);
-	for (let t = 0; t < a; t++) {
-		let a = n[t] * 4, s = r[t] * 4, c = i[t];
-		o[t * 4 + 0] = e[a + 0] + (e[s + 0] - e[a + 0]) * c, o[t * 4 + 1] = e[a + 1] + (e[s + 1] - e[a + 1]) * c, o[t * 4 + 2] = e[a + 2] + (e[s + 2] - e[a + 2]) * c, o[t * 4 + 3] = e[a + 3] + (e[s + 3] - e[a + 3]) * c;
-	}
-	return o;
-}
-function A(t, c, l, u) {
-	let d = t.gl, f = t.pathFillVColor;
-	d.useProgram(f.handle), d.bindVertexArray(u.vao), o(t, f), s(t, f, l.color, l.opacity), a(t, f);
-	let p = D(d, f, c.vertexColors, u);
-	u.requiresStencil ? (r(t, u.indexCount), e(t, u.indexCount, t.gl.UNSIGNED_INT), i(t)) : (n(t), e(t, u.indexCount, t.gl.UNSIGNED_INT)), O(d, p), d.bindVertexArray(null);
-}
-function j(e, t) {
-	let n = t.fill ?? "solid";
-	if (n === "solid") return N(e, t);
-	if (n === "pattern") return P(e, t);
-	if (n === "linear-gradient" || n === "radial-gradient" || n === "conic-gradient") return F(e, t);
-	let r = f(n)?.bind;
-	return r ? r(w(e), t) : null;
-}
-function M(t, r, i) {
-	if (!j(t, r)) return;
-	let a = t.gl;
-	a.bindVertexArray(i.vao), n(t), e(t, i.indexCount, t.gl.UNSIGNED_INT), a.bindVertexArray(null);
-}
-function N(e, t) {
-	let n = e.pathFill;
-	return e.gl.useProgram(n.handle), o(e, n), s(e, n, t.color, t.opacity), a(e, n), n;
-}
-function P(e, t) {
-	return C(e, e.patternFill, t, e.state.transform);
-}
-function F(e, t) {
-	return S(e, e.gradFill, t, e.state.transform);
-}
-function I(t, n, a) {
-	let s = t.gl;
-	s.useProgram(t.pathFill.handle), s.bindVertexArray(a.vao), o(t, t.pathFill), r(t, a.indexCount), j(t, n) && e(t, a.indexCount, t.gl.UNSIGNED_INT), i(t), s.bindVertexArray(null);
-}
-function L(e, t) {
-	let { cmd: n, spaces: r } = g(e.state.transform, t), i = n.stroke, a = i.align ?? "center", o = r.ribbon?.metric;
-	(n.path.kind === "polygon" || o !== void 0 && !p(o)) && a !== "center" ? (d(e), V(e, n, a, r)) : R(e, n, r);
-	let s = m(i.width ?? 1, 1), c = _(n.path, t.stroke, i, s, e.flattenTolerance, r);
-	for (let t of c) T(e, t);
-}
-function R(t, r, i) {
-	let c = r.stroke, l = c.paint, u = l.fill === void 0 || l.fill === "solid", d = l, f = h(r.path, c, t.flattenTolerance, i);
-	if (f.indices.length === 0) return;
-	let p = !!(c.vertexColors && c.vertexColors.length > 0), m = v(t, l, p);
-	if (m === null || x(t, f, m)) return;
-	let g = p ? t.meshCache.uploadTransient(f) : t.meshCache.uploadRecurring(f);
-	if (!u && !p) {
-		M(t, l, g);
-		return;
-	}
-	let _ = t.gl;
-	if (p) {
-		let r = t.pathFillVColor;
-		_.useProgram(r.handle), _.bindVertexArray(g.vao), o(t, r), s(t, r, u ? d.color : "#ffffff", l.opacity), a(t, r);
-		let i = D(_, r, c.vertexColors, g);
-		n(t), e(t, g.indexCount, t.gl.UNSIGNED_INT), O(_, i), _.bindVertexArray(null);
-		return;
-	}
-	_.useProgram(t.pathFill.handle), _.bindVertexArray(g.vao), o(t, t.pathFill), s(t, t.pathFill, d.color, d.opacity), a(t, t.pathFill), n(t), e(t, g.indexCount, t.gl.UNSIGNED_INT), _.bindVertexArray(null);
-}
-var z = /* @__PURE__ */ new WeakMap();
-function B(e) {
-	let t = z.get(e);
-	return t === void 0 && (t = e.map((e) => e * 2), z.set(e, t)), t;
-}
-function V(n, r, i, c) {
-	let u = r.stroke, d = u.paint, f = d.fill === void 0 || d.fill === "solid", p = d, g = {
-		...u,
-		width: m(u.width ?? 1, 1) * 2,
-		...u.vertexWidths ? { vertexWidths: B(u.vertexWidths) } : {},
-		align: "center"
-	}, _ = !!(u.vertexColors && u.vertexColors.length > 0), v = l(n, r.path), y = h(r.path, g, n.flattenTolerance, c);
-	if (y.indices.length === 0) return;
-	let b = _ ? n.meshCache.uploadTransient(y) : n.meshCache.uploadRecurring(y), x = n.gl, S = _ ? n.pathFillVColor : n.pathFill;
-	x.useProgram(S.handle), o(n, S), x.enable(x.STENCIL_TEST), x.colorMask(!1, !1, !1, !1), x.stencilMask(1), x.stencilFunc(x.ALWAYS, 1, 1), x.stencilOp(x.KEEP, x.KEEP, v.requiresStencil ? x.INVERT : x.REPLACE), x.bindVertexArray(v.vao), e(n, v.indexCount, n.gl.UNSIGNED_INT);
-	let C = t(n.clipDepth);
-	x.colorMask(!0, !0, !0, !0), i === "inner" ? x.stencilFunc(x.EQUAL, C | 1, C | 1) : x.stencilFunc(x.EQUAL, C, C | 1), x.stencilOp(x.KEEP, x.KEEP, x.KEEP);
-	let w = S;
-	if (_ ? (s(n, S, f ? p.color : "#ffffff", d.opacity), a(n, S)) : w = j(n, d), !w) {
-		x.stencilMask(1), x.clear(x.STENCIL_BUFFER_BIT), x.disable(x.STENCIL_TEST), x.bindVertexArray(null);
-		return;
-	}
-	x.bindVertexArray(b.vao);
-	let T = _ ? D(x, w, u.vertexColors, b) : null;
-	e(n, b.indexCount, n.gl.UNSIGNED_INT), x.stencilMask(1), x.clear(x.STENCIL_BUFFER_BIT), x.disable(x.STENCIL_TEST), T && O(x, T), x.bindVertexArray(null);
-}
-//#endregion
-export { T as drawPath, M as drawPathFillByKind };
-
-//# sourceMappingURL=pathPaint.js.map

package/dist/renderer/draw/pathPaint.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pathPaint.js","names":["drawPath","cmd","drawPathFill","ctx","drawPathStroke","fill","isSolid","hasVColors","solid","paint","batchPaint","pushRampRect","pushRect","mesh","fillMesh","tryStageFill","handle","meshHandle","drawPathFillVColor","drawPathFillStencil","drawPathFillByKind","attachVertexColors","vbo","gl","expandAnchorColors","perAnchor","location","prog","detachVertexColors","aA","aB","aT","n","out","i","a4","b4","t","setProjAndModel","setSolidPaintUniforms","setColorMatrixUniforms","colors","beginParityMask","drawTriangles","endParityMask","applyClipTest","bindPathFillByKind","kind","bindPathFillSolid","bindPathFillPattern","bindPathFillGradient","bind","getPaintKind","paintBindContext","bindPattern","bindGradient","resolveStrokeLengths","rawCmd","stroke","align","metric","spaces","metricKeepsRects","flushForOwnDraw","drawPathStrokeStenciled","drawPathStrokeUnclipped","width","resolveStrokeWidth","heads","cachedMarkerCommands","marker","strokeMesh","batched","DOUBLED_VERTEX_WIDTHS","doubledVertexWidths","doubled","widths","w","widerStroke","useVColor","fillHandle","fillMeshHandle","ribbonMesh","ribbonHandle","clipMask","ancestorMask","ribbonProg"],"sources":["../../../src/renderer/draw/pathPaint.ts"],"sourcesContent":["import type { Stroke, FillStyle } from '@weasel-js/paint';\nimport { getPaintKind } from 'core/paintKinds';\nimport type { PathDrawCommand } from '../DrawCommand';\nimport type { GLMeshHandle } from '../cache/GLMeshCache';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { strokeMesh } from '../cache/strokeMeshCache';\nimport { resolveStrokeLengths, type StrokedPathCommand } from '../strokeLengths';\nimport { metricKeepsRects, type StrokeSpaces } from 'features/paths/tessellate/metric';\nimport { cachedMarkerCommands } from '../cache/markerCommandCache';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { fillMesh, meshHandle, fillMeshHandle } from './mesh';\nimport { setColorMatrixUniforms, setProjAndModel, setSolidPaintUniforms } from './uniforms';\nimport { applyClipTest, ancestorMask, beginParityMask, endParityMask } from './stencil';\nimport { flushForOwnDraw } from './clip';\nimport { pushRect, pushRampRect, tryStageFill } from './batch';\nimport { batchPaint } from './gradient';\nimport { paintBindContext, bindPattern, bindGradient } from './paintBind';\n\nexport function drawPath(ctx: DrawContext, cmd: PathDrawCommand): void {\n  if (cmd.fill) drawPathFill(ctx, cmd);\n  // A stroke with no `paint` paints nothing, the way a node's `fill: null`\n  // does. Commands arriving from a consumer painter or overlay can carry one.\n  if (cmd.stroke?.paint) drawPathStroke(ctx, cmd as StrokedPathCommand);\n}\n\nfunction drawPathFill(ctx: DrawContext, cmd: PathDrawCommand): void {\n  const fill = cmd.fill!;\n  // Batchable: see `batchPaint`. A rect skips tessellation entirely; anything\n  // else stages its mesh. Both also keep animated demos that mint a fresh Path\n  // every frame from allocating a GL buffer per frame.\n  const isSolid = fill.fill === undefined || fill.fill === 'solid';\n  const hasVColors = !!(cmd.vertexColors && cmd.vertexColors.length > 0);\n  const solid = fill as { color: string; opacity?: number };\n  const paint = batchPaint(ctx, fill, hasVColors);\n  if (paint === null) return;\n\n  if (paint !== undefined && cmd.path.kind === 'rect') {\n    if (paint.kind === 'ramp') pushRampRect(ctx, cmd.path, paint);\n    else pushRect(ctx, cmd.path, paint);\n    return;\n  }\n\n  const mesh = fillMesh(ctx, cmd.path);\n  if (tryStageFill(ctx, mesh, paint)) return;\n\n  const handle = meshHandle(ctx, mesh);\n  if (isSolid && hasVColors) {\n    drawPathFillVColor(ctx, cmd, solid, handle);\n  } else if (handle.requiresStencil) {\n    drawPathFillStencil(ctx, fill, handle);\n  } else {\n    drawPathFillByKind(ctx, fill, handle);\n  }\n}\n\ninterface VertexColorBinding { vbo: WebGLBuffer; location: number | undefined }\n\n/** Point the bound mesh VAO's a_vertexColor at a fresh buffer of per-vertex\n *  colors. Pair with `detachVertexColors` before the VAO is unbound. */\nfunction attachVertexColors(\n  gl: WebGL2RenderingContext, prog: ShaderProgram, perAnchor: number[], handle: GLMeshHandle,\n): VertexColorBinding {\n  const vbo = gl.createBuffer();\n  if (!vbo) throw new Error('attachVertexColors: createBuffer returned null');\n  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);\n  gl.bufferData(gl.ARRAY_BUFFER, expandAnchorColors(perAnchor, handle), gl.DYNAMIC_DRAW);\n  const location = prog.attribute('a_vertexColor');\n  if (location !== undefined) {\n    gl.enableVertexAttribArray(location);\n    gl.vertexAttribPointer(location, 4, gl.FLOAT, false, 0, 0);\n  }\n  return { vbo, location };\n}\n\n// Order matters: a buffer deleted after its VAO is unbound stays attached to\n// that VAO and is not freed until the mesh is, and one deleted while its\n// attribute is still enabled leaves the VAO unable to draw.\nfunction detachVertexColors(gl: WebGL2RenderingContext, { vbo, location }: VertexColorBinding): void {\n  if (location !== undefined) gl.disableVertexAttribArray(location);\n  gl.deleteBuffer(vbo);\n}\n\nfunction expandAnchorColors(perAnchor: number[], handle: GLMeshHandle): Float32Array {\n  const aA = handle.anchorA;\n  const aB = handle.anchorB;\n  const aT = handle.anchorT;\n  if (!aA || !aB || !aT) {\n    // Legacy fallback: mesh lacks anchor params (e.g. non-path mesh). Treat\n    // the caller-provided array as already per-vertex.\n    return new Float32Array(perAnchor);\n  }\n  const n = aA.length;\n  const out = new Float32Array(n * 4);\n  for (let i = 0; i < n; i++) {\n    const a4 = aA[i] * 4;\n    const b4 = aB[i] * 4;\n    const t = aT[i];\n    out[i * 4 + 0] = perAnchor[a4 + 0] + (perAnchor[b4 + 0] - perAnchor[a4 + 0]) * t;\n    out[i * 4 + 1] = perAnchor[a4 + 1] + (perAnchor[b4 + 1] - perAnchor[a4 + 1]) * t;\n    out[i * 4 + 2] = perAnchor[a4 + 2] + (perAnchor[b4 + 2] - perAnchor[a4 + 2]) * t;\n    out[i * 4 + 3] = perAnchor[a4 + 3] + (perAnchor[b4 + 3] - perAnchor[a4 + 3]) * t;\n  }\n  return out;\n}\n\nfunction drawPathFillVColor(\n  ctx: DrawContext,\n  cmd: PathDrawCommand,\n  fill: { color: string; opacity?: number },\n  handle: GLMeshHandle,\n): void {\n  const gl = ctx.gl;\n  const prog = ctx.pathFillVColor;\n  gl.useProgram(prog.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, prog);\n  setSolidPaintUniforms(ctx, prog, fill.color, fill.opacity);\n  setColorMatrixUniforms(ctx, prog);\n\n  const colors = attachVertexColors(gl, prog, cmd.vertexColors!, handle);\n\n  if (handle.requiresStencil) {\n    beginParityMask(ctx, handle.indexCount);\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n    endParityMask(ctx);\n  } else {\n    applyClipTest(ctx);\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  }\n  detachVertexColors(gl, colors);\n  gl.bindVertexArray(null);\n}\n\n/**\n * Bind the program, uniforms and textures for `fill`, and return the program.\n *\n * Split from the draw so a caller owning its own stencil state can paint\n * without `applyClipTest` clobbering it — `drawPathStrokeStenciled` clips a\n * doubled ribbon to one side of the silhouette, and `applyClipTest` at depth 0\n * disables the stencil test outright.\n */\nfunction bindPathFillByKind(ctx: DrawContext, fill: FillStyle): ShaderProgram | null {\n  const kind = fill.fill ?? 'solid';\n  if (kind === 'solid') return bindPathFillSolid(ctx, fill as { color: string; opacity?: number });\n  if (kind === 'pattern') return bindPathFillPattern(ctx, fill as Extract<FillStyle, { fill: 'pattern' }>);\n  if (kind === 'linear-gradient' || kind === 'radial-gradient' || kind === 'conic-gradient') {\n    return bindPathFillGradient(ctx, fill as Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>);\n  }\n  const bind = getPaintKind(kind)?.bind;\n  return bind ? bind(paintBindContext(ctx), fill) : null;\n}\n\nexport function drawPathFillByKind(ctx: DrawContext, fill: FillStyle, handle: GLMeshHandle): void {\n  const prog = bindPathFillByKind(ctx, fill);\n  if (!prog) return;\n  const gl = ctx.gl;\n  gl.bindVertexArray(handle.vao);\n  applyClipTest(ctx);\n  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  gl.bindVertexArray(null);\n}\n\nfunction bindPathFillSolid(\n  ctx: DrawContext,\n  fill: { color: string; opacity?: number },\n): ShaderProgram {\n  const prog = ctx.pathFill;\n  ctx.gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog);\n  setSolidPaintUniforms(ctx, prog, fill.color, fill.opacity);\n  setColorMatrixUniforms(ctx, prog);\n  return prog;\n}\n\nfunction bindPathFillPattern(\n  ctx: DrawContext,\n  fill: Extract<FillStyle, { fill: 'pattern' }>,\n): ShaderProgram | null {\n  return bindPattern(ctx, ctx.patternFill, fill, ctx.state.transform);\n}\n\nfunction bindPathFillGradient(\n  ctx: DrawContext,\n  fill: Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>,\n): ShaderProgram | null {\n  return bindGradient(ctx, ctx.gradFill, fill, ctx.state.transform);\n}\n\nfunction drawPathFillStencil(ctx: DrawContext, fill: FillStyle, handle: GLMeshHandle): void {\n  const gl = ctx.gl;\n  gl.useProgram(ctx.pathFill.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, ctx.pathFill);\n\n  beginParityMask(ctx, handle.indexCount);\n  // The paint binds here, not above: pass 1 runs under a false colorMask, so a\n  // uniform missed here renders black while the GL-recorder tests still pass.\n  // Not `drawPathFillByKind` — its `applyClipTest` would disable this stencil.\n  if (bindPathFillByKind(ctx, fill)) {\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  }\n\n  endParityMask(ctx);\n  gl.bindVertexArray(null);\n}\n\nfunction drawPathStroke(ctx: DrawContext, rawCmd: StrokedPathCommand): void {\n  const { cmd, spaces } = resolveStrokeLengths(ctx.state.transform, rawCmd);\n  const stroke = cmd.stroke;\n  const align = stroke.align ?? 'center';\n  const metric = spaces.ribbon?.metric;\n  // A rect the metric turns is no longer a rect in the space its ribbon is\n  // built in, so it aligns through the stencil like any polygon.\n  const stenciled = cmd.path.kind === 'polygon' || (metric !== undefined && !metricKeepsRects(metric));\n  if (stenciled && align !== 'center') {\n    flushForOwnDraw(ctx);\n    drawPathStrokeStenciled(ctx, cmd, align, spaces);\n  } else {\n    drawPathStrokeUnclipped(ctx, cmd, spaces);\n  }\n  // After the ribbon, so a head sits on top of the line it caps.\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const heads = cachedMarkerCommands(cmd.path, rawCmd.stroke, stroke, width, ctx.flattenTolerance, spaces);\n  for (const marker of heads) drawPath(ctx, marker);\n}\n\nfunction drawPathStrokeUnclipped(ctx: DrawContext, cmd: StrokedPathCommand, spaces: StrokeSpaces): void {\n  const stroke = cmd.stroke;\n  const paint = stroke.paint;\n  const isSolid = paint.fill === undefined || paint.fill === 'solid';\n  const solid = paint as { color: string; opacity?: number };\n  const mesh = strokeMesh(cmd.path, stroke, ctx.flattenTolerance, spaces);\n  if (mesh.indices.length === 0) return;\n\n  // Staged, a ribbon allocates nothing and joins the fill it sits on.\n  const hasVColors = !!(stroke.vertexColors && stroke.vertexColors.length > 0);\n  const batched = batchPaint(ctx, paint, hasVColors);\n  if (batched === null) return;\n  if (tryStageFill(ctx, mesh, batched)) return;\n\n  // The VAO records the per-draw color attribute, so a vertex-colored draw\n  // cannot share a persistent one with a draw that has no vertex colors.\n  const handle = hasVColors\n    ? ctx.meshCache.uploadTransient(mesh)\n    : ctx.meshCache.uploadRecurring(mesh);\n\n  if (!isSolid && !hasVColors) {\n    drawPathFillByKind(ctx, paint, handle);\n    return;\n  }\n\n  const gl = ctx.gl;\n  if (hasVColors) {\n    const prog = ctx.pathFillVColor;\n    gl.useProgram(prog.handle);\n    gl.bindVertexArray(handle.vao);\n    setProjAndModel(ctx, prog);\n    // Per-vertex colors are the paint here; a non-solid base has no single\n    // color to multiply by, so white leaves the vertex colors unmodified.\n    setSolidPaintUniforms(ctx, prog, isSolid ? solid.color : '#ffffff', paint.opacity);\n    setColorMatrixUniforms(ctx, prog);\n\n    const colors = attachVertexColors(gl, prog, stroke.vertexColors!, handle);\n    applyClipTest(ctx);\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n    detachVertexColors(gl, colors);\n    gl.bindVertexArray(null);\n    return;\n  }\n\n  gl.useProgram(ctx.pathFill.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, ctx.pathFill);\n  setSolidPaintUniforms(ctx, ctx.pathFill, solid.color, solid.opacity);\n  setColorMatrixUniforms(ctx, ctx.pathFill);\n  applyClipTest(ctx);\n  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  gl.bindVertexArray(null);\n}\n\n/** The ribbon cache compares `vertexWidths` by reference, so the doubled copy\n *  has to be the same array on every frame the source array is. */\nconst DOUBLED_VERTEX_WIDTHS = new WeakMap<number[], number[]>();\n\nfunction doubledVertexWidths(widths: number[]): number[] {\n  let doubled = DOUBLED_VERTEX_WIDTHS.get(widths);\n  if (doubled === undefined) {\n    doubled = widths.map((w) => w * 2);\n    DOUBLED_VERTEX_WIDTHS.set(widths, doubled);\n  }\n  return doubled;\n}\n\nfunction drawPathStrokeStenciled(\n  ctx: DrawContext,\n  cmd: StrokedPathCommand,\n  align: 'inner' | 'outer',\n  spaces: StrokeSpaces,\n): void {\n  const stroke = cmd.stroke;\n  const paint = stroke.paint;\n  const isSolid = paint.fill === undefined || paint.fill === 'solid';\n  const solid = paint as { color: string; opacity?: number };\n  const widerStroke: Stroke = {\n    ...stroke,\n    width: resolveStrokeWidth(stroke.width ?? 1, 1) * 2,\n    ...(stroke.vertexWidths ? { vertexWidths: doubledVertexWidths(stroke.vertexWidths) } : {}),\n    align: 'center',\n  };\n\n  const useVColor = !!(stroke.vertexColors && stroke.vertexColors.length > 0);\n\n  const fillHandle = fillMeshHandle(ctx, cmd.path);\n  const ribbonMesh = strokeMesh(cmd.path, widerStroke, ctx.flattenTolerance, spaces);\n  if (ribbonMesh.indices.length === 0) return;\n  // The VAO records the per-draw color attribute, so a vertex-colored draw\n  // cannot share a persistent one with a draw that has no vertex colors.\n  const ribbonHandle = useVColor\n    ? ctx.meshCache.uploadTransient(ribbonMesh)\n    : ctx.meshCache.uploadRecurring(ribbonMesh);\n\n  const gl = ctx.gl;\n  const prog = useVColor ? ctx.pathFillVColor : ctx.pathFill;\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog);\n\n  gl.enable(gl.STENCIL_TEST);\n  gl.colorMask(false, false, false, false);\n  gl.stencilMask(0x01);\n  gl.stencilFunc(gl.ALWAYS, 1, 0x01);\n  // An even-odd fill is one fan per contour, and only parity cuts its holes.\n  gl.stencilOp(gl.KEEP, gl.KEEP, fillHandle.requiresStencil ? gl.INVERT : gl.REPLACE);\n  gl.bindVertexArray(fillHandle.vao);\n  drawTriangles(ctx, fillHandle.indexCount, ctx.gl.UNSIGNED_INT);\n\n  const clipMask = ancestorMask(ctx.clipDepth);\n  gl.colorMask(true, true, true, true);\n  if (align === 'inner') {\n    gl.stencilFunc(gl.EQUAL, clipMask | 0x01, clipMask | 0x01);\n  } else {\n    gl.stencilFunc(gl.EQUAL, clipMask, clipMask | 0x01);\n  }\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);\n  // Bind the paint here rather than through `drawPathFillByKind`: that calls\n  // `applyClipTest`, which at clip depth 0 disables the stencil test this\n  // function just set up to clip the ribbon to one side.\n  let ribbonProg: ShaderProgram | null = prog;\n  if (useVColor) {\n    // Per-vertex colors are the paint here; a non-solid base has no single\n    // color to multiply by, so white leaves the vertex colors unmodified.\n    setSolidPaintUniforms(ctx, prog, isSolid ? solid.color : '#ffffff', paint.opacity);\n    setColorMatrixUniforms(ctx, prog);\n  } else {\n    ribbonProg = bindPathFillByKind(ctx, paint);\n  }\n  if (!ribbonProg) {\n    gl.stencilMask(0x01);\n    gl.clear(gl.STENCIL_BUFFER_BIT);\n    gl.disable(gl.STENCIL_TEST);\n    gl.bindVertexArray(null);\n    return;\n  }\n  gl.bindVertexArray(ribbonHandle.vao);\n\n  const colors = useVColor\n    ? attachVertexColors(gl, ribbonProg, stroke.vertexColors!, ribbonHandle)\n    : null;\n\n  drawTriangles(ctx, ribbonHandle.indexCount, ctx.gl.UNSIGNED_INT);\n\n  // Narrow to bit 0 first: clear only zeroes bits the mask enables, and\n  // pushClip owns bits 1-7.\n  gl.stencilMask(0x01);\n  gl.clear(gl.STENCIL_BUFFER_BIT);\n  gl.disable(gl.STENCIL_TEST);\n  if (colors) detachVertexColors(gl, colors);\n  gl.bindVertexArray(null);\n}\n"],"mappings":"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"}

package/dist/renderer/draw/scratchPass.js

@@ -1,83 +0,0 @@
-import { drawTriangles as e } from "./drawTriangles.js";
-import { setProjAndModel as t } from "./uniforms.js";
-import { returnToRenderTarget as n } from "./effects.js";
-import { BATCH_MODEL as r } from "./flushBatch.js";
-import { getPaintKind as i } from "../../core/paintKinds.js";
-import { paintBindContext as a } from "./paintBind.js";
-//#region src/renderer/draw/scratchPass.ts
-var o = {
-	vertices: new Float32Array([
-		0,
-		0,
-		1,
-		0,
-		1,
-		1,
-		0,
-		1
-	]),
-	indices: new Uint32Array([
-		0,
-		1,
-		2,
-		0,
-		2,
-		3
-	])
-};
-function s(r, s, c) {
-	let l = r.paintScratch, u = i(s.fill)?.bind;
-	if (!l || !u) return null;
-	let d = r.deviceWidth && r.widthCss > 0 ? r.deviceWidth / r.widthCss : 1, f = r.deviceWidth ?? Math.round(r.widthCss), p = r.deviceHeight ?? Math.round(r.heightCss), m = Math.max(0, Math.floor(c.x0 * d)), h = Math.max(0, Math.floor(c.y0 * d)), g = r.imageCache.maxTextureSide, _ = Math.min(g, Math.min(f, Math.ceil(c.x1 * d)) - m), v = Math.min(g, Math.min(p, Math.ceil(c.y1 * d)) - h);
-	if (!(_ > 0 && v > 0)) return null;
-	let y = m / d, b = h / d, x = _ / d, S = v / d, C = new Float32Array([
-		x,
-		0,
-		0,
-		0,
-		S,
-		0,
-		y,
-		b,
-		1
-	]), w = new Float32Array([
-		2 / x,
-		0,
-		0,
-		0,
-		2 / S,
-		0,
-		-1 - 2 * y / x,
-		-1 - 2 * b / S,
-		1
-	]), T = a(r), E = {
-		...T,
-		alpha: r.state.alpha,
-		maxTextureSize: T.maxTextureSize,
-		setProjAndModel: (e) => t(r, e, C, w)
-	}, D = r.gl, O = l.acquire(_, v), k = D.isEnabled(D.SCISSOR_TEST);
-	D.activeTexture(D.TEXTURE0), D.bindTexture(D.TEXTURE_2D, null), D.bindFramebuffer(D.FRAMEBUFFER, O.fbo), D.viewport(0, 0, _, v), D.disable(D.SCISSOR_TEST), D.disable(D.STENCIL_TEST), D.clear(D.COLOR_BUFFER_BIT), D.disable(D.BLEND);
-	let A = u(E, s);
-	return A && (D.bindVertexArray(r.meshCache.uploadRecurring(o).vao), e(r, o.indices.length, D.UNSIGNED_INT), D.bindVertexArray(null)), D.enable(D.BLEND), n(r, f, p, k), A ? {
-		texture: O.texture,
-		uvFromScreen: new Float32Array([
-			d / O.width,
-			0,
-			0,
-			0,
-			d / O.height,
-			0,
-			-m / O.width,
-			-h / O.height,
-			1
-		])
-	} : null;
-}
-function c(e, n, i) {
-	let a = e.gl;
-	return a.useProgram(n.handle), t(e, n, r), a.uniformMatrix3fv(n.uniform("u_worldInv"), !1, i.uvFromScreen), a.activeTexture(a.TEXTURE0), a.bindTexture(a.TEXTURE_2D, i.texture), a.uniform1i(n.uniform("u_sampler"), 0), n;
-}
-//#endregion
-export { c as bindScratchPaint, s as renderPaintToScratch };
-
-//# sourceMappingURL=scratchPass.js.map

package/dist/renderer/draw/scratchPass.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scratchPass.js","names":["UNIT_QUAD","renderPaintToScratch","scratch","ctx","bind","getPaintKind","fill","ratio","deviceW","deviceH","px0","rect","py0","maxSide","pw","ph","x0","y0","w","h","model","proj","base","paintBindContext","bindCtx","setProjAndModel","prog","gl","target","scissorWasOn","drawTriangles","returnToRenderTarget","bindScratchPaint","BATCH_MODEL","painted"],"sources":["../../../src/renderer/draw/scratchPass.ts"],"sourcesContent":["import type { FillStyle } from '@weasel-js/paint';\nimport { getPaintKind, type PaintBindContext } from 'core/paintKinds';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport type { GlMat3 } from '../math/mat3';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { setProjAndModel } from './uniforms';\nimport { returnToRenderTarget } from './effects';\nimport { BATCH_MODEL } from './flushBatch';\nimport { paintBindContext } from './paintBind';\n\nexport interface ScreenRect { x0: number; y0: number; x1: number; y1: number }\n\n/** The unit square, stretched over the region a scratch paint covers. */\nconst UNIT_QUAD: Mesh = {\n  vertices: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),\n  indices: new Uint32Array([0, 1, 2, 0, 2, 3]),\n};\n\ninterface ScratchPaint {\n  texture: WebGLTexture;\n  /** Screen position → the texture coordinate the paint landed at there. */\n  uvFromScreen: GlMat3;\n}\n\n/**\n * Render a registered kind's paint over `rect` (screen px) into the renderer's\n * scratch buffer, through the kind's own `bind` — so any kind that paints a\n * path paints this, with nothing asked of it beyond what a path asks.\n *\n * The region is snapped out to the device-pixel grid and clamped to the\n * drawing buffer, so each texel is one device pixel of the target and a glyph\n * fragment reads its own. The kind sees the same transform, alpha and paint\n * space it would for a path here; only the projection differs, aimed at the\n * scratch buffer instead of the target. No clip and no scissor apply inside:\n * the glyphs that sample the result are drawn under both.\n *\n * `null` when there is no scratch buffer, the region is empty, or the kind\n * declines the paint — and the glyphs then draw nothing, as the outline tier\n * does for a paint no kind binds.\n */\nexport function renderPaintToScratch(ctx: DrawContext, fill: FillStyle, rect: ScreenRect): ScratchPaint | null {\n  const scratch = ctx.paintScratch;\n  const bind = getPaintKind(fill.fill)?.bind;\n  if (!scratch || !bind) return null;\n  const ratio = ctx.deviceWidth && ctx.widthCss > 0 ? ctx.deviceWidth / ctx.widthCss : 1;\n  const deviceW = ctx.deviceWidth ?? Math.round(ctx.widthCss);\n  const deviceH = ctx.deviceHeight ?? Math.round(ctx.heightCss);\n  const px0 = Math.max(0, Math.floor(rect.x0 * ratio));\n  const py0 = Math.max(0, Math.floor(rect.y0 * ratio));\n  const maxSide = ctx.imageCache.maxTextureSide;\n  const pw = Math.min(maxSide, Math.min(deviceW, Math.ceil(rect.x1 * ratio)) - px0);\n  const ph = Math.min(maxSide, Math.min(deviceH, Math.ceil(rect.y1 * ratio)) - py0);\n  if (!(pw > 0 && ph > 0)) return null;\n\n  // The region in screen px, and the two matrices a kind's vertex stage\n  // multiplies: the unit quad onto it, and it onto the whole of clip space.\n  const x0 = px0 / ratio, y0 = py0 / ratio, w = pw / ratio, h = ph / ratio;\n  const model = new Float32Array([w, 0, 0, 0, h, 0, x0, y0, 1]);\n  const proj = new Float32Array([2 / w, 0, 0, 0, 2 / h, 0, -1 - (2 * x0) / w, -1 - (2 * y0) / h, 1]);\n  const base = paintBindContext(ctx);\n  const bindCtx: PaintBindContext = {\n    ...base,\n    alpha: ctx.state.alpha,\n    maxTextureSize: base.maxTextureSize,\n    setProjAndModel: (prog) => setProjAndModel(ctx, prog, model, proj),\n  };\n\n  const gl = ctx.gl;\n  const target = scratch.acquire(pw, ph);\n  const scissorWasOn = gl.isEnabled(gl.SCISSOR_TEST);\n  // The last glyph pass left this texture bound to unit 0; a kind sampling a\n  // unit it never binds would read the buffer it is drawing into.\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, null);\n  gl.bindFramebuffer(gl.FRAMEBUFFER, target.fbo);\n  gl.viewport(0, 0, pw, ph);\n  gl.disable(gl.SCISSOR_TEST);\n  gl.disable(gl.STENCIL_TEST);\n  gl.clear(gl.COLOR_BUFFER_BIT);\n  gl.disable(gl.BLEND);\n\n  const prog = bind(bindCtx, fill);\n  if (prog) {\n    gl.bindVertexArray(ctx.meshCache.uploadRecurring(UNIT_QUAD).vao);\n    drawTriangles(ctx, UNIT_QUAD.indices.length, gl.UNSIGNED_INT);\n    gl.bindVertexArray(null);\n  }\n\n  gl.enable(gl.BLEND);\n  returnToRenderTarget(ctx, deviceW, deviceH, scissorWasOn);\n  if (!prog) return null;\n  return {\n    texture: target.texture,\n    uvFromScreen: new Float32Array([\n      ratio / target.width, 0, 0,\n      0, ratio / target.height, 0,\n      -px0 / target.width, -py0 / target.height, 1,\n    ]),\n  };\n}\n\n/** Bind the glyph program to sample `painted` as its paint. */\nexport function bindScratchPaint(ctx: DrawContext, prog: ShaderProgram, painted: ScratchPaint): ShaderProgram {\n  const gl = ctx.gl;\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog, BATCH_MODEL);\n  gl.uniformMatrix3fv(prog.uniform('u_worldInv')!, false, painted.uvFromScreen);\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, painted.texture);\n  gl.uniform1i(prog.uniform('u_sampler')!, 0);\n  return prog;\n}\n"],"mappings":"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"}

package/dist/renderer/draw/stencil.js

@@ -1,28 +0,0 @@
-import { drawTriangles as e } from "./drawTriangles.js";
-//#region src/renderer/draw/stencil.ts
-function t(e, t = e.clipDepth) {
-	let r = e.gl;
-	if (t === 0) {
-		r.disable(r.STENCIL_TEST);
-		return;
-	}
-	let i = n(t);
-	r.enable(r.STENCIL_TEST), r.stencilFunc(r.EQUAL, i, i), r.stencilOp(r.KEEP, r.KEEP, r.KEEP);
-}
-function n(e) {
-	return e === 0 ? 0 : (1 << e + 1) - 1 & 254;
-}
-function r(t, r) {
-	let i = t.gl;
-	i.enable(i.STENCIL_TEST), i.colorMask(!1, !1, !1, !1), i.stencilMask(1), i.stencilFunc(i.ALWAYS, 0, 1), i.stencilOp(i.KEEP, i.KEEP, i.INVERT), e(t, r, t.gl.UNSIGNED_INT);
-	let a = n(t.clipDepth);
-	i.colorMask(!0, !0, !0, !0), i.stencilFunc(i.EQUAL, a | 1, a | 1), i.stencilOp(i.KEEP, i.KEEP, i.KEEP);
-}
-function i(e) {
-	let t = e.gl;
-	t.stencilMask(1), t.clear(t.STENCIL_BUFFER_BIT), t.disable(t.STENCIL_TEST);
-}
-//#endregion
-export { n as ancestorMask, t as applyClipTest, r as beginParityMask, i as endParityMask };
-
-//# sourceMappingURL=stencil.js.map

package/dist/renderer/draw/stencil.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stencil.js","names":["applyClipTest","ctx","gl","depth","mask","ancestorMask","beginParityMask","drawTriangles","indexCount","clipMask","endParityMask"],"sources":["../../../src/renderer/draw/stencil.ts"],"sourcesContent":["import type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\n\n// ─── Per-fragment clip test ───────────────────────────────────────────────────\n\n/**\n * Set the stencil test for the current clip depth. Called by every\n * fragment-producing draw before its drawElements call when clipDepth > 0.\n * At clipDepth = 0, disables STENCIL_TEST (zero-overhead common case).\n *\n * Note: not called by drawPathFillStencil / drawPathStrokeStenciled, which\n * manage their own stencil state (evenodd / inner-outer stencil). Those paths\n * coexist with clip bits because they use bit 0 exclusively while clip levels\n * occupy bits 1-7.\n */\nexport function applyClipTest(ctx: DrawContext, depth: number = ctx.clipDepth): void {\n  const gl = ctx.gl;\n  if (depth === 0) {\n    gl.disable(gl.STENCIL_TEST);\n    return;\n  }\n  const mask = ancestorMask(depth);\n  gl.enable(gl.STENCIL_TEST);\n  gl.stencilFunc(gl.EQUAL, mask, mask);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);\n}\n\n// ─── Clip-stencil helpers ────────────────────────────────────────────────────\n\n/**\n * Bit-mask for ancestor clip levels.\n * Returns bits 1..depth (inclusive).\n * depth=0 → 0x00; depth=1 → 0x02; depth=3 → 0x0E.\n */\nexport function ancestorMask(depth: number): number {\n  return depth === 0 ? 0 : ((1 << (depth + 1)) - 1) & 0xFE;\n}\n\n/**\n * Write the bound even-odd mesh's parity to stencil bit 0, then leave the\n * test passing where that parity is odd and every enclosing clip holds. The\n * program, VAO, and model are the caller's, already bound.\n */\nexport function beginParityMask(ctx: DrawContext, indexCount: number): void {\n  const gl = ctx.gl;\n  gl.enable(gl.STENCIL_TEST);\n  gl.colorMask(false, false, false, false);\n  gl.stencilMask(0x01);\n  gl.stencilFunc(gl.ALWAYS, 0, 0x01);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);\n  drawTriangles(ctx, indexCount, ctx.gl.UNSIGNED_INT);\n\n  const clipMask = ancestorMask(ctx.clipDepth);\n  gl.colorMask(true, true, true, true);\n  gl.stencilFunc(gl.EQUAL, clipMask | 0x01, clipMask | 0x01);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);\n}\n\nexport function endParityMask(ctx: DrawContext): void {\n  const gl = ctx.gl;\n  // Narrow to bit 0 first: clear only zeroes bits the mask enables, and\n  // pushClip owns bits 1-7.\n  gl.stencilMask(0x01);\n  gl.clear(gl.STENCIL_BUFFER_BIT);\n  gl.disable(gl.STENCIL_TEST);\n}\n"],"mappings":";;AAeA,SAAgBA,EAAc,GAAkB,IAAgBC,EAAI,WAAiB;CACnF,IAAMC,IAAKD,EAAI;CACf,IAAIE,MAAU,GAAG;EACf,EAAG,QAAQD,EAAG,YAAY;EAC1B;CACF;CACA,IAAME,IAAOC,EAAaF,CAAK;CAG/B,AAFAD,EAAG,OAAOA,EAAG,YAAY,GACzBA,EAAG,YAAYA,EAAG,OAAOE,GAAMA,CAAI,GACnCF,EAAG,UAAUA,EAAG,MAAMA,EAAG,MAAMA,EAAG,IAAI;AACxC;AASA,SAAgBG,EAAa,GAAuB;CAClD,OAAOF,MAAU,IAAI,KAAM,KAAMA,IAAQ,KAAM,IAAK;AACtD;AAOA,SAAgBG,EAAgB,GAAkB,GAA0B;CAC1E,IAAMJ,IAAKD,EAAI;CAMf,AALAC,EAAG,OAAOA,EAAG,YAAY,GACzBA,EAAG,UAAU,IAAO,IAAO,IAAO,EAAK,GACvCA,EAAG,YAAY,CAAI,GACnBA,EAAG,YAAYA,EAAG,QAAQ,GAAG,CAAI,GACjCA,EAAG,UAAUA,EAAG,MAAMA,EAAG,MAAMA,EAAG,MAAM,GACxCK,EAAcN,GAAKO,GAAYP,EAAI,GAAG,YAAY;CAElD,IAAMQ,IAAWJ,EAAaJ,EAAI,SAAS;CAG3C,AAFAC,EAAG,UAAU,IAAM,IAAM,IAAM,EAAI,GACnCA,EAAG,YAAYA,EAAG,OAAOO,IAAW,GAAMA,IAAW,CAAI,GACzDP,EAAG,UAAUA,EAAG,MAAMA,EAAG,MAAMA,EAAG,IAAI;AACxC;AAEA,SAAgBQ,EAAc,GAAwB;CACpD,IAAMR,IAAKD,EAAI;CAKf,AAFAC,EAAG,YAAY,CAAI,GACnBA,EAAG,MAAMA,EAAG,kBAAkB,GAC9BA,EAAG,QAAQA,EAAG,YAAY;AAC5B"}

package/dist/renderer/draw/text.js

@@ -1,167 +0,0 @@
-import { resolveColor as e } from "../math/color.js";
-import { drawTriangles as t } from "./drawTriangles.js";
-import { applyClipTest as n } from "./stencil.js";
-import { BATCH_MODEL as r, flushBatch as i } from "./flushBatch.js";
-import { enterUncut as a, flushForOwnDraw as o, leaveUncut as s } from "./clip.js";
-import { batchPaint as c } from "./gradient.js";
-import { stageGlyphs as l, stageSolid as u, tryStageFill as d } from "./batch.js";
-import { bindGradient as f, bindPattern as p } from "./paintBind.js";
-import { drawPathFillByKind as m } from "./pathPaint.js";
-import { SYNTHETIC_ITALIC_RADIANS as h } from "../syntheticItalic.js";
-import { outlineGroupMesh as g, outlineGroupStrokeMesh as _ } from "../glyphOutlineMesh.js";
-import { bindScratchPaint as v, renderPaintToScratch as y } from "./scratchPass.js";
-import { GLYPH_MODE_MSDF as b, GLYPH_MODE_R8 as x, dynamicPageTextureId as S, ensureFontTexture as C, glyphFieldScale as w, syncDynamicPageTexture as T, textureCacheKey as E } from "@weasel-js/font";
-import { cachedLayoutRuns as D, resolveTextStyle as O, verticalAlignOffset as k } from "@weasel-js/text";
-//#region src/renderer/draw/text.ts
-var A = 48;
-function j(e) {
-	let t = Math.hypot(e[0], e[1]), n = Math.hypot(e[3], e[4]);
-	return Math.sqrt(t * n) || 1;
-}
-function M(e, t) {
-	let n = O(t.style), r = n.lineHeight, i = t.align ?? n.align, a = t.direction ?? n.direction, o = t.maxWidth ?? Infinity, s = e.textOutlineMinScreenSize ?? A, c = Number.isFinite(s) ? s / j(e.state.transform) : void 0, l = D(t.runs, {
-		maxWidth: o,
-		alignWidth: t.width,
-		lineHeight: r,
-		align: i,
-		direction: a,
-		tabSize: n.tabSize,
-		justify: t.justify,
-		outlineMinSize: c
-	});
-	if (l.groups.length === 0 && l.decorations.length === 0) return;
-	let u = t.x, d = t.y + k(t.verticalAlign, t.height, l.bounds.height);
-	for (let t of l.groups) t.source === "outline" ? N(e, t, u, d) : R(e, t, u, d);
-	F(e, l.decorations, u, d);
-}
-function N(e, t, n, r) {
-	let i = t.fill;
-	if (i !== null) {
-		let a = g(t, n, r);
-		a && P(e, i, a);
-	}
-	let a = t.stroke?.paint;
-	if (!a) return;
-	let o = _(t, n, r, e.state.transform);
-	o && P(e, a, o);
-}
-function P(e, t, n) {
-	let r = c(e, t, !1);
-	r !== null && (d(e, n, r) || m(e, t, e.meshCache.uploadTransient(n)));
-}
-function F(t, n, r, i) {
-	for (let o of n) {
-		if (z(o.fill) !== null) {
-			P(t, o.fill, I(o.x0 + r, o.y0 + i, o.x1 + r, o.y1 + i));
-			continue;
-		}
-		let [n, c, l, d] = "color" in o.fill ? e(o.fill.color) : [
-			0,
-			0,
-			0,
-			1
-		], f;
-		for (;;) {
-			let e = u(t, 4);
-			if (t.drawBatch.pushRect(o.x0 + r, o.y0 + i, o.x1 - o.x0, o.y1 - o.y0, t.state.transform, n, c, l, d * (e.foldsAlpha ? t.state.alpha : 1))) break;
-			f = a(t);
-		}
-		f !== void 0 && s(t, f);
-	}
-}
-function I(e, t, n, r) {
-	return {
-		vertices: new Float32Array([
-			e,
-			t,
-			n,
-			t,
-			n,
-			r,
-			e,
-			r
-		]),
-		indices: new Uint32Array([
-			0,
-			1,
-			2,
-			0,
-			2,
-			3
-		])
-	};
-}
-var L = .08;
-function R(t, n, r, o) {
-	if (n.source === "canvas") {
-		if (!T(t.textureCache, n.page)) return;
-	} else if (!C(n.family, n.weight, n.style, t.textureCache)) return;
-	if (n.quads.length === 0) return;
-	let c = n.source === "canvas" ? S(n.page) : E(n.family, n.weight, n.style), u = n.source === "canvas" ? x : b, d = w(n.source === "canvas" ? "canvas" : "atlas", n.family, n.weight, n.style);
-	if (!d) return;
-	let f = n.synthetic.bold ? L : 0, p = n.synthetic.italic ? Math.tan(h) : 0, m = z(n.fill);
-	if (m !== null) {
-		V(t, n, r, o, m, c, u, f, p, d);
-		return;
-	}
-	let g = n.fill !== null && "color" in n.fill ? e(n.fill.color) : [
-		0,
-		0,
-		0,
-		1
-	], _ = t.drawBatch, v = t.state.transform, { staged: y, slot: D } = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1);
-	for (let e of n.quads) {
-		_.wouldOverflow(4) && (i(t), {staged: y, slot: D} = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1));
-		let n;
-		for (; !_.pushGlyph(e.x0 + r, e.y0 + o, e.x1 + r, e.y1 + o, e.baselineY + o, p, v, e.u0, e.v0, e.u1, e.v1, g[0], g[1], g[2], O, D, u);) n = a(t), {staged: y, slot: D} = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1);
-		n !== void 0 && (s(t, n), {staged: y, slot: D} = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1));
-	}
-}
-function z(e) {
-	let t = e?.fill ?? "solid";
-	return t === "pattern" ? "pattern" : t === "linear-gradient" || t === "radial-gradient" || t === "conic-gradient" ? "gradient" : t === "solid" ? null : "texture";
-}
-var B = 1;
-function V(e, t, i, a, s, c, l, u, d, m) {
-	let h = e.glyphPaintProgram?.(s);
-	if (!h) return;
-	o(e);
-	let g = t.fill, _ = e.state.transform, b;
-	if (s === "pattern") b = p(e, h, g, r);
-	else if (s === "gradient") b = f(e, h, g, r);
-	else {
-		let n = y(e, g, U(t, i, a, d, _));
-		b = n && v(e, h, n);
-	}
-	if (!b) return;
-	let x = e.gl;
-	e.textureCache.bind(c, B), x.uniform1i(h.uniform("u_atlas"), B), x.uniform1f(h.uniform("u_synthBold"), u), x.uniform2f(h.uniform("u_fieldScale"), m[0], m[1]), n(e);
-	let S = e.drawBatch, C = S.clip;
-	S.clip = null;
-	for (let n of t.quads) S.wouldOverflow(4) && H(e), S.pushGlyph(n.x0 + i, n.y0 + a, n.x1 + i, n.y1 + a, n.baselineY + a, d, _, n.u0, n.v0, n.u1, n.v1, 1, 1, 1, 1, B, l);
-	H(e), S.clip = C, x.activeTexture(x.TEXTURE0), x.bindVertexArray(null);
-}
-function H(e) {
-	let n = e.drawBatch;
-	n.length !== 0 && (t(e, n.uploadAndBind(), e.gl.UNSIGNED_INT), n.reset());
-}
-function U(e, t, n, r, i) {
-	let a = {
-		x0: Infinity,
-		y0: Infinity,
-		x1: -Infinity,
-		y1: -Infinity
-	}, o = (e, t) => {
-		let n = i[0] * e + i[3] * t + i[6], r = i[1] * e + i[4] * t + i[7];
-		n < a.x0 && (a.x0 = n), n > a.x1 && (a.x1 = n), r < a.y0 && (a.y0 = r), r > a.y1 && (a.y1 = r);
-	};
-	for (let i of e.quads) {
-		let e = i.x0 + t, a = i.x1 + t, s = i.y0 + n, c = i.y1 + n, l = i.baselineY + n, u = (l - s) * r, d = (l - c) * r;
-		o(e + u, s), o(a + u, s), o(a + d, c), o(e + d, c);
-	}
-	return a;
-}
-//#endregion
-export { A as OUTLINE_MIN_SCREEN_PX, M as drawText };
-
-//# sourceMappingURL=text.js.map