@weasel-js/core 1.9.4 → 1.10.1

package/dist/renderer/cache/markerCommandCache.js

@@ -1,63 +0,0 @@
-import { screenSpaceKey as e } from "../../features/paths/tessellate/metric.js";
-import { getMarker as t, markerGeneration as n } from "../../core/strokeMarkers.js";
-import { markerKeyOf as r } from "../../core/markerInset.js";
-import { STROKE_CONFIGS_PER_PATH as i } from "./strokeMeshCache.js";
-import { headCommands as a, markerHeads as o, markerReadsKey as s } from "../../features/paths/markerCommands.js";
-//#region src/renderer/cache/markerCommandCache.ts
-var c = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap(), u = (e) => e === void 0 ? "" : typeof e == "string" ? e : `${e.key}@${String(e.size ?? "")}`;
-function d(e) {
-	let n = "";
-	for (let i of [
-		e.markerStart,
-		e.markerMid,
-		e.markerEnd
-	]) {
-		let a = i === void 0 ? void 0 : t(r(i));
-		if (a === void 0) {
-			n += "/";
-			continue;
-		}
-		let o = s(a, e);
-		if (o === null) return null;
-		n += `${o}/`;
-	}
-	return n;
-}
-function f(e, t, n) {
-	if (n !== null) {
-		let t = c.get(e);
-		return t === void 0 && c.set(e, t = /* @__PURE__ */ new Map()), t;
-	}
-	let r = l.get(e);
-	r === void 0 && l.set(e, r = /* @__PURE__ */ new WeakMap());
-	let i = r.get(t);
-	return i === void 0 && r.set(t, i = /* @__PURE__ */ new Map()), i;
-}
-function p(t, r, s, c, l, p = {}) {
-	if (s.markerStart === void 0 && s.markerMid === void 0 && s.markerEnd === void 0) return [];
-	let m = d(s), h = f(t, r, m), g = [
-		c,
-		l ?? "",
-		n(),
-		u(s.markerStart),
-		u(s.markerMid),
-		u(s.markerEnd),
-		m ?? "",
-		e(p.start),
-		e(p.mid),
-		e(p.end)
-	].join("|"), _ = h.get(g);
-	if (_ === void 0) {
-		let e = o(t, s, c, l, p);
-		_ = {
-			heads: e,
-			paint: s.paint,
-			cmds: a(e, s)
-		}, h.size >= i && h.clear(), h.set(g, _);
-	} else _.paint !== s.paint && (_.paint = s.paint, _.cmds = a(_.heads, s));
-	return _.cmds;
-}
-//#endregion
-export { p as cachedMarkerCommands };
-
-//# sourceMappingURL=markerCommandCache.js.map

package/dist/renderer/cache/markerCommandCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markerCommandCache.js","names":["byValue","byStroke","refKey","ref","readsKey","key","stroke","entry","getMarker","markerKeyOf","reads","markerReadsKey","mapFor","map","path","strokes","source","cachedMarkerCommands","strokeWidth","flattenTolerance","markerGeneration","screenSpaceKey","spaces","heads","markerHeads","headCommands","STROKE_CONFIGS_PER_PATH"],"sources":["../../../src/renderer/cache/markerCommandCache.ts"],"sourcesContent":["/**\n * A stroke's marker commands, cached per path. The placed head is a fresh\n * `Path`, and the fill cache keys on path identity — so rebuilding it every\n * frame would re-tessellate and re-upload every head every frame.\n *\n * Keyed on value, so a painter that builds a new stroke object every frame\n * still hits: the resolved lengths, the flatten tolerance, the registry's\n * generation, the marker refs and whatever fields each head declares it reads.\n * A head that does not declare them may read any field, so for it the stroke\n * as the command carried it — before any `{ px }` length was resolved — joins\n * the key by identity. Paint is applied over the cached geometry, so a new\n * paint reuses the heads.\n */\n\nimport type { Path } from '@weasel-js/geom';\nimport type { CommandFill, MarkerRef, CommandStroke } from '@weasel-js/paint';\nimport type { PathDrawCommand } from '../DrawCommand';\nimport {\n  headCommands, markerHeads, markerReadsKey, type MarkerHead,\n} from 'features/paths/markerCommands';\nimport { getMarker, markerGeneration } from '../../core/strokeMarkers';\nimport { markerKeyOf } from '../../core/markerInset';\nimport { STROKE_CONFIGS_PER_PATH } from './strokeMeshCache';\nimport { screenSpaceKey, type StrokeSpaces } from 'features/paths/tessellate/metric';\n\ninterface Entry {\n  readonly heads: MarkerHead[];\n  paint: CommandFill | undefined;\n  cmds: PathDrawCommand[];\n}\n\nlet byValue = new WeakMap<Path, Map<string, Entry>>();\nlet byStroke = new WeakMap<Path, WeakMap<CommandStroke, Map<string, Entry>>>();\n\nconst refKey = (ref: MarkerRef | undefined): string =>\n  ref === undefined ? '' : typeof ref === 'string' ? ref : `${ref.key}@${String(ref.size ?? '')}`;\n\n/** What every head of `stroke` reads, or `null` if any head does not say. */\nfunction readsKey(stroke: CommandStroke): string | null {\n  let key = '';\n  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {\n    const entry = ref === undefined ? undefined : getMarker(markerKeyOf(ref));\n    if (entry === undefined) {\n      key += '/';\n      continue;\n    }\n    const reads = markerReadsKey(entry, stroke);\n    if (reads === null) return null;\n    key += `${reads}/`;\n  }\n  return key;\n}\n\nfunction mapFor(path: Path, source: CommandStroke, reads: string | null): Map<string, Entry> {\n  if (reads !== null) {\n    let map = byValue.get(path);\n    if (map === undefined) byValue.set(path, (map = new Map()));\n    return map;\n  }\n  let strokes = byStroke.get(path);\n  if (strokes === undefined) byStroke.set(path, (strokes = new WeakMap()));\n  let map = strokes.get(source);\n  if (map === undefined) strokes.set(source, (map = new Map()));\n  return map;\n}\n\n/**\n * The marker commands for `path` under `stroke`, whose lengths are already\n * resolved. `source` is the stroke before that resolution. A head's lengths are\n * in the space `spaces` builds it in.\n */\nexport function cachedMarkerCommands(\n  path: Path,\n  source: CommandStroke,\n  stroke: CommandStroke,\n  strokeWidth: number,\n  flattenTolerance: number | undefined,\n  spaces: StrokeSpaces = {},\n): PathDrawCommand[] {\n  if (stroke.markerStart === undefined && stroke.markerMid === undefined && stroke.markerEnd === undefined) {\n    return [];\n  }\n  const reads = readsKey(stroke);\n  const map = mapFor(path, source, reads);\n  const key = [\n    strokeWidth,\n    flattenTolerance ?? '',\n    markerGeneration(),\n    refKey(stroke.markerStart),\n    refKey(stroke.markerMid),\n    refKey(stroke.markerEnd),\n    reads ?? '',\n    screenSpaceKey(spaces.start),\n    screenSpaceKey(spaces.mid),\n    screenSpaceKey(spaces.end),\n  ].join('|');\n  let entry = map.get(key);\n  if (entry === undefined) {\n    const heads = markerHeads(path, stroke, strokeWidth, flattenTolerance, spaces);\n    entry = { heads, paint: stroke.paint, cmds: headCommands(heads, stroke) };\n    if (map.size >= STROKE_CONFIGS_PER_PATH) map.clear();\n    map.set(key, entry);\n  } else if (entry.paint !== stroke.paint) {\n    entry.paint = stroke.paint;\n    entry.cmds = headCommands(entry.heads, stroke);\n  }\n  return entry.cmds;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetMarkerCommandCacheForTests(): void {\n  byValue = new WeakMap();\n  byStroke = new WeakMap();\n}\n"],"mappings":";;;;;;AA+BA,IAAIA,oBAAU,IAAI,QAAkC,GAChDC,oBAAW,IAAI,QAA0D,GAEvEC,KAAU,MACdC,MAAQ,KAAA,IAAY,KAAK,OAAOA,KAAQ,WAAWA,IAAM,GAAGA,EAAI,IAAI,GAAG,OAAOA,EAAI,QAAQ,EAAE;AAG9F,SAASC,EAAS,GAAsC;CACtD,IAAIC,IAAM;CACV,KAAK,IAAMF,KAAO;EAACG,EAAO;EAAaA,EAAO;EAAWA,EAAO;CAAS,GAAG;EAC1E,IAAMC,IAAQJ,MAAQ,KAAA,IAAY,KAAA,IAAYK,EAAUC,EAAYN,CAAG,CAAC;EACxE,IAAII,MAAU,KAAA,GAAW;GACvB,KAAO;GACP;EACF;EACA,IAAMG,IAAQC,EAAeJ,GAAOD,CAAM;EAC1C,IAAII,MAAU,MAAM,OAAO;EAC3B,KAAO,GAAGA,EAAM;CAClB;CACA,OAAOL;AACT;AAEA,SAASO,EAAO,GAAY,GAAuB,GAA0C;CAC3F,IAAIF,MAAU,MAAM;EAClB,IAAIG,IAAMb,EAAQ,IAAIc,CAAI;EAE1B,OADID,MAAQ,KAAA,KAAWb,EAAQ,IAAIc,GAAO,oBAAM,IAAI,IAAI,CAAE,GACnDD;CACT;CACA,IAAIE,IAAUd,EAAS,IAAIa,CAAI;CAC/B,AAAIC,MAAY,KAAA,KAAWd,EAAS,IAAIa,GAAO,oBAAU,IAAI,QAAQ,CAAE;CACvE,IAAID,IAAME,EAAQ,IAAIC,CAAM;CAE5B,OADIH,MAAQ,KAAA,KAAWE,EAAQ,IAAIC,GAAS,oBAAM,IAAI,IAAI,CAAE,GACrDH;AACT;AAOA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GACA,IAAuB,CAAC,GACL;CACnB,IAAIX,EAAO,gBAAgB,KAAA,KAAaA,EAAO,cAAc,KAAA,KAAaA,EAAO,cAAc,KAAA,GAC7F,OAAO,CAAC;CAEV,IAAMI,IAAQN,EAASE,CAAM,GACvBO,IAAMD,EAAOE,GAAME,GAAQN,CAAK,GAChCL,IAAM;EACVa;EACAC,KAAoB;EACpBC,EAAiB;EACjBlB,EAAOI,EAAO,WAAW;EACzBJ,EAAOI,EAAO,SAAS;EACvBJ,EAAOI,EAAO,SAAS;EACvBI,KAAS;EACTW,EAAeC,EAAO,KAAK;EAC3BD,EAAeC,EAAO,GAAG;EACzBD,EAAeC,EAAO,GAAG;CAC3B,CAAC,CAAC,KAAK,GAAG,GACNf,IAAQM,EAAI,IAAIR,CAAG;CACvB,IAAIE,MAAU,KAAA,GAAW;EACvB,IAAMgB,IAAQC,EAAYV,GAAMR,GAAQY,GAAaC,GAAkBG,CAAM;EAG7E,AAFA,IAAQ;GAAE;GAAO,OAAOhB,EAAO;GAAO,MAAMmB,EAAaF,GAAOjB,CAAM;EAAE,GACpEO,EAAI,QAAQa,KAAyBb,EAAI,MAAM,GACnDA,EAAI,IAAIR,GAAKE,CAAK;CACpB,OAAO,AAAIA,EAAM,UAAUD,EAAO,UAChC,EAAM,QAAQA,EAAO,OACrB,EAAM,OAAOmB,EAAalB,EAAM,OAAOD,CAAM;CAE/C,OAAOC,EAAM;AACf"}

package/dist/renderer/cache/outlineMeshCache.js

@@ -1,15 +0,0 @@
-import { pathFromD as e } from "@weasel-js/geom";
-import { tessellate as t } from "@weasel-js/geom/tessellate";
-//#region src/renderer/cache/outlineMeshCache.ts
-var n = 1 / 4096, r = 2048, i = /* @__PURE__ */ new Map();
-function a(a, o) {
-	let s = i.get(a);
-	if (s !== void 0) return s;
-	i.size >= r && (i = /* @__PURE__ */ new Map());
-	let c = t(e(o), { flattenTolerance: n });
-	return i.set(a, c), c;
-}
-//#endregion
-export { n as OUTLINE_FLATTEN_TOLERANCE, r as OUTLINE_MESH_CACHE_LIMIT, a as outlineMesh };
-
-//# sourceMappingURL=outlineMeshCache.js.map

package/dist/renderer/cache/outlineMeshCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"outlineMeshCache.js","names":["OUTLINE_FLATTEN_TOLERANCE","OUTLINE_MESH_CACHE_LIMIT","cache","outlineMesh","cached","key","mesh","tessellate","pathFromD","d"],"sources":["../../../src/renderer/cache/outlineMeshCache.ts"],"sourcesContent":["/**\n * Tessellated glyph outlines, in em space.\n *\n * This is the half of the outline text tier that is expensive: parsing `d`\n * into a path and running earcut over it costs far more than the per-instance\n * transform that follows. It is also the half that does not vary — em space\n * is unit-scale and baseline-relative, so the same glyph of the same face is\n * the same triangles at every size, position and zoom. Tessellate once, keep\n * it, and pay only a scale-and-translate per occurrence.\n *\n * That is why the renderer transforms cached vertices on the CPU and appends\n * them into one shared buffer rather than giving each glyph its own model\n * matrix: a per-glyph matrix would mean a draw call per glyph, throwing away\n * the batching the atlas tier already has, in exchange for saving an\n * arithmetic pass over a few hundred vertices.\n *\n * ### Flatten tolerance\n *\n * Tessellating once means committing to a curve tolerance once, and em space\n * makes that a clean tradeoff rather than a guess: an error of `T` em shows\n * up as `T × fontSize × viewScale` screen pixels. At 1/4096 em, a glyph would\n * have to reach ~4000 screen pixels tall before the flattening error covered\n * a single pixel — well past any size a document is read at, and far enough\n * past the tier's own threshold that the two never interact.\n *\n * ### Bound\n *\n * A plain `Map` with a cap and wholesale eviction. Glyph tessellations are\n * small (a few hundred vertices) and the working set is a charset, not a\n * document — the cap exists so a page that cycles through many faces cannot\n * grow without limit, not because pressure is expected. Wholesale rather than\n * LRU because the refill cost is bounded by what is actually on screen, and\n * an LRU's bookkeeping would cost more than the misses it avoids.\n */\n\nimport { pathFromD } from '@weasel-js/geom';\nimport { tessellate, type Mesh } from '@weasel-js/geom/tessellate';\n\n/** Curve flattening tolerance for glyph outlines, in em. See the header. */\nexport const OUTLINE_FLATTEN_TOLERANCE = 1 / 4096;\n\n/** Cached glyph tessellations before the cache is dropped wholesale. */\nexport const OUTLINE_MESH_CACHE_LIMIT = 2048;\n\nlet cache = new Map<string, Mesh>();\n\n/**\n * The em-space tessellation of one glyph.\n *\n * `key` identifies the glyph — face identity plus codepoint, assembled by\n * `layoutRuns`. `d` is only read on a miss, so passing the path data on every\n * call costs nothing; it is already in hand from the same source.\n */\nexport function outlineMesh(key: string, d: string): Mesh {\n  const cached = cache.get(key);\n  if (cached !== undefined) return cached;\n  if (cache.size >= OUTLINE_MESH_CACHE_LIMIT) cache = new Map();\n  const mesh = tessellate(pathFromD(d), { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE });\n  cache.set(key, mesh);\n  return mesh;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetOutlineMeshCacheForTests(): void {\n  cache = new Map();\n}\n"],"mappings":";;;AAuCA,IAAaA,IAA4B,IAAI,MAGhCC,IAA2B,MAEpCC,oBAAQ,IAAI,IAAkB;AASlC,SAAgBC,EAAY,GAAa,GAAiB;CACxD,IAAMC,IAASF,EAAM,IAAIG,CAAG;CAC5B,IAAID,MAAW,KAAA,GAAW,OAAOA;CACjC,AAAIF,EAAM,QAAQD,MAA0B,oBAAQ,IAAI,IAAI;CAC5D,IAAMK,IAAOC,EAAWC,EAAUC,CAAC,GAAG,EAAE,kBAAkBT,EAA0B,CAAC;CAErF,OADAE,EAAM,IAAIG,GAAKC,CAAI,GACZA;AACT"}

