@weasel-js/core 1.9.3 → 1.10.0

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/core';\nimport type { FillStyle, MarkerRef, Stroke } 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: FillStyle | undefined;\n  cmds: PathDrawCommand[];\n}\n\nlet byValue = new WeakMap<Path, Map<string, Entry>>();\nlet byStroke = new WeakMap<Path, WeakMap<Stroke, 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: Stroke): 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: Stroke, 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: Stroke,\n  stroke: Stroke,\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,QAAmD,GAEhEC,KAAU,MACdC,MAAQ,KAAA,IAAY,KAAK,OAAOA,KAAQ,WAAWA,IAAM,GAAGA,EAAI,IAAI,GAAG,OAAOA,EAAI,QAAQ,EAAE;AAG9F,SAASC,EAAS,GAA+B;CAC/C,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,GAAgB,GAA0C;CACpF,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/core';\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 { SPRITE_STRIDE as t } from "./DrawCommand.js";
-import { resolveStrokeWidth as n } from "../features/paths/tessellate/stroke.js";
-import { markerReach as r } from "../features/paths/markerCommands.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, t, a = t) {
-	let s = a > 0 ? a : t, c = n(e.width ?? 1, typeof e.width == "object" ? s : t);
-	if (e.vertexWidths) for (let t of e.vertexWidths) t > c && (c = t);
-	let l = Math.max(e.miterLimit ?? o, Math.SQRT2), u = r(e);
-	return Math.max(Math.abs(c) * l, u.world, i({ px: u.px }, s));
-}
-function p(e, n, r) {
-	let i = Infinity, a = Infinity, o = -Infinity, s = -Infinity;
-	for (let n = 0; n + t <= e.length; n += t) {
-		let t = e[n], r = e[n + 1], c = t + e[n + 2], l = r + e[n + 3];
-		i = Math.min(i, t, c), o = Math.max(o, t, c), a = Math.min(a, r, l), s = Math.max(s, r, l);
-	}
-	return i !== Infinity && g(i, a, o, s, n, r);
-}
-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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"}