package/dist/renderer/cache/outlineStrokeMeshCache.js

@@ -1,36 +0,0 @@
-import { metricKey as e } from "../../features/paths/tessellate/metric.js";
-import { tessellateStroke as t } from "../../features/paths/tessellate/stroke.js";
-import { OUTLINE_FLATTEN_TOLERANCE as n } from "./outlineMeshCache.js";
-import { pathFromD as r } from "@weasel-js/geom";
-//#region src/renderer/cache/outlineStrokeMeshCache.ts
-var i = 2048, a = 1 / 1024, o = /* @__PURE__ */ new Map();
-function s(e) {
-	return Math.round(e / a) * a;
-}
-function c(a, s, c, l, u) {
-	if (!(c > 0)) return null;
-	let d = [
-		a,
-		c,
-		l.join ?? "miter",
-		l.cap ?? "butt",
-		l.miterLimit ?? "",
-		l.align ?? "center",
-		(l.dash ?? []).join(","),
-		e(u)
-	].join("|"), f = o.get(d);
-	if (f !== void 0) return f.indices.length === 0 ? null : f;
-	o.size >= i && (o = /* @__PURE__ */ new Map());
-	let p = t(r(s), {
-		...l,
-		width: c
-	}, {
-		flattenTolerance: n,
-		metric: u
-	});
-	return o.set(d, p), p.indices.length === 0 ? null : p;
-}
-//#endregion
-export { i as OUTLINE_STROKE_MESH_CACHE_LIMIT, c as outlineStrokeMesh, s as quantizeEmWidth };
-
-//# sourceMappingURL=outlineStrokeMeshCache.js.map

package/dist/renderer/cache/outlineStrokeMeshCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"outlineStrokeMeshCache.js","names":["OUTLINE_STROKE_MESH_CACHE_LIMIT","WIDTH_QUANTUM","cache","quantizeEmWidth","emWidth","outlineStrokeMesh","key","glyphKey","stroke","metricKey","metric","cached","mesh","tessellateStroke","pathFromD","d","OUTLINE_FLATTEN_TOLERANCE"],"sources":["../../../src/renderer/cache/outlineStrokeMeshCache.ts"],"sourcesContent":["/**\n * Tessellated glyph *outlines' strokes*, in em space.\n *\n * The sibling of `outlineMeshCache`, and cached for the same reason: parsing\n * `d` and tessellating a ribbon costs far more than the per-instance\n * transform that follows, and em space is size- and position-independent, so\n * one tessellation serves every occurrence of that glyph.\n *\n * ### Why the width is in the key\n *\n * A fill mesh is the same triangles at every size. A stroke's is not — the\n * ribbon's width relative to the glyph decides the geometry, so the em-space\n * mesh depends on `strokeWidth / fontSize`. That ratio is a property of the\n * run's style, not of the frame, so it is stable across frames and makes a\n * perfectly good cache key; what it is *not* is free, so a document that\n * animates stroke width or font size will miss every frame. That is the same\n * bargain `tessellate` makes everywhere else, and it is the reason the width\n * is quantized before it reaches the key: neighbouring sub-quantum widths\n * would otherwise each get their own entry and evict each other.\n *\n * Joins, caps, miter limit, alignment and dash all change the ribbon too, so\n * they are in the key as well — assembled by the caller, which already has\n * the `Stroke` in hand.\n */\n\nimport { pathFromD } from '@weasel-js/geom';\nimport { tessellateStroke } from 'features/paths/tessellate/stroke';\nimport { metricKey, type StrokeMetric } from 'features/paths/tessellate/metric';\nimport type { Stroke } from '@weasel-js/paint';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport { OUTLINE_FLATTEN_TOLERANCE } from './outlineMeshCache';\n\n/** Cached ribbons before the cache is dropped wholesale. Matches the fill\n *  cache's cap: the working set is a charset times the handful of stroke\n *  widths a document actually uses. */\nexport const OUTLINE_STROKE_MESH_CACHE_LIMIT = 2048;\n\n/**\n * Em-width quantum. 1/1024 em is finer than any width a reader can\n * distinguish at the sizes this tier serves — a 0.001 em difference is a\n * fifth of a screen pixel on 200px text — and coarse enough that a slider\n * dragged across a range lands on a bounded set of keys.\n */\nconst WIDTH_QUANTUM = 1 / 1024;\n\nlet cache = new Map<string, Mesh>();\n\n/** Quantized em width, exported so the key builder and the tessellator agree\n *  on the number rather than each rounding for themselves. */\nexport function quantizeEmWidth(emWidth: number): number {\n  return Math.round(emWidth / WIDTH_QUANTUM) * WIDTH_QUANTUM;\n}\n\n/**\n * The em-space stroke tessellation of one glyph.\n *\n * `glyphKey` identifies the glyph (face identity plus codepoint, assembled by\n * `layoutRuns`); `emWidth` is the stroke width in em, already quantized, and\n * `stroke`'s dashes are in em too. Given a `metric`, the ribbon is built in its\n * space and both are lengths there. `d` is only read on a miss.\n *\n * Returns `null` when the ribbon has no area — a zero or negative width, or a\n * glyph whose path is empty (a space).\n */\nexport function outlineStrokeMesh(\n  glyphKey: string,\n  d: string,\n  emWidth: number,\n  stroke: Stroke,\n  metric?: StrokeMetric,\n): Mesh | null {\n  if (!(emWidth > 0)) return null;\n  const key = [\n    glyphKey, emWidth, stroke.join ?? 'miter', stroke.cap ?? 'butt',\n    stroke.miterLimit ?? '', stroke.align ?? 'center', (stroke.dash ?? []).join(','),\n    metricKey(metric),\n  ].join('|');\n\n  const cached = cache.get(key);\n  if (cached !== undefined) return cached.indices.length === 0 ? null : cached;\n  if (cache.size >= OUTLINE_STROKE_MESH_CACHE_LIMIT) cache = new Map();\n\n  const mesh = tessellateStroke(\n    pathFromD(d),\n    { ...stroke, width: emWidth },\n    { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE, metric },\n  );\n  cache.set(key, mesh);\n  return mesh.indices.length === 0 ? null : mesh;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetOutlineStrokeMeshCacheForTests(): void {\n  cache = new Map();\n}\n"],"mappings":";;;;;AAmCA,IAAaA,IAAkC,MAQzCC,IAAgB,IAAI,MAEtBC,oBAAQ,IAAI,IAAkB;AAIlC,SAAgBC,EAAgB,GAAyB;CACvD,OAAO,KAAK,MAAMC,IAAUH,CAAa,IAAIA;AAC/C;AAaA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GACa;CACb,IAAI,EAAED,IAAU,IAAI,OAAO;CAC3B,IAAME,IAAM;EACVC;EAAUH;EAASI,EAAO,QAAQ;EAASA,EAAO,OAAO;EACzDA,EAAO,cAAc;EAAIA,EAAO,SAAS;GAAWA,EAAO,QAAQ,CAAC,EAAA,CAAG,KAAK,GAAG;EAC/EC,EAAUC,CAAM;CAClB,CAAC,CAAC,KAAK,GAAG,GAEJC,IAAST,EAAM,IAAII,CAAG;CAC5B,IAAIK,MAAW,KAAA,GAAW,OAAOA,EAAO,QAAQ,WAAW,IAAI,OAAOA;CACtE,AAAIT,EAAM,QAAQF,MAAiC,oBAAQ,IAAI,IAAI;CAEnE,IAAMY,IAAOC,EACXC,EAAUC,CAAC,GACX;EAAE,GAAGP;EAAQ,OAAOJ;CAAQ,GAC5B;EAAE,kBAAkBY;EAA2B;CAAO,CACxD;CAEA,OADAd,EAAM,IAAII,GAAKM,CAAI,GACZA,EAAK,QAAQ,WAAW,IAAI,OAAOA;AAC5C"}

package/dist/renderer/cache/strokeMeshCache.js

@@ -1,55 +0,0 @@
-import { metricKey as e } from "../../features/paths/tessellate/metric.js";
-import { resolveStrokeWidth as t, tessellateStroke as n } from "../../features/paths/tessellate/stroke.js";
-import { strokeInsets as r } from "../../core/markerInset.js";
-//#region src/renderer/cache/strokeMeshCache.ts
-var i = 8, a = 1 / 8;
-function o(e, t) {
-	if (!(e > 0) || !(t > 0) || !Number.isFinite(t)) return t;
-	let n = Math.ceil(Math.LN2 / (2 * Math.log1p(a / e)));
-	return 2 ** (Math.round(Math.log2(t) * n) / n);
-}
-var s = /* @__PURE__ */ new WeakMap();
-function c(n, i, a) {
-	let o = t(n.width ?? 1, 1), s = r(n, o), c = a.ribbon?.metric;
-	return [
-		o,
-		n.cap ?? "butt",
-		n.join ?? "miter",
-		n.miterLimit ?? "",
-		n.align ?? "center",
-		(n.dash ?? []).join(","),
-		n.varyingWidthJoinThreshold ?? "",
-		i ?? "",
-		s.start,
-		s.end,
-		e(c),
-		e(a.start?.metric),
-		e(a.end?.metric)
-	].join("|");
-}
-function l(e, a, o, l = {}) {
-	let d = s.get(e);
-	d === void 0 && (d = /* @__PURE__ */ new Map(), s.set(e, d));
-	let f = c(a, o, l), p = d.get(f);
-	if (p !== void 0 && p.vertexWidths === a.vertexWidths) return p.mesh;
-	let m = t(a.width ?? 1, 1), h = r(a, m), g = n(e, a, {
-		flattenTolerance: o,
-		startInset: u(h.start, l.start, l.ribbon),
-		endInset: u(h.end, l.end, l.ribbon),
-		metric: l.ribbon?.metric
-	});
-	return p === void 0 && d.size >= i && d.clear(), d.set(f, {
-		mesh: g,
-		vertexWidths: a.vertexWidths
-	}), g;
-}
-function u(e, t, n) {
-	return t?.metric === n?.metric ? e : {
-		length: e,
-		metric: t?.metric ?? null
-	};
-}
-//#endregion
-export { i as STROKE_CONFIGS_PER_PATH, o as quantizeStrokeScale, l as strokeMesh };
-
-//# sourceMappingURL=strokeMeshCache.js.map

package/dist/renderer/cache/strokeMeshCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strokeMeshCache.js","names":["STROKE_CONFIGS_PER_PATH","PX_WIDTH_TOLERANCE","quantizeStrokeScale","px","scale","stepsPerOctave","cache","configKey","width","resolveStrokeWidth","stroke","insets","strokeInsets","ribbon","spaces","flattenTolerance","metricKey","strokeMesh","byConfig","path","key","entry","mesh","tessellateStroke","insetIn","head","length"],"sources":["../../../src/renderer/cache/strokeMeshCache.ts"],"sourcesContent":["/**\n * Tessellated stroke ribbons for scene paths, keyed on `Path` identity.\n *\n * The sibling of `cache.ts` (fills) and `outlineStrokeMeshCache.ts` (glyph\n * ribbons in em space), and it inherits their contract: identity, not content.\n * A `Path` rebuilt with equal coords is a distinct entry.\n *\n * Design: `docs/superpowers/specs/2026-08-15-stroke-ribbon-cache-design.md`.\n */\n\nimport type { Path } from '@weasel-js/geom';\nimport type { Stroke } from '@weasel-js/paint';\nimport { tessellateStroke, resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { strokeInsets } from '../../core/markerInset';\nimport { metricKey, type ScreenSpace, type StrokeSpaces } from 'features/paths/tessellate/metric';\nimport type { InsetLength } from 'features/paths/tessellate/insets';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\n\n/**\n * Distinct stroke configurations kept per path before that path's map is\n * dropped wholesale. A document uses a handful; a width slider passes this on\n * its first drag and then degrades to tessellating every frame, which is what\n * it did before this cache existed.\n */\nexport const STROKE_CONFIGS_PER_PATH = 8;\n\n/** Screen-pixel bound on how far a quantized `{ px }` ribbon's width may\n *  drift from the width asked for: each edge moves at most half of it. */\nconst PX_WIDTH_TOLERANCE = 1 / 8;\n\n/**\n * `scale` snapped to a log-spaced grid, for resolving a `{ px }` width against.\n * Resolving against the raw scale gives a continuous zoom a new cache key every\n * frame. The grid is fine enough that the resolved ribbon stays within\n * `PX_WIDTH_TOLERANCE` screen pixels of `px`, so it is coarser for thin\n * strokes, and powers of two land on it exactly.\n */\nexport function quantizeStrokeScale(px: number, scale: number): number {\n  if (!(px > 0) || !(scale > 0) || !Number.isFinite(scale)) return scale;\n  const stepsPerOctave = Math.ceil(Math.LN2 / (2 * Math.log1p(PX_WIDTH_TOLERANCE / px)));\n  return 2 ** (Math.round(Math.log2(scale) * stepsPerOctave) / stepsPerOctave);\n}\n\ninterface StrokeEntry {\n  readonly mesh: Mesh;\n  /** Compared by reference — long enough that stringifying it per frame would\n   *  cost what the cache saves. */\n  readonly vertexWidths: number[] | undefined;\n}\n\nlet cache = new WeakMap<Path, Map<string, StrokeEntry>>();\n\n/** The stroke parameters that change the ribbon's geometry. `paint` and\n *  `vertexColors` are absent on purpose: both are applied over the same\n *  triangles at draw time. Marker *identity* is absent too — only the\n *  resolved trim distance affects these triangles, so two heads with the\n *  same inset share one entry. */\nfunction configKey(stroke: Stroke, flattenTolerance: number | undefined, spaces: StrokeSpaces): string {\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  const ribbon = spaces.ribbon?.metric;\n  return [\n    width,\n    stroke.cap ?? 'butt',\n    stroke.join ?? 'miter',\n    stroke.miterLimit ?? '',\n    stroke.align ?? 'center',\n    (stroke.dash ?? []).join(','),\n    stroke.varyingWidthJoinThreshold ?? '',\n    flattenTolerance ?? '',\n    insets.start,\n    insets.end,\n    metricKey(ribbon),\n    metricKey(spaces.start?.metric),\n    metricKey(spaces.end?.metric),\n  ].join('|');\n}\n\n/** The tessellated ribbon for `path` under `stroke`, built in the space\n *  `spaces` names for it, and stopped short of each head in that head's own.\n *  The same `Mesh` object comes back for as long as the entry lives. */\nexport function strokeMesh(\n  path: Path,\n  stroke: Stroke,\n  flattenTolerance: number | undefined,\n  spaces: StrokeSpaces = {},\n): Mesh {\n  let byConfig = cache.get(path);\n  if (byConfig === undefined) {\n    byConfig = new Map<string, StrokeEntry>();\n    cache.set(path, byConfig);\n  }\n\n  const key = configKey(stroke, flattenTolerance, spaces);\n  const entry = byConfig.get(key);\n  if (entry !== undefined && entry.vertexWidths === stroke.vertexWidths) {\n    return entry.mesh;\n  }\n\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  const mesh = tessellateStroke(path, stroke, {\n    flattenTolerance,\n    startInset: insetIn(insets.start, spaces.start, spaces.ribbon),\n    endInset: insetIn(insets.end, spaces.end, spaces.ribbon),\n    metric: spaces.ribbon?.metric,\n  });\n  // Only a new key grows the map; replacing one under a churning\n  // `vertexWidths` must not evict the other configurations alongside it.\n  if (entry === undefined && byConfig.size >= STROKE_CONFIGS_PER_PATH) byConfig.clear();\n  byConfig.set(key, { mesh, vertexWidths: stroke.vertexWidths });\n  return mesh;\n}\n\n/** `length`, measured in `head`'s space, as the tessellator reads it. */\nfunction insetIn(length: number, head: ScreenSpace | undefined, ribbon: ScreenSpace | undefined): InsetLength {\n  return head?.metric === ribbon?.metric ? length : { length, metric: head?.metric ?? null };\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetStrokeMeshCacheForTests(): void {\n  cache = new WeakMap();\n}\n"],"mappings":";;;;AAwBA,IAAaA,IAA0B,GAIjCC,IAAqB,IAAI;AAS/B,SAAgBC,EAAoB,GAAY,GAAuB;CACrE,IAAI,EAAEC,IAAK,MAAM,EAAEC,IAAQ,MAAM,CAAC,OAAO,SAASA,CAAK,GAAG,OAAOA;CACjE,IAAMC,IAAiB,KAAK,KAAK,KAAK,OAAO,IAAI,KAAK,MAAMJ,IAAqBE,CAAE,EAAE;CACrF,OAAO,MAAM,KAAK,MAAM,KAAK,KAAKC,CAAK,IAAIC,CAAc,IAAIA;AAC/D;AASA,IAAIC,oBAAQ,IAAI,QAAwC;AAOxD,SAASC,EAAU,GAAgB,GAAsC,GAA8B;CACrG,IAAMC,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK,GACnCK,IAASC,EAAO,QAAQ;CAC9B,OAAO;EACLN;EACAE,EAAO,OAAO;EACdA,EAAO,QAAQ;EACfA,EAAO,cAAc;EACrBA,EAAO,SAAS;GACfA,EAAO,QAAQ,CAAC,EAAA,CAAG,KAAK,GAAG;EAC5BA,EAAO,6BAA6B;EACpCK,KAAoB;EACpBJ,EAAO;EACPA,EAAO;EACPK,EAAUH,CAAM;EAChBG,EAAUF,EAAO,OAAO,MAAM;EAC9BE,EAAUF,EAAO,KAAK,MAAM;CAC9B,CAAC,CAAC,KAAK,GAAG;AACZ;AAKA,SAAgBG,EACd,GACA,GACA,GACA,IAAuB,CAAC,GAClB;CACN,IAAIC,IAAWZ,EAAM,IAAIa,CAAI;CAC7B,AAAID,MAAa,KAAA,MACf,oBAAW,IAAI,IAAyB,GACxCZ,EAAM,IAAIa,GAAMD,CAAQ;CAG1B,IAAME,IAAMb,EAAUG,GAAQK,GAAkBD,CAAM,GAChDO,IAAQH,EAAS,IAAIE,CAAG;CAC9B,IAAIC,MAAU,KAAA,KAAaA,EAAM,iBAAiBX,EAAO,cACvD,OAAOW,EAAM;CAGf,IAAMb,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK,GACnCc,IAAOC,EAAiBJ,GAAMT,GAAQ;EAC1C;EACA,YAAYc,EAAQb,EAAO,OAAOG,EAAO,OAAOA,EAAO,MAAM;EAC7D,UAAUU,EAAQb,EAAO,KAAKG,EAAO,KAAKA,EAAO,MAAM;EACvD,QAAQA,EAAO,QAAQ;CACzB,CAAC;CAKD,OAFIO,MAAU,KAAA,KAAaH,EAAS,QAAQlB,KAAyBkB,EAAS,MAAM,GACpFA,EAAS,IAAIE,GAAK;EAAE;EAAM,cAAcV,EAAO;CAAa,CAAC,GACtDY;AACT;AAGA,SAASE,EAAQ,GAAgB,GAA+B,GAA8C;CAC5G,OAAOC,GAAM,WAAWZ,GAAQ,SAASa,IAAS;EAAE;EAAQ,QAAQD,GAAM,UAAU;CAAK;AAC3F"}

package/dist/renderer/cullDrawCommands.js

@@ -1,90 +0,0 @@
-import { mat3 as e } from "./math/mat3.js";
-import { resolveStrokeWidth as t } from "../features/paths/tessellate/stroke.js";
-import { markerReach as n } from "../features/paths/markerCommands.js";
-import { SPRITE_STRIDE as r } from "./DrawCommand.js";
-import { resolveScreenLength as i } from "@weasel-js/paint";
-//#region src/renderer/cullDrawCommands.ts
-var a = 1, o = 4;
-function s(e, t, n) {
-	return c(e, t, h(n));
-}
-function c(e, t, n) {
-	let r = null;
-	for (let i = 0; i < e.length; i++) {
-		let a = e[i], o = l(a, t, n);
-		if (o === a) {
-			r?.push(a);
-			continue;
-		}
-		r ??= e.slice(0, i), o && r.push(o);
-	}
-	return r ?? e;
-}
-function l(t, n, r) {
-	switch (t.kind) {
-		case "group": {
-			if (t.effects && t.effects.length > 0) return t;
-			let i = t.transform ? e.multiply(n, t.transform) : n, a = c(t.children, i, r);
-			return a === t.children ? t : a.length === 0 ? null : {
-				...t,
-				children: a
-			};
-		}
-		case "path": return u(t.path, t.stroke, n, r) ? null : t;
-		case "image": return g(t.x, t.y, t.x + t.w, t.y + t.h, n, r) ? null : t;
-		case "sprites": return p(t.sprites, n, r) ? null : t;
-		default: return t;
-	}
-}
-function u(e, t, n, r) {
-	let i, a, o, s;
-	if (e.kind === "rect") i = Math.min(e.x, e.x + e.width), o = Math.max(e.x, e.x + e.width), a = Math.min(e.y, e.y + e.height), s = Math.max(e.y, e.y + e.height);
-	else if (e.kind === "polygon") {
-		let t = e.coords;
-		if (t.length < 2) return !1;
-		i = o = t[0], a = s = t[1];
-		for (let e = 2; e + 1 < t.length; e += 2) {
-			let n = t[e], r = t[e + 1];
-			n < i ? i = n : n > o && (o = n), r < a ? a = r : r > s && (s = r);
-		}
-	} else return !1;
-	let c = t ? d(t, n) : 0;
-	return g(i - c, a - c, o + c, s + c, n, r);
-}
-function d(t, n) {
-	return f(t, e.meanScaleOf(n), e.minScaleOf(n));
-}
-function f(e, r, a = r) {
-	let s = a > 0 ? a : r, c = t(e.width ?? 1, typeof e.width == "object" ? s : r);
-	if (e.vertexWidths) for (let t of e.vertexWidths) t > c && (c = t);
-	let l = Math.max(e.miterLimit ?? o, Math.SQRT2), u = n(e);
-	return Math.max(Math.abs(c) * l, u.world, i({ px: u.px }, s));
-}
-function p(e, t, n) {
-	let i = Infinity, a = Infinity, o = -Infinity, s = -Infinity;
-	for (let t = 0; t + r <= e.length; t += r) {
-		let n = e[t], r = e[t + 1], c = n + e[t + 2], l = r + e[t + 3];
-		i = Math.min(i, n, c), o = Math.max(o, n, c), a = Math.min(a, r, l), s = Math.max(s, r, l);
-	}
-	return i !== Infinity && g(i, a, o, s, t, n);
-}
-function m(e, t, n) {
-	let r = Math.min(e.x, e.x + e.width), i = Math.max(e.x, e.x + e.width);
-	return g(r, Math.min(e.y, e.y + e.height), i, Math.max(e.y, e.y + e.height), t, h(n));
-}
-function h(e) {
-	return {
-		minX: e.x - a,
-		minY: e.y - a,
-		maxX: e.x + e.width + a,
-		maxY: e.y + e.height + a
-	};
-}
-function g(t, n, r, i, a, o) {
-	let [s, c] = e.apply(a, t, n), [l, u] = e.apply(a, r, n), [d, f] = e.apply(a, r, i), [p, m] = e.apply(a, t, i);
-	return Math.max(s, l, d, p) < o.minX || Math.min(s, l, d, p) > o.maxX || Math.max(c, u, f, m) < o.minY || Math.min(c, u, f, m) > o.maxY;
-}
-//#endregion
-export { m as boundsMissRect, s as cullDrawCommands, f as strokeReachAt };
-
-//# sourceMappingURL=cullDrawCommands.js.map

package/dist/renderer/cullDrawCommands.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cullDrawCommands.js","names":["SLACK_PX","DEFAULT_MITER_LIMIT","cullDrawCommands","cullList","cmds","transform","slackBox","rect","out","cmd","kept","cullOne","m","box","inner","mat3","children","pathMisses","quadMisses","spritesMiss","minX","minY","maxX","maxY","path","c","i","x","y","reach","stroke","strokeReach","strokeReachAt","scale","at","least","width","resolveStrokeWidth","v","spike","heads","markerReach","resolveScreenLength","SPRITE_STRIDE","sprites","x0","y0","x1","y1","boundsMissRect","bounds","ax","ay","bx","by","cx","cy","dx","dy"],"sources":["../../src/renderer/cullDrawCommands.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { resolveScreenLength, type Stroke } from '@weasel-js/paint';\nimport { SPRITE_STRIDE, type DrawCommand } from './DrawCommand';\nimport { mat3, type GlMat3 } from './math/mat3';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { markerReach } from 'features/paths/markerCommands';\n\n/** A screen-space rectangle, CSS pixels. */\nexport interface CullRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Screen pixels added to every bound: antialiasing, and the 1/8 px a `{ px }`\n *  stroke's width may drift through quantization. */\nconst SLACK_PX = 1;\n\n/** Matches the tessellator's default. */\nconst DEFAULT_MITER_LIMIT = 4;\n\n/**\n * `cmds` without the commands that cannot put a pixel inside `rect`, where\n * `transform` maps the commands' space to screen space — `viewToMat3(view)`\n * for a world-space layer.\n *\n * Conservative by construction: a command is dropped only when a bound that\n * encloses everything it can paint misses `rect`. Paths are bounded by their\n * control hull plus the farthest a stroke can reach (miter spikes and square\n * caps included), images and sprites by their quads, and every bound is taken\n * through the accumulated transform as the AABB of its corners, so rotation\n * only enlarges it. Text and shader commands are always kept, and so is a\n * group with `effects` — an effect may move pixels. Clips are ignored, which\n * can only keep more. A group whose children all go is dropped.\n *\n * Returns `cmds` itself when nothing was dropped.\n */\nexport function cullDrawCommands(\n  cmds: DrawCommand[],\n  transform: GlMat3,\n  rect: CullRect,\n): DrawCommand[] {\n  return cullList(cmds, transform, slackBox(rect));\n}\n\ninterface Box { minX: number; minY: number; maxX: number; maxY: number }\n\nfunction cullList(cmds: DrawCommand[], m: GlMat3, box: Box): DrawCommand[] {\n  let out: DrawCommand[] | null = null;\n  for (let i = 0; i < cmds.length; i++) {\n    const cmd = cmds[i];\n    const kept = cullOne(cmd, m, box);\n    if (kept === cmd) {\n      out?.push(cmd);\n      continue;\n    }\n    out ??= cmds.slice(0, i);\n    if (kept) out.push(kept);\n  }\n  return out ?? cmds;\n}\n\nfunction cullOne(cmd: DrawCommand, m: GlMat3, box: Box): DrawCommand | null {\n  switch (cmd.kind) {\n    case 'group': {\n      if (cmd.effects && cmd.effects.length > 0) return cmd;\n      const inner = cmd.transform ? mat3.multiply(m, cmd.transform) : m;\n      const children = cullList(cmd.children, inner, box);\n      if (children === cmd.children) return cmd;\n      return children.length === 0 ? null : { ...cmd, children };\n    }\n    case 'path':\n      return pathMisses(cmd.path, cmd.stroke, m, box) ? null : cmd;\n    case 'image':\n      return quadMisses(cmd.x, cmd.y, cmd.x + cmd.w, cmd.y + cmd.h, m, box) ? null : cmd;\n    case 'sprites':\n      return spritesMiss(cmd.sprites, m, box) ? null : cmd;\n    default:\n      return cmd;\n  }\n}\n\nfunction pathMisses(path: Path, stroke: Stroke | undefined, m: GlMat3, box: Box): boolean {\n  let minX: number, minY: number, maxX: number, maxY: number;\n  if (path.kind === 'rect') {\n    minX = Math.min(path.x, path.x + path.width);\n    maxX = Math.max(path.x, path.x + path.width);\n    minY = Math.min(path.y, path.y + path.height);\n    maxY = Math.max(path.y, path.y + path.height);\n  } else if (path.kind === 'polygon') {\n    const c = path.coords;\n    if (c.length < 2) return false;\n    minX = maxX = c[0];\n    minY = maxY = c[1];\n    for (let i = 2; i + 1 < c.length; i += 2) {\n      const x = c[i], y = c[i + 1];\n      if (x < minX) minX = x; else if (x > maxX) maxX = x;\n      if (y < minY) minY = y; else if (y > maxY) maxY = y;\n    }\n  } else {\n    return false;\n  }\n  const reach = stroke ? strokeReach(stroke, m) : 0;\n  return quadMisses(minX - reach, minY - reach, maxX + reach, maxY + reach, m, box);\n}\n\n/** How far outside the geometry a stroke can paint, in the path's own units.\n *  A full width rather than half covers `'outer'` alignment, which the\n *  renderer draws as a doubled ribbon; the miter limit covers every join. A\n *  marker head sits on a vertex, so its reach is measured from the hull too. */\nfunction strokeReach(stroke: Stroke, m: GlMat3): number {\n  return strokeReachAt(stroke, mat3.meanScaleOf(m), mat3.minScaleOf(m));\n}\n\n/**\n * {@link strokeReach} at a known world-to-screen scale — what a painter\n * bounding its own output before it paints can know. `least` is the scale\n * along the axis the transform shrinks most, where it differs from `scale`.\n *\n * A `{ px }` ribbon or head is built to its screen size in every direction,\n * so in world it reaches farthest along that axis. A head with a world size is\n * built in world, whatever the line's width is in.\n */\nexport function strokeReachAt(stroke: Stroke, scale: number, least = scale): number {\n  const at = least > 0 ? least : scale;\n  const base = resolveStrokeWidth(stroke.width ?? 1, typeof stroke.width === 'object' ? at : scale);\n  let width = base;\n  if (stroke.vertexWidths) {\n    for (const v of stroke.vertexWidths) if (v > width) width = v;\n  }\n  const spike = Math.max(stroke.miterLimit ?? DEFAULT_MITER_LIMIT, Math.SQRT2);\n  const heads = markerReach(stroke);\n  return Math.max(Math.abs(width) * spike, heads.world, resolveScreenLength({ px: heads.px }, at));\n}\n\nfunction spritesMiss(sprites: Float32Array, m: GlMat3, box: Box): boolean {\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + SPRITE_STRIDE <= sprites.length; i += SPRITE_STRIDE) {\n    const x0 = sprites[i], y0 = sprites[i + 1];\n    const x1 = x0 + sprites[i + 2], y1 = y0 + sprites[i + 3];\n    minX = Math.min(minX, x0, x1); maxX = Math.max(maxX, x0, x1);\n    minY = Math.min(minY, y0, y1); maxY = Math.max(maxY, y0, y1);\n  }\n  if (minX === Infinity) return false;\n  return quadMisses(minX, minY, maxX, maxY, m, box);\n}\n\n/**\n * True when `bounds`, taken through `transform` to screen space, cannot put a\n * pixel inside `rect` — the per-command test above, for a caller holding a box\n * rather than a command. Same slack, same NaN-keeps rule.\n */\nexport function boundsMissRect(\n  bounds: { x: number; y: number; width: number; height: number },\n  transform: GlMat3,\n  rect: CullRect,\n): boolean {\n  const x0 = Math.min(bounds.x, bounds.x + bounds.width);\n  const x1 = Math.max(bounds.x, bounds.x + bounds.width);\n  const y0 = Math.min(bounds.y, bounds.y + bounds.height);\n  const y1 = Math.max(bounds.y, bounds.y + bounds.height);\n  return quadMisses(x0, y0, x1, y1, transform, slackBox(rect));\n}\n\nfunction slackBox(rect: CullRect): Box {\n  return {\n    minX: rect.x - SLACK_PX,\n    minY: rect.y - SLACK_PX,\n    maxX: rect.x + rect.width + SLACK_PX,\n    maxY: rect.y + rect.height + SLACK_PX,\n  };\n}\n\n/** True when the local rect, taken through `m`, lies wholly outside `box`.\n *  Any NaN makes every comparison false, so the command is kept. */\nfunction quadMisses(x0: number, y0: number, x1: number, y1: number, m: GlMat3, box: Box): boolean {\n  const [ax, ay] = mat3.apply(m, x0, y0);\n  const [bx, by] = mat3.apply(m, x1, y0);\n  const [cx, cy] = mat3.apply(m, x1, y1);\n  const [dx, dy] = mat3.apply(m, x0, y1);\n  return (\n    Math.max(ax, bx, cx, dx) < box.minX ||\n    Math.min(ax, bx, cx, dx) > box.maxX ||\n    Math.max(ay, by, cy, dy) < box.minY ||\n    Math.min(ay, by, cy, dy) > box.maxY\n  );\n}\n"],"mappings":"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"}

package/dist/renderer/draw/batch.js

@@ -1,133 +0,0 @@
-import { BATCH_TEXTURE_SLOTS as e } from "../shaders/batchFill.js";
-import { resolveColor as t } from "../math/color.js";
-import { IDENTITY_COLOR_MATRIX as n } from "../state/GroupState.js";
-import { sameValues as r } from "./uniforms.js";
-import { flushBatch as i } from "./flushBatch.js";
-import { flushForOwnDraw as a, retryUncut as o, runClipDepth as s } from "./clip.js";
-import { rampVertices as c } from "./gradient.js";
-//#region src/renderer/draw/batch.ts
-function l(e) {
-	return e === n || r(n, e);
-}
-function u(e, t, n, i, a = 0) {
-	if (t.clipDepth !== (e.clipStack.length === 0 ? e.clipDepth : s(e)) || t.synthBold !== a || !t.foldsAlpha && t.alpha !== e.state.alpha || n !== void 0 && d(t, n, i) < 0) return !1;
-	let o = e.state.colorMatrix;
-	return t.colorMatrix === o || r(t.colorMatrix, o);
-}
-function d(e, t, n) {
-	for (let r = 0; r < e.textures.length; r++) {
-		let i = e.textures[r];
-		if (i.kind === "bitmap" && i.image === t) return i.sampling === n ? r + 1 : -1;
-	}
-	return m(e);
-}
-function f(e) {
-	for (let t = 0; t < e.textures.length; t++) if (e.textures[t].kind === "ramps") return t + 1;
-	return m(e);
-}
-function p(e, t) {
-	for (let n = 0; n < e.textures.length; n++) {
-		let r = e.textures[n];
-		if (r.kind === "atlas" && r.id === t) return n + 1;
-	}
-	return m(e);
-}
-function m(t) {
-	return t.textures.length + 1 < e ? t.textures.length + 1 : -1;
-}
-var h = {
-	maxVertices: 96,
-	maxVerticesInRun: 1024
-};
-function g(e, t) {
-	if (t.requiresStencil) return !1;
-	let n = e.drawBatch.length > 0 ? h.maxVerticesInRun : h.maxVertices;
-	return t.vertices.length >> 1 <= n;
-}
-function _(e, t) {
-	return e.batchState !== void 0 && !u(e, e.batchState) && i(e), e.drawBatch.wouldOverflow(t) && i(e), v(e);
-}
-function v(e) {
-	if (e.batchState === void 0) {
-		let t = e.state.colorMatrix, n = l(t);
-		e.batchState = {
-			alpha: n ? 1 : e.state.alpha,
-			colorMatrix: t,
-			clipDepth: s(e),
-			synthBold: 0,
-			foldsAlpha: n,
-			textures: []
-		};
-	}
-	return e.batchState;
-}
-function y(e, t, n) {
-	e.batchState !== void 0 && !u(e, e.batchState, t, n) && i(e), e.drawBatch.wouldOverflow(4) && i(e);
-	let r = v(e), a = d(r, t, n);
-	return a > r.textures.length && (r.textures.push({
-		kind: "bitmap",
-		image: t,
-		sampling: n
-	}), a = r.textures.length), {
-		staged: r,
-		slot: a
-	};
-}
-function b(e, t, n, r) {
-	e.batchState !== void 0 && (!u(e, e.batchState, void 0, void 0, r) || p(e.batchState, t) < 0) && i(e), e.drawBatch.wouldOverflow(4) && i(e);
-	let a = v(e);
-	a.synthBold = r;
-	let o = p(a, t);
-	return o > a.textures.length && (a.textures.push({
-		kind: "atlas",
-		id: t,
-		fieldScale: n
-	}), o = a.textures.length), {
-		staged: a,
-		slot: o
-	};
-}
-function x(e, t, n, r) {
-	e.gradRamps.wouldReshape(t, n) && i(e), e.batchState !== void 0 && (!u(e, e.batchState) || f(e.batchState) < 0) && i(e), e.drawBatch.wouldOverflow(r) && i(e);
-	let a = v(e), o = f(a);
-	return o > a.textures.length && (a.textures.push({ kind: "ramps" }), o = a.textures.length), {
-		staged: a,
-		slot: o,
-		rowV: e.gradRamps.rowV(e.gradRamps.upload(t, n))
-	};
-}
-function S(e, t, n) {
-	return (n ?? 1) * (t.foldsAlpha ? e.state.alpha : 1);
-}
-function C(e, n, r) {
-	let [i, a, o, s] = t(r.color);
-	return [
-		i,
-		a,
-		o,
-		s * S(e, n, r.opacity)
-	];
-}
-function w(e, t, n) {
-	let [r, i, a, s] = C(e, _(e, 4), n);
-	e.drawBatch.pushRect(t.x, t.y, t.width, t.height, e.state.transform, r, i, a, s) || o(e, t, n, w);
-}
-function T(e, t, n) {
-	let [r, i, a, s] = C(e, _(e, t.vertices.length >> 1), n);
-	e.drawBatch.pushMesh(t, e.state.transform, r, i, a, s) || o(e, t, n, T);
-}
-function E(e, t, n) {
-	let { staged: r, slot: i, rowV: a } = x(e, n.stops, n.space, 4), { uv: s, post: l } = c(n, a);
-	e.drawBatch.pushGradientRect(t.x, t.y, t.width, t.height, e.state.transform, s, l, i, n.mode, 1, 1, 1, S(e, r, n.opacity)) || o(e, t, n, E);
-}
-function D(e, t, n) {
-	let { staged: r, slot: i, rowV: a } = x(e, n.stops, n.space, t.vertices.length >> 1), { uv: s, post: l } = c(n, a);
-	e.drawBatch.pushGradientMesh(t, e.state.transform, s, l, i, n.mode, 1, 1, 1, S(e, r, n.opacity)) || o(e, t, n, D);
-}
-function O(e, t, n) {
-	return n !== void 0 && g(e, t) ? (n.kind === "ramp" ? D(e, t, n) : T(e, t, n), !0) : (a(e), !1);
-}
-//#endregion
-export { h as meshBatching, E as pushRampRect, w as pushRect, b as stageGlyphs, y as stageImage, _ as stageSolid, O as tryStageFill };
-
-//# sourceMappingURL=batch.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"batch.js","names":["isIdentityColorMatrix","cm","IDENTITY_COLOR_MATRIX","sameValues","stagedStateIsLive","staged","ctx","runClipDepth","synthBold","image","slotForBitmap","sampling","colorMatrix","i","entry","nextFreeSlot","slotForRamps","slotForAtlas","id","BATCH_TEXTURE_SLOTS","meshBatching","canBatchMesh","mesh","cap","stageSolid","flushBatch","vertices","openRun","foldsAlpha","stageImage","slot","stageGlyphs","atlasId","stageRamps","stops","space","stagedAlpha","opacity","stagedColor","r","g","b","a","resolveColor","paint","pushRect","fill","rect","retryUncut","pushMesh","pushRampRect","rampVertices","rowV","uv","post","pushRampMesh","tryStageFill","flushForOwnDraw"],"sources":["../../../src/renderer/draw/batch.ts"],"sourcesContent":["import type { ColorSpace, GradStop } from '@weasel-js/paint';\nimport { IDENTITY_COLOR_MATRIX } from '../state/GroupState';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport { resolveColor } from '../math/color';\nimport { BATCH_TEXTURE_SLOTS } from '../shaders/batchFill';\nimport type { DrawContext } from './drawContext';\nimport { sameValues } from './uniforms';\nimport { runClipDepth, retryUncut, flushForOwnDraw } from './clip';\nimport { flushBatch } from './flushBatch';\nimport { type BatchPaint, rampVertices } from './gradient';\n\n/**\n * The group state a staged run was built under.\n *\n * A run outlives the group it started in, so the state live when the flush\n * happens is not the state the rects belong to — the flush draws with these\n * values instead. Transform is absent because it rides the vertices; `alpha`\n * is 1 whenever it rode them too.\n */\nexport interface StagedBatchState {\n  alpha: number;\n  colorMatrix: Float32Array;\n  clipDepth: number;\n  /**\n   * The SDF threshold shift `u_synthBold` draws this run under.\n   *\n   * A uniform rather than a vertex attribute, and so a thing that breaks a run.\n   * A per-vertex float costs every rect and quad in the run (see \"Mode and slot\n   * share one attribute\" in `shaders/batchFill.ts`): the batch's whole point is\n   * one cheap buffer write a frame, and a float only glyphs read still widens the write\n   * for every rect and quad beside them. What it costs instead is a break\n   * wherever faked-bold text meets text that is not, which is a fallback path:\n   * a registered bold face never sets this at all.\n   */\n  synthBold: number;\n  /** Whether group alpha folded into the vertex colors. */\n  foldsAlpha: boolean;\n  /**\n   * The textures this run samples, in the order they joined. A quad's vertices\n   * carry `index + 1`, because slot 0 is the white texel every solid samples.\n   *\n   * Two kinds, because two caches own them: an image quad names an\n   * `ImageBitmap` that `GLImageCache` keys by identity, a glyph names the\n   * string id of a font atlas in `GLTextureCache`. They share the slot list so\n   * a caption and the thumbnail above it share a draw.\n   *\n   * A bitmap's `sampling` is per entry and set per flush rather than at upload:\n   * MAG_FILTER is state on the texture object, so the same bitmap drawn at both\n   * filters in one frame needs two flushes, not two slots. An atlas carries no\n   * sampling because `GLTextureCache` owns its filtering — and must keep\n   * owning it: filtering a distance field destroys it, so a font atlas is\n   * never mipmapped and never joins a shared image atlas.\n   */\n  textures: BatchTexture[];\n}\n\n/** One entry in a run's slot list. */\ntype BatchTexture =\n  | { kind: 'bitmap'; image: ImageBitmap; sampling: 'linear' | 'nearest' }\n  | { kind: 'atlas'; id: string; fieldScale: readonly [number, number] }\n  | { kind: 'ramps' };\n\n/** Identity in row-major 4×5 leaves `src` untouched *and* leaves the shader's\n *  clamp with nothing to do, which is what makes the alpha fold exact. */\nfunction isIdentityColorMatrix(cm: Float32Array): boolean {\n  return cm === IDENTITY_COLOR_MATRIX || sameValues(IDENTITY_COLOR_MATRIX, cm);\n}\n\n/**\n * Whether the live group state would draw the staged run identically.\n *\n * By value, not by reference: a group carrying an identity color matrix still\n * goes through `compose4x5`, which allocates a new array holding equal numbers.\n * Twenty float compares are nothing against the draw call they save.\n */\nfunction stagedStateIsLive(\n  ctx: DrawContext, staged: StagedBatchState,\n  image?: ImageBitmap, sampling?: 'linear' | 'nearest',\n  synthBold = 0,\n): boolean {\n  if (staged.clipDepth !== (ctx.clipStack.length === 0 ? ctx.clipDepth : runClipDepth(ctx))) return false;\n  // Solids and image quads ask with 0, which is what a run of them carries, so\n  // this only ever breaks between two kinds of glyph.\n  if (staged.synthBold !== synthBold) return false;\n  if (!staged.foldsAlpha && staged.alpha !== ctx.state.alpha) return false;\n  if (image !== undefined && slotForBitmap(staged, image, sampling!) < 0) return false;\n  const colorMatrix = ctx.state.colorMatrix;\n  return staged.colorMatrix === colorMatrix || sameValues(staged.colorMatrix, colorMatrix);\n}\n\n/**\n * The slot `image` would sample from in this run, or -1 if it cannot join.\n *\n * A bitmap already in the run reuses its slot — but only at the filter it went\n * in under, since MAG_FILTER belongs to the texture object and one draw cannot\n * have it both ways. Otherwise it takes the next free slot, and a run with none\n * left is a run this quad has to break.\n */\nfunction slotForBitmap(\n  staged: StagedBatchState, image: ImageBitmap, sampling: 'linear' | 'nearest',\n): number {\n  for (let i = 0; i < staged.textures.length; i++) {\n    const entry = staged.textures[i];\n    if (entry.kind !== 'bitmap' || entry.image !== image) continue;\n    return entry.sampling === sampling ? i + 1 : -1;\n  }\n  return nextFreeSlot(staged);\n}\n\n/** The same for the ramp atlas, of which there is one — so every gradient in a\n *  run shares the slot, however many distinct ramps they are. */\nfunction slotForRamps(staged: StagedBatchState): number {\n  for (let i = 0; i < staged.textures.length; i++) {\n    if (staged.textures[i].kind === 'ramps') return i + 1;\n  }\n  return nextFreeSlot(staged);\n}\n\n/** The same for a font atlas, which has no filter to disagree about. */\nfunction slotForAtlas(staged: StagedBatchState, id: string): number {\n  for (let i = 0; i < staged.textures.length; i++) {\n    const entry = staged.textures[i];\n    if (entry.kind === 'atlas' && entry.id === id) return i + 1;\n  }\n  return nextFreeSlot(staged);\n}\n\n/** The slot a texture new to this run would take, or -1 if it is full. */\nfunction nextFreeSlot(staged: StagedBatchState): number {\n  return staged.textures.length + 1 < BATCH_TEXTURE_SLOTS ? staged.textures.length + 1 : -1;\n}\n\n/**\n * Vertices above which a mesh keeps its own draw, by whether a run is open.\n *\n * Batching trades a draw call for copying and re-uploading the mesh every\n * frame, where a mesh already in the persistent cache costs nothing per frame\n * beyond the draw. Drawn alone with a run open, a mesh also closes that run and\n * switches program twice, so it breaks even far later there. Both values sit\n * below what `tests/perf/mesh-batch.spec.ts` measured, recorded in\n * `docs/TODO.md`: being wrong on the open-run side costs ten times more.\n */\nconst MAX_BATCHED_MESH_VERTICES = 96;\n\nconst MAX_BATCHED_MESH_VERTICES_IN_RUN = 1024;\n\n/** The caps {@link canBatchMesh} reads. Mutable only so `mesh-batch.spec.ts`\n *  can time both sides of them in one page; the barrel does not export it. */\nexport const meshBatching = {\n  maxVertices: MAX_BATCHED_MESH_VERTICES,\n  maxVerticesInRun: MAX_BATCHED_MESH_VERTICES_IN_RUN,\n};\n\n/** Whether a mesh can join a run. Stencil fills need their own two-pass dance,\n *  and a mesh past the cap is cheaper as its own draw. */\nfunction canBatchMesh(ctx: DrawContext, mesh: Mesh): boolean {\n  if (mesh.requiresStencil) return false;\n  const cap = ctx.drawBatch.length > 0 ? meshBatching.maxVerticesInRun : meshBatching.maxVertices;\n  return (mesh.vertices.length >> 1) <= cap;\n}\n\n/**\n * Open or continue a run for `vertices` more, flushing first if the run would\n * overflow or if the live group state no longer matches what it was staged\n * under. Returns the staged state, which the caller reads to resolve alpha.\n *\n * Fill opacity folds into the vertex alpha, exactly as `u_color` carried it\n * when each shape was its own draw. Group alpha folds in too, but only under an\n * identity color matrix: the shader is `a = clamp(CM * src + bias).a * u_alpha`,\n * so with a real matrix between them a pre-multiplied vertex alpha is a\n * different number. There it stays a uniform, and a differing alpha breaks the\n * run as before.\n */\nexport function stageSolid(ctx: DrawContext, vertices: number): StagedBatchState {\n  if (ctx.batchState !== undefined && !stagedStateIsLive(ctx, ctx.batchState)) flushBatch(ctx);\n  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);\n  return openRun(ctx);\n}\n\n/** The staged state, opening a run under the live group state if none is. */\nfunction openRun(ctx: DrawContext): StagedBatchState {\n  if (ctx.batchState === undefined) {\n    const colorMatrix = ctx.state.colorMatrix;\n    const foldsAlpha = isIdentityColorMatrix(colorMatrix);\n    ctx.batchState = {\n      alpha: foldsAlpha ? 1 : ctx.state.alpha,\n      colorMatrix,\n      clipDepth: runClipDepth(ctx),\n      synthBold: 0,\n      foldsAlpha,\n      textures: [],\n    };\n  }\n  return ctx.batchState;\n}\n\n/**\n * Open or continue a run for one more image quad, flushing first if the run\n * would overflow or cannot give this bitmap a slot.\n *\n * A run adopts a bitmap it has not seen rather than breaking, which is what\n * lets a wall's ground rect and its atlas quad share a draw, and what lets a\n * cell's art and its badge share one too. Returns the staged state and the slot\n * the quad's vertices must carry.\n */\nexport function stageImage(\n  ctx: DrawContext, image: ImageBitmap, sampling: 'linear' | 'nearest',\n): { staged: StagedBatchState; slot: number } {\n  if (ctx.batchState !== undefined\n      && !stagedStateIsLive(ctx, ctx.batchState, image, sampling)) {\n    flushBatch(ctx);\n  }\n  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);\n  const staged = openRun(ctx);\n  let slot = slotForBitmap(staged, image, sampling);\n  if (slot > staged.textures.length) {\n    staged.textures.push({ kind: 'bitmap', image, sampling });\n    slot = staged.textures.length;\n  }\n  return { staged, slot };\n}\n\n/**\n * Open or continue a run for a glyph off the font atlas `atlasId`, flushing\n * first if the run would overflow or has no slot left for it.\n *\n * The atlas is the unit of coalescing the way a sprite sheet is: every glyph a\n * face contributes to a frame shares one texture, so a paragraph is one run\n * however many glyphs it is, and a second face costs one more slot rather than\n * a flush per word.\n */\nexport function stageGlyphs(\n  ctx: DrawContext, atlasId: string, fieldScale: readonly [number, number], synthBold: number,\n): { staged: StagedBatchState; slot: number } {\n  if (ctx.batchState !== undefined\n      && (!stagedStateIsLive(ctx, ctx.batchState, undefined, undefined, synthBold)\n          || slotForAtlas(ctx.batchState, atlasId) < 0)) {\n    flushBatch(ctx);\n  }\n  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);\n  const staged = openRun(ctx);\n  // An empty run adopts the threshold; one that already has vertices agreed to\n  // it above, since a mismatch flushed.\n  staged.synthBold = synthBold;\n  let slot = slotForAtlas(staged, atlasId);\n  if (slot > staged.textures.length) {\n    staged.textures.push({ kind: 'atlas', id: atlasId, fieldScale });\n    slot = staged.textures.length;\n  }\n  return { staged, slot };\n}\n\n/**\n * Open or continue a run for geometry filled from the ramp atlas, flushing\n * first if the run would overflow, has no slot left, or if baking `stops` would\n * move the rows already staged.\n *\n * **That last one is the trap.** A staged vertex names its ramp by where the\n * row sits, so growing the atlas — which changes every row's `v` — or recycling\n * a row repaints geometry already staged with somebody else's gradient. Both\n * are irreversible once done, so the question is asked before the bake, not\n * after.\n */\nfunction stageRamps(\n  ctx: DrawContext, stops: GradStop[], space: ColorSpace, vertices: number,\n): { staged: StagedBatchState; slot: number; rowV: number } {\n  if (ctx.gradRamps.wouldReshape(stops, space)) flushBatch(ctx);\n  if (ctx.batchState !== undefined\n      && (!stagedStateIsLive(ctx, ctx.batchState) || slotForRamps(ctx.batchState) < 0)) {\n    flushBatch(ctx);\n  }\n  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);\n  const staged = openRun(ctx);\n  let slot = slotForRamps(staged);\n  if (slot > staged.textures.length) {\n    staged.textures.push({ kind: 'ramps' });\n    slot = staged.textures.length;\n  }\n  return { staged, slot, rowV: ctx.gradRamps.rowV(ctx.gradRamps.upload(stops, space)) };\n}\n\n/** Alpha a batched paint's vertices carry: its own opacity, and the group's\n *  under an identity color matrix. */\nfunction stagedAlpha(\n  ctx: DrawContext, staged: StagedBatchState, opacity: number | undefined,\n): number {\n  return (opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1);\n}\n\n/** Straight-alpha rgba for a solid paint under the staged state. */\nfunction stagedColor(\n  ctx: DrawContext, staged: StagedBatchState,\n  paint: { color: string; opacity?: number },\n): [number, number, number, number] {\n  const [r, g, b, a] = resolveColor(paint.color);\n  return [r, g, b, a * stagedAlpha(ctx, staged, paint.opacity)];\n}\n\nexport function pushRect(\n  ctx: DrawContext,\n  rect: { x: number; y: number; width: number; height: number },\n  fill: { color: string; opacity?: number },\n): void {\n  const staged = stageSolid(ctx, 4);\n  const [r, g, b, a] = stagedColor(ctx, staged, fill);\n  if (!ctx.drawBatch.pushRect(\n    rect.x, rect.y, rect.width, rect.height, ctx.state.transform, r, g, b, a,\n  )) retryUncut(ctx, rect, fill, pushRect);\n}\n\nfunction pushMesh(\n  ctx: DrawContext,\n  mesh: Mesh,\n  paint: { color: string; opacity?: number },\n): void {\n  const staged = stageSolid(ctx, mesh.vertices.length >> 1);\n  const [r, g, b, a] = stagedColor(ctx, staged, paint);\n  if (!ctx.drawBatch.pushMesh(mesh, ctx.state.transform, r, g, b, a)) {\n    retryUncut(ctx, mesh, paint, pushMesh);\n  }\n}\n\nexport function pushRampRect(\n  ctx: DrawContext,\n  rect: { x: number; y: number; width: number; height: number },\n  paint: Extract<BatchPaint, { kind: 'ramp' }>,\n): void {\n  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, paint.space, 4);\n  const { uv, post } = rampVertices(paint, rowV);\n  // White vertices, so the ramp texel passes through as its own color and the\n  // alpha channel carries what `u_opacity` and `u_alpha` used to.\n  if (!ctx.drawBatch.pushGradientRect(\n    rect.x, rect.y, rect.width, rect.height, ctx.state.transform,\n    uv, post, slot, paint.mode, 1, 1, 1, stagedAlpha(ctx, staged, paint.opacity),\n  )) retryUncut(ctx, rect, paint, pushRampRect);\n}\n\nfunction pushRampMesh(\n  ctx: DrawContext, mesh: Mesh, paint: Extract<BatchPaint, { kind: 'ramp' }>,\n): void {\n  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, paint.space, mesh.vertices.length >> 1);\n  const { uv, post } = rampVertices(paint, rowV);\n  if (!ctx.drawBatch.pushGradientMesh(\n    mesh, ctx.state.transform,\n    uv, post, slot, paint.mode, 1, 1, 1, stagedAlpha(ctx, staged, paint.opacity),\n  )) retryUncut(ctx, mesh, paint, pushRampMesh);\n}\n\n/**\n * Stage `mesh` into the run, or drain the run so the caller can draw it itself.\n *\n * `true` means the mesh is in the batch and the caller is done. `false` comes\n * back only *after* a flush, so an emitter cannot earn permission to draw for\n * itself without also draining the batch. `paint` is `undefined` when it is one\n * no run can express — see `batchPaint`.\n */\nexport function tryStageFill(\n  ctx: DrawContext,\n  mesh: Mesh,\n  paint: BatchPaint | undefined,\n): boolean {\n  if (paint !== undefined && canBatchMesh(ctx, mesh)) {\n    if (paint.kind === 'ramp') pushRampMesh(ctx, mesh, paint);\n    else pushMesh(ctx, mesh, paint);\n    return true;\n  }\n  flushForOwnDraw(ctx);\n  return false;\n}\n"],"mappings":"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"}

package/dist/renderer/draw/clip.js

@@ -1,89 +0,0 @@
-import { drawTriangles as e } from "./drawTriangles.js";
-import { ancestorMask as t } from "./stencil.js";
-import { setProjAndModel as n } from "./uniforms.js";
-import { axisAlignedClipRect as r, intersectClipRects as i } from "../batchClip.js";
-import { fillMeshHandle as a } from "./mesh.js";
-import { flushBatch as o } from "./flushBatch.js";
-//#region src/renderer/draw/clip.ts
-function s(e, t) {
-	let n = e.clipStack.reduce((e, t) => e + +(t.depth === 0), 0);
-	if (e.clipDepth + n + 1 > 7) throw Error("weasel: clip nesting depth exceeded (max 7). You can't nest more than 7 levels of clipped containers in a single draw tree. Flatten the hierarchy or compose poses outside the scene graph.");
-	c(e, t);
-}
-function c(e, t) {
-	let n = e.state.transform, i = r(t, n);
-	if (i === null) {
-		u(e);
-		let r = e.clipDepth + 1;
-		v(e, t, r), e.clipDepth = r, e.clipStack.push({
-			path: t,
-			transform: n,
-			rect: null,
-			depth: r
-		});
-	} else e.clipStack.push({
-		path: t,
-		transform: n,
-		rect: i,
-		depth: 0
-	});
-	d(e);
-}
-function l(e) {
-	let t = e.clipStack.pop();
-	t.depth > 0 && (y(e, t.path, t.depth - 1, t.transform), e.clipDepth = t.depth - 1), d(e);
-}
-function u(e) {
-	for (let t of e.clipStack) {
-		if (t.depth !== 0) continue;
-		let n = e.clipDepth + 1;
-		v(e, t.path, n, t.transform), t.depth = n, e.clipDepth = n;
-	}
-}
-function d(e) {
-	let t = null;
-	for (let n of e.clipStack) n.rect && (t = t ? i(t, n.rect) : n.rect);
-	e.drawBatch.clip = t;
-}
-function f(e) {
-	let t = e.clipStack;
-	if (t.length === 0 || e.uncut) return e.clipDepth;
-	for (let e = t.length - 1; e >= 0; e--) if (t[e].rect === null) return t[e].depth;
-	for (let e of t) if (e.depth > 0) return e.depth - 1;
-	return e.clipDepth;
-}
-function p(e) {
-	u(e);
-	let t = e.drawBatch.clip;
-	return e.drawBatch.clip = null, e.uncut = !0, t;
-}
-function m(e, t) {
-	e.drawBatch.clip = t, e.uncut = !1;
-}
-function h(e, t, n, r) {
-	let i = p(e);
-	r(e, t, n), m(e, i);
-}
-function g(e) {
-	o(e), e.clipStack.length > 0 && u(e);
-}
-function _(t, r, i) {
-	let o = t.gl, s = a(t, r);
-	o.useProgram(t.pathFill.handle), o.bindVertexArray(s.vao), n(t, t.pathFill, i), e(t, s.indexCount, t.gl.UNSIGNED_INT), o.bindVertexArray(null);
-}
-function v(e, n, r, i = e.state.transform) {
-	o(e);
-	let s = e.gl, c = t(r - 1), l = 1 << r, u = c | l;
-	s.enable(s.STENCIL_TEST), s.colorMask(!1, !1, !1, !1), a(e, n).requiresStencil ? (s.stencilMask(1), s.stencilFunc(s.ALWAYS, 0, 1), s.stencilOp(s.KEEP, s.KEEP, s.INVERT), _(e, n, i), s.stencilMask(l), s.stencilFunc(s.EQUAL, u | 1, c | 1), s.stencilOp(s.KEEP, s.KEEP, s.REPLACE), _(e, n, i), s.stencilMask(1), s.stencilFunc(s.ALWAYS, 0, 1), s.stencilOp(s.KEEP, s.KEEP, s.INVERT), _(e, n, i)) : (s.stencilMask(l), s.stencilFunc(s.EQUAL, u, c), s.stencilOp(s.KEEP, s.KEEP, s.REPLACE), _(e, n, i)), s.colorMask(!0, !0, !0, !0), s.stencilMask(255);
-}
-function y(e, n, r, i = e.state.transform) {
-	e.batchState !== void 0 && e.batchState.clipDepth > r && o(e);
-	let a = e.gl;
-	a.enable(a.STENCIL_TEST);
-	let s = 1 << r + 1, c = t(r) | s;
-	a.colorMask(!1, !1, !1, !1), a.stencilMask(s), a.stencilFunc(a.EQUAL, c, c), a.stencilOp(a.KEEP, a.KEEP, a.ZERO), _(e, n, i), a.colorMask(!0, !0, !0, !0), a.stencilMask(255);
-}
-//#endregion
-export { s as enterGroupClip, p as enterUncut, g as flushForOwnDraw, l as leaveClip, m as leaveUncut, y as popClip, v as pushClip, h as retryUncut, f as runClipDepth };
-
-//# sourceMappingURL=clip.js.map