@weasel-js/renderer 0.0.0-stage → 1.10.0

package/dist/chunk-LFD47OV2.js

@@ -0,0 +1,1487 @@
+import { ownTextureIds, rasterizeTile, drawTileShapes, tileGeometry, tileSize, registerTextureAs, textureRegistry, unregisterTexture } from './chunk-Q4SIHV7Q.js';
+import { defaultOpenFill, pathFromD, boundsOfPath } from '@weasel-js/geom';
+import { tessellate } from '@weasel-js/geom/tessellate';
+import { createReflectable, createEmitter } from '@weasel-js/registry';
+import { resolveStrokeWidth, strokeInsets, tessellateStroke, markerGeneration, screenSpaceKey, markerHeads, metricKey, getMarker, markerKeyOf, markerReadsKey } from '@weasel-js/stroke';
+import { isTileKind, isPatternPaint, tileSpecOf, isTilePaint, patternPlacementOf } from '@weasel-js/paint';
+import { GLYPH_COVERAGE_GLSL } from '@weasel-js/font';
+
+// src/cache/uploadPremultiplied.ts
+function uploadPremultiplied(gl, source) {
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+}
+
+// src/cache/GLImageCache.ts
+var DEFAULT_MAX_TEXTURE_SIDE = 4096;
+var live = /* @__PURE__ */ new Set();
+function releaseImageSource(key) {
+  for (const cache7 of live) cache7.release(key);
+}
+function imageSourceInLatestFrame(key) {
+  for (const cache7 of live) if (cache7.drewInLatestFrame(key)) return true;
+  return false;
+}
+function maxImageTextureSide() {
+  let side = Infinity;
+  for (const cache7 of live) side = Math.min(side, cache7.maxTextureSide);
+  return Number.isFinite(side) ? side : DEFAULT_MAX_TEXTURE_SIDE;
+}
+var GLImageCache = class {
+  /** `minification` selects the MIN_FILTER strategy for uploaded textures.
+   *  `'mipmap'` generates mipmaps and filters LINEAR_MIPMAP_LINEAR: when a
+   *  large source bitmap is drawn small, bilinear-only minification
+   *  undersamples and produces moiré. `'auto'` pays for that only on the
+   *  textures a frame draws small, when it first does. */
+  constructor(gl, minification = "linear") {
+    this.gl = gl;
+    this.minification = minification;
+    const reported = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+    this.maxTextureSide = typeof reported === "number" && reported > 0 ? reported : DEFAULT_MAX_TEXTURE_SIDE;
+    this.finalizer = new FinalizationRegistry((tex) => {
+      if (this.textures.delete(tex)) this.pendingDeletes.push(tex);
+    });
+    live.add(this);
+  }
+  gl;
+  minification;
+  /** This context's `MAX_TEXTURE_SIZE`. */
+  maxTextureSide;
+  map = /* @__PURE__ */ new WeakMap();
+  /** Every texture `map` holds, so `dispose` can reach them — a WeakMap
+   *  cannot be enumerated. */
+  textures = /* @__PURE__ */ new Set();
+  /**
+   * MAG_FILTER each texture currently carries, so a redundant write can be
+   * skipped. The batch sets this per flush — the same bitmap can be drawn at
+   * both filters in one frame — but filtering is state on the *texture
+   * object*, not on the unit, so re-asserting a value it already has is a
+   * write to a live texture for no reason.
+   */
+  magFilters = /* @__PURE__ */ new WeakMap();
+  finalizer;
+  pendingDeletes = [];
+  /** Under `'auto'`, the sources whose mipmaps are built. */
+  mipped = /* @__PURE__ */ new WeakSet();
+  frame = 0;
+  lastDrawn = /* @__PURE__ */ new WeakMap();
+  /** Open a frame: what {@link drewInLatestFrame} answers about from here on.
+   *  The renderer calls this at the top of each `render()`. */
+  beginFrame() {
+    this.frame++;
+    this.drainPendingDeletes();
+  }
+  /** Whether `key` was uploaded or bound since the last {@link beginFrame}. */
+  drewInLatestFrame(key) {
+    return this.lastDrawn.get(key) === this.frame;
+  }
+  /** Delete the textures of sources collected since the last call. */
+  drainPendingDeletes() {
+    if (this.pendingDeletes.length === 0) return;
+    for (const tex of this.pendingDeletes) this.gl.deleteTexture(tex);
+    this.pendingDeletes.length = 0;
+  }
+  /** Delete `key`'s texture, if it has one. */
+  release(key) {
+    const tex = this.map.get(key);
+    if (!tex) return;
+    this.gl.deleteTexture(tex);
+    this.textures.delete(tex);
+    this.finalizer.unregister(key);
+    this.map.delete(key);
+    this.magFilters.delete(key);
+    this.lastDrawn.delete(key);
+    this.mipped.delete(key);
+  }
+  /** Delete every texture this cache uploaded and stop answering
+   *  {@link releaseImageSource} and {@link maxImageTextureSide}. Idempotent. */
+  dispose() {
+    for (const tex of this.textures) this.gl.deleteTexture(tex);
+    this.drainPendingDeletes();
+    this.abandon();
+  }
+  /** {@link dispose} without the deletes, for a cache whose context was lost:
+   *  its textures died with it. */
+  abandon() {
+    this.textures.clear();
+    this.pendingDeletes.length = 0;
+    live.delete(this);
+  }
+  upload(key, source, repetition) {
+    this.lastDrawn.set(key, this.frame);
+    const existing = this.map.get(key);
+    if (existing) return existing;
+    const gl = this.gl;
+    const tex = gl.createTexture();
+    if (!tex) throw new Error("GLImageCache: createTexture failed");
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    uploadPremultiplied(gl, source);
+    gl.texParameteri(
+      gl.TEXTURE_2D,
+      gl.TEXTURE_MIN_FILTER,
+      this.minification === "mipmap" ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    this.magFilters.set(key, gl.LINEAR);
+    const [wrapS, wrapT] = wrapModes(gl, repetition);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapS);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapT);
+    if (this.minification === "mipmap") gl.generateMipmap(gl.TEXTURE_2D);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    this.map.set(key, tex);
+    this.textures.add(tex);
+    this.finalizer.register(key, tex, key);
+    return tex;
+  }
+  /** Whether `key` would gain from {@link buildMipmaps}: only under `'auto'`,
+   *  and only until they are built. */
+  lacksMipmaps(key) {
+    return this.minification === "auto" && !this.mipped.has(key);
+  }
+  /** Build `key`'s mipmaps and filter minification through them from here
+   *  on. Its texture must be uploaded. Leaves no texture bound. */
+  buildMipmaps(key) {
+    const tex = this.map.get(key);
+    if (!tex || this.mipped.has(key)) return;
+    const gl = this.gl;
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.generateMipmap(gl.TEXTURE_2D);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    this.mipped.add(key);
+  }
+  bind(key, unit) {
+    const tex = this.map.get(key);
+    if (!tex) throw new Error("GLImageCache: image not uploaded; call upload() first");
+    this.lastDrawn.set(key, this.frame);
+    const gl = this.gl;
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+  }
+  /** Set `key`'s MAG_FILTER, skipping the call when it already holds that
+   *  value. Its texture must be bound to the active unit — callers pair this
+   *  with `bind`. */
+  setMagFilter(key, filter) {
+    if (this.magFilters.get(key) === filter) return;
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, filter);
+    this.magFilters.set(key, filter);
+  }
+};
+function wrapModes(gl, rep) {
+  switch (rep) {
+    case "repeat":
+      return [gl.REPEAT, gl.REPEAT];
+    case "repeat-x":
+      return [gl.REPEAT, gl.CLAMP_TO_EDGE];
+    case "repeat-y":
+      return [gl.CLAMP_TO_EDGE, gl.REPEAT];
+    default:
+      return [gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE];
+  }
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function getMesh(path) {
+  const openFill = defaultOpenFill();
+  const cached = cache.get(path);
+  if (cached !== void 0 && cached.openFill === openFill) return cached.mesh;
+  const mesh = tessellate(path);
+  cache.set(path, { mesh, openFill });
+  return mesh;
+}
+function _resetCacheForTests() {
+  cache = /* @__PURE__ */ new WeakMap();
+}
+var registry = createReflectable();
+var programSourceRegistry = registry.reflection;
+function _resetProgramRegistryForTests() {
+  registry.clear();
+}
+function getProgramSource(id) {
+  return registry.get(id) ?? null;
+}
+var isDev = () => typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+function registerProgram(id, vert, frag) {
+  if (registry.has(id) && !isDev()) {
+    throw new Error(`weasel registerProgram: duplicate program id "${id}". In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);
+  }
+  registry.set(id, { vert, frag });
+  return { id };
+}
+var KINDS = createReflectable();
+var paintDrawKindRegistry = KINDS.reflection;
+function registerPaintDrawKind(entry) {
+  if (entry.inPoseFrame === void 0 !== (entry.toBoundsFrame === void 0)) {
+    const missing = entry.inPoseFrame === void 0 ? "inPoseFrame" : "toBoundsFrame";
+    throw new Error(
+      `weasel registerPaintKind: kind "${entry.id}" is missing ${missing}. A kind that converts one frame direction and not the other drifts on the next resize; supply both or neither.`
+    );
+  }
+  for (const [id, src] of Object.entries(entry.programs ?? {})) {
+    const have = getProgramSource(id);
+    if (!have || have.vert !== src.vert || have.frag !== src.frag) registerProgram(id, src.vert, src.frag);
+  }
+  return KINDS.push(entry.id, entry);
+}
+function getPaintDrawKind(kind) {
+  const id = kind ?? "solid";
+  const entry = KINDS.get(id);
+  if (!entry && LOADERS.has(id)) void startLoad(id).catch(() => {
+  });
+  return entry;
+}
+var LOADERS = /* @__PURE__ */ new Map();
+var LOADS = /* @__PURE__ */ new Map();
+function registerPaintDrawKindLoader(id, load) {
+  LOADERS.set(id, load);
+  return () => {
+    if (LOADERS.get(id) === load) LOADERS.delete(id);
+  };
+}
+function startLoad(id) {
+  const running = LOADS.get(id);
+  if (running) return running;
+  const load = LOADERS.get(id);
+  const done = load().then(
+    (entry) => {
+      if (entry.id !== id) {
+        throw new Error(`weasel: the loader for paint kind "${id}" resolved to "${entry.id}".`);
+      }
+      if (!KINDS.has(id)) registerPaintDrawKind(entry);
+    }
+  ).catch((err) => {
+    console.error(`weasel: paint kind "${id}" failed to load:`, err);
+    throw err;
+  });
+  LOADS.set(id, done);
+  return done;
+}
+function isPaintKindKnown(id) {
+  return KINDS.has(id) || LOADERS.has(id);
+}
+function warmPaintKinds(kinds) {
+  const ids = kinds ?? [...LOADERS.keys()];
+  const loads = [];
+  for (const id of ids) {
+    if (KINDS.has(id)) continue;
+    if (!LOADERS.has(id)) {
+      return Promise.reject(new Error(
+        `weasel warmPaintKinds: "${id}" is neither registered nor loadable.`
+      ));
+    }
+    loads.push(startLoad(id));
+  }
+  return Promise.all(loads).then(() => void 0);
+}
+function _resetPaintDrawKindsForTests() {
+  KINDS.clear();
+  LOADERS.clear();
+  LOADS.clear();
+}
+var STROKE_CONFIGS_PER_PATH = 8;
+var PX_WIDTH_TOLERANCE = 1 / 8;
+function quantizeStrokeScale(px, scale) {
+  if (!(px > 0) || !(scale > 0) || !Number.isFinite(scale)) return scale;
+  const stepsPerOctave = Math.ceil(Math.LN2 / (2 * Math.log1p(PX_WIDTH_TOLERANCE / px)));
+  return 2 ** (Math.round(Math.log2(scale) * stepsPerOctave) / stepsPerOctave);
+}
+var cache2 = /* @__PURE__ */ new WeakMap();
+function configKey(stroke, flattenTolerance, spaces) {
+  const width = resolveStrokeWidth(stroke.width ?? 1, 1);
+  const insets = strokeInsets(stroke, width);
+  const ribbon = spaces.ribbon?.metric;
+  return [
+    width,
+    stroke.cap ?? "butt",
+    stroke.join ?? "miter",
+    stroke.miterLimit ?? "",
+    stroke.align ?? "center",
+    (stroke.dash ?? []).join(","),
+    stroke.varyingWidthJoinThreshold ?? "",
+    flattenTolerance ?? "",
+    insets.start,
+    insets.end,
+    metricKey(ribbon),
+    metricKey(spaces.start?.metric),
+    metricKey(spaces.end?.metric)
+  ].join("|");
+}
+function strokeMesh(path, stroke, flattenTolerance, spaces = {}) {
+  let byConfig = cache2.get(path);
+  if (byConfig === void 0) {
+    byConfig = /* @__PURE__ */ new Map();
+    cache2.set(path, byConfig);
+  }
+  const key = configKey(stroke, flattenTolerance, spaces);
+  const entry = byConfig.get(key);
+  if (entry !== void 0 && entry.vertexWidths === stroke.vertexWidths) {
+    return entry.mesh;
+  }
+  const width = resolveStrokeWidth(stroke.width ?? 1, 1);
+  const insets = strokeInsets(stroke, width);
+  const mesh = tessellateStroke(path, stroke, {
+    flattenTolerance,
+    startInset: insetIn(insets.start, spaces.start, spaces.ribbon),
+    endInset: insetIn(insets.end, spaces.end, spaces.ribbon),
+    metric: spaces.ribbon?.metric
+  });
+  if (entry === void 0 && byConfig.size >= STROKE_CONFIGS_PER_PATH) byConfig.clear();
+  byConfig.set(key, { mesh, vertexWidths: stroke.vertexWidths });
+  return mesh;
+}
+function insetIn(length, head, ribbon) {
+  return head?.metric === ribbon?.metric ? length : { length, metric: head?.metric ?? null };
+}
+function _resetStrokeMeshCacheForTests() {
+  cache2 = /* @__PURE__ */ new WeakMap();
+}
+function fillInPoseFrame(fill, box) {
+  if (!isBuiltinKind(fill)) {
+    return getPaintDrawKind(fill.kind)?.inPoseFrame?.(fill, box) ?? fill;
+  }
+  if (isBoundsPattern(fill)) {
+    const o = fill.origin ?? { x: 0, y: 0 };
+    return { ...fill, origin: { x: box.x + o.x, y: box.y + o.y }, units: "local" };
+  }
+  if (!isBoundsGradient(fill)) return fill;
+  const toBox = (p) => ({
+    x: box.x + p.x * box.width,
+    y: box.y + p.y * box.height
+  });
+  if (fill.kind === "linear-gradient") {
+    return { ...fill, from: toBox(fill.from), to: toBox(fill.to), units: "local" };
+  }
+  if (fill.kind === "radial-gradient") {
+    const scale = Math.hypot(box.width, box.height) / Math.SQRT2;
+    return { ...fill, center: toBox(fill.center), radius: fill.radius * scale, units: "local" };
+  }
+  return { ...fill, center: toBox(fill.center), units: "local" };
+}
+function fillToBoundsFrame(fill, box) {
+  if (!isBuiltinKind(fill)) {
+    return getPaintDrawKind(fill.kind)?.toBoundsFrame?.(fill, box) ?? fill;
+  }
+  if (isPatternPaint(fill)) {
+    const o = fill.origin ?? { x: 0, y: 0 };
+    return { ...fill, origin: { x: o.x - box.x, y: o.y - box.y }, units: "bounds" };
+  }
+  const isGradient = fill.kind === "linear-gradient" || fill.kind === "radial-gradient" || fill.kind === "conic-gradient";
+  if (!isGradient) return fill;
+  if (box.width === 0 || box.height === 0) return fill;
+  const fromBox = (p) => ({
+    x: (p.x - box.x) / box.width,
+    y: (p.y - box.y) / box.height
+  });
+  if (fill.kind === "linear-gradient") {
+    return { ...fill, from: fromBox(fill.from), to: fromBox(fill.to), units: "bounds" };
+  }
+  if (fill.kind === "radial-gradient") {
+    const scale = Math.hypot(box.width, box.height) / Math.SQRT2;
+    return { ...fill, center: fromBox(fill.center), radius: fill.radius / scale, units: "bounds" };
+  }
+  return { ...fill, center: fromBox(fill.center), units: "bounds" };
+}
+function isBoundsPattern(fill) {
+  return isPatternPaint(fill) && fill.units === "bounds";
+}
+function isBoundsGradient(fill) {
+  if (fill === void 0) return false;
+  const kind = fill.kind;
+  if (kind !== "linear-gradient" && kind !== "radial-gradient" && kind !== "conic-gradient") {
+    return false;
+  }
+  return fill.units === "bounds";
+}
+function isBuiltinKind(fill) {
+  const kind = fill.kind ?? "solid";
+  return kind === "solid" || isPatternPaint(fill) || kind === "linear-gradient" || kind === "radial-gradient" || kind === "conic-gradient";
+}
+var PATTERN_TILE_CACHE_LIMIT = 256;
+var ID_PREFIX = "pattern:";
+var cache3 = /* @__PURE__ */ new Map();
+function specId(spec) {
+  const bag = spec;
+  const sorted = {};
+  for (const k of Object.keys(bag).sort()) sorted[k] = bag[k];
+  return ID_PREFIX + JSON.stringify(sorted);
+}
+function _resetPatternSpecCacheForTests() {
+  cache3.clear();
+}
+function resolvePatternSpec(spec) {
+  const tile = tileSpecOf(spec);
+  const id = specId(tile);
+  const hit = cache3.get(id);
+  if (hit !== void 0) {
+    markUsed(id);
+    return hit;
+  }
+  return build(id, tile);
+}
+function markUsed(id) {
+  const hit = cache3.get(id);
+  if (hit === void 0) return;
+  cache3.delete(id);
+  cache3.set(id, hit);
+}
+function build(id, spec) {
+  const bitmap = isTileKind(spec.kind) ? rasterizeTile({
+    size: tileSize(spec),
+    draw: (oc) => drawTileShapes(oc, tileGeometry(spec))
+  }) : null;
+  const handle = bitmap ? registerTextureAs(id, bitmap) : null;
+  cache3.delete(id);
+  cache3.set(id, handle);
+  while (cache3.size > PATTERN_TILE_CACHE_LIMIT) evict(cache3.keys().next().value);
+  return handle;
+}
+function evict(id) {
+  cache3.delete(id);
+  const source = textureRegistry.get(id)?.source;
+  unregisterTexture({ id });
+  if (source && "close" in source) source.close();
+}
+function revive(id) {
+  let spec;
+  try {
+    spec = JSON.parse(id.slice(ID_PREFIX.length));
+  } catch {
+    return;
+  }
+  if (typeof spec !== "object" || spec === null || !("kind" in spec)) return;
+  build(id, spec);
+}
+ownTextureIds(ID_PREFIX, { revive, touched: markUsed });
+function resolveFillPattern(fill) {
+  if (!isTilePaint(fill)) return fill;
+  const texture = resolvePatternSpec(fill);
+  return texture ? { kind: "texture", texture, ...patternPlacementOf(fill) } : null;
+}
+
+// src/patterns/commandPaint.ts
+function commandPaint(paint, box) {
+  return resolveFillPattern(fillInPoseFrame(paint, box));
+}
+function commandFill(fill, box) {
+  if (fill.paint == null) return null;
+  const paint = commandPaint(fill.paint, box);
+  if (paint === null) return null;
+  return paint === fill.paint ? fill : { ...fill, paint };
+}
+function commandStroke(stroke, box) {
+  if (stroke.paint == null) return null;
+  const paint = commandPaint(stroke.paint, box);
+  if (paint === null) return null;
+  return paint === stroke.paint ? stroke : { ...stroke, paint };
+}
+function resolvePaint(p, stroke, fallback, head) {
+  const v = p ?? fallback;
+  if (v === "none") return void 0;
+  if (v === "line") return stroke.paint;
+  return commandPaint(v, boundsOfPath(head)) ?? void 0;
+}
+function headCommands(heads, stroke) {
+  const out = [];
+  for (const { entry, path, size, space } of heads) {
+    const fill = resolvePaint(entry.fill, stroke, "line", path);
+    const width = entry.outline ? entry.outline.width * size : 0;
+    const outline = entry.outline ? { paint: resolvePaint(entry.outline.paint, stroke, "line", path), width: space ? { px: width * space.pxPerUnit } : width } : null;
+    if (fill === void 0 && (outline === null || outline.paint === void 0)) continue;
+    out.push({
+      kind: "path",
+      path,
+      ...fill ? { fill: { paint: fill } } : {},
+      ...outline && outline.paint ? { stroke: { paint: outline.paint, width: outline.width, cap: "round", join: "round" } } : {}
+    });
+  }
+  return out;
+}
+var byValue = /* @__PURE__ */ new WeakMap();
+var byStroke = /* @__PURE__ */ new WeakMap();
+var refKey = (ref) => ref === void 0 ? "" : typeof ref === "string" ? ref : `${ref.key}@${String(ref.size ?? "")}`;
+function readsKey(stroke) {
+  let key = "";
+  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {
+    const entry = ref === void 0 ? void 0 : getMarker(markerKeyOf(ref));
+    if (entry === void 0) {
+      key += "/";
+      continue;
+    }
+    const reads2 = markerReadsKey(entry, stroke);
+    if (reads2 === null) return null;
+    key += `${reads2}/`;
+  }
+  return key;
+}
+function mapFor(path, source, reads2) {
+  if (reads2 !== null) {
+    let map2 = byValue.get(path);
+    if (map2 === void 0) byValue.set(path, map2 = /* @__PURE__ */ new Map());
+    return map2;
+  }
+  let strokes = byStroke.get(path);
+  if (strokes === void 0) byStroke.set(path, strokes = /* @__PURE__ */ new WeakMap());
+  let map = strokes.get(source);
+  if (map === void 0) strokes.set(source, map = /* @__PURE__ */ new Map());
+  return map;
+}
+function cachedMarkerCommands(path, source, stroke, strokeWidth, flattenTolerance, spaces = {}) {
+  if (stroke.markerStart === void 0 && stroke.markerMid === void 0 && stroke.markerEnd === void 0) {
+    return [];
+  }
+  const reads2 = readsKey(stroke);
+  const map = mapFor(path, source, reads2);
+  const key = [
+    strokeWidth,
+    flattenTolerance ?? "",
+    markerGeneration(),
+    refKey(stroke.markerStart),
+    refKey(stroke.markerMid),
+    refKey(stroke.markerEnd),
+    reads2 ?? "",
+    screenSpaceKey(spaces.start),
+    screenSpaceKey(spaces.mid),
+    screenSpaceKey(spaces.end)
+  ].join("|");
+  let entry = map.get(key);
+  if (entry === void 0) {
+    const heads = markerHeads(path, stroke, strokeWidth, flattenTolerance, spaces);
+    entry = { heads, paint: stroke.paint, cmds: headCommands(heads, stroke) };
+    if (map.size >= STROKE_CONFIGS_PER_PATH) map.clear();
+    map.set(key, entry);
+  } else if (entry.paint !== stroke.paint) {
+    entry.paint = stroke.paint;
+    entry.cmds = headCommands(entry.heads, stroke);
+  }
+  return entry.cmds;
+}
+function _resetMarkerCommandCacheForTests() {
+  byValue = /* @__PURE__ */ new WeakMap();
+  byStroke = /* @__PURE__ */ new WeakMap();
+}
+var OUTLINE_FLATTEN_TOLERANCE = 1 / 4096;
+var OUTLINE_MESH_CACHE_LIMIT = 2048;
+var cache4 = /* @__PURE__ */ new Map();
+function outlineMesh(key, d) {
+  const cached = cache4.get(key);
+  if (cached !== void 0) return cached;
+  if (cache4.size >= OUTLINE_MESH_CACHE_LIMIT) cache4 = /* @__PURE__ */ new Map();
+  const mesh = tessellate(pathFromD(d), { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE });
+  cache4.set(key, mesh);
+  return mesh;
+}
+function _resetOutlineMeshCacheForTests() {
+  cache4 = /* @__PURE__ */ new Map();
+}
+var OUTLINE_STROKE_MESH_CACHE_LIMIT = 2048;
+var WIDTH_QUANTUM = 1 / 1024;
+var cache5 = /* @__PURE__ */ new Map();
+function quantizeEmWidth(emWidth) {
+  return Math.round(emWidth / WIDTH_QUANTUM) * WIDTH_QUANTUM;
+}
+function outlineStrokeMesh(glyphKey, d, emWidth, stroke, metric) {
+  if (!(emWidth > 0)) return null;
+  const key = [
+    glyphKey,
+    emWidth,
+    stroke.join ?? "miter",
+    stroke.cap ?? "butt",
+    stroke.miterLimit ?? "",
+    stroke.align ?? "center",
+    (stroke.dash ?? []).join(","),
+    metricKey(metric)
+  ].join("|");
+  const cached = cache5.get(key);
+  if (cached !== void 0) return cached.indices.length === 0 ? null : cached;
+  if (cache5.size >= OUTLINE_STROKE_MESH_CACHE_LIMIT) cache5 = /* @__PURE__ */ new Map();
+  const mesh = tessellateStroke(
+    pathFromD(d),
+    { ...stroke, width: emWidth },
+    { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE, metric }
+  );
+  cache5.set(key, mesh);
+  return mesh.indices.length === 0 ? null : mesh;
+}
+function _resetOutlineStrokeMeshCacheForTests() {
+  cache5 = /* @__PURE__ */ new Map();
+}
+
+// src/shaders/straightRgb.ts
+var STRAIGHT_RGB_GLSL = (
+  /* glsl */
+  `
+vec3 straightRgb(vec4 premultiplied) {
+  return premultiplied.rgb / max(premultiplied.a, 0.0001);
+}
+`
+);
+
+// src/shaders/batchFill.ts
+var BATCH_TEXTURE_SLOTS = 8;
+var WHITE_SLOT = 0;
+var PAINT_MODE_PLAIN = 0;
+var PAINT_MODE_RADIAL = 3;
+var PAINT_MODE_CONIC = 4;
+var PAINT_MODE_IMAGE = 5;
+var INV_TAU = (1 / (2 * Math.PI)).toFixed(10);
+function packSlot(slot, mode) {
+  return slot + BATCH_TEXTURE_SLOTS * mode;
+}
+var BATCH_ATTRIBUTE_LOCATIONS = {
+  a_position: 0,
+  a_vertexColor: 1,
+  a_uv: 2,
+  a_post: 3,
+  a_texSlot: 4
+};
+var L = BATCH_ATTRIBUTE_LOCATIONS;
+function sampleChain(slots) {
+  const arms = [];
+  for (let i = 1; i < slots; i++) {
+    arms.push(`  if (slot == ${i}) return texture(u_samplers[${i}], uv);`);
+  }
+  return arms.join("\n");
+}
+var BATCH_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+layout(location = ${L.a_position}) in vec2 a_position;
+layout(location = ${L.a_vertexColor}) in vec4 a_vertexColor;
+layout(location = ${L.a_uv}) in vec2 a_uv;
+layout(location = ${L.a_post}) in float a_post;
+layout(location = ${L.a_texSlot}) in float a_texSlot;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+out vec4 v_vertexColor;
+out vec2 v_uv;
+out float v_post;
+flat out int v_texSlot;
+flat out float v_paintMode;
+void main() {
+  vec3 screen = u_model * vec3(a_position, 1.0);
+  vec3 clip = u_proj * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  v_vertexColor = a_vertexColor;
+  v_uv = a_uv;
+  v_post = a_post;
+  // slot + 8 * mode, unpacked \u2014 see the file header for why they share a float.
+  int packed = int(a_texSlot + 0.5);
+  v_texSlot = packed % ${BATCH_TEXTURE_SLOTS};
+  v_paintMode = float(packed / ${BATCH_TEXTURE_SLOTS});
+}
+`
+);
+var BATCH_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec4 v_vertexColor;
+in vec2 v_uv;
+in float v_post;
+flat in int v_texSlot;
+flat in float v_paintMode;
+uniform sampler2D u_samplers[${BATCH_TEXTURE_SLOTS}];
+uniform vec4 u_color;
+uniform float u_alpha;
+uniform float u_synthBold;
+uniform vec2 u_fieldScale[${BATCH_TEXTURE_SLOTS}];
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+
+vec4 sampleSlot(int slot, vec2 uv) {
+${sampleChain(BATCH_TEXTURE_SLOTS)}
+  return texture(u_samplers[0], uv);
+}
+${GLYPH_COVERAGE_GLSL}
+${STRAIGHT_RGB_GLSL}
+void main() {
+  float isGrad = step(2.5, v_paintMode) * step(v_paintMode, ${PAINT_MODE_CONIC + 0.5});
+  // A radial or conic vertex carries a gradient-space coordinate rather than a
+  // texture coordinate, and its atlas row rather than an alpha. The sample is
+  // split across the branch rather than the coordinate selected before it: an
+  // arm that reads v_uv straight is a fetch the hardware can schedule against a
+  // varying, and one reading a coordinate the shader computed is not. Selecting
+  // the coordinate first and sampling once costs 29-54% of a fragment that is
+  // not a gradient; splitting it is within the measurement's own spread of free
+  // (tests/perf/fill-rate.spec.ts, teitou, 2026-10-05).
+  //
+  // Branching at all is safe here where it would not be around the glyph math:
+  // v_paintMode is flat, so every fragment of a quad takes the same arm, and
+  // nothing in either arm is a derivative.
+  vec4 texel;
+  if (isGrad > 0.5) {
+    float t = v_paintMode > ${PAINT_MODE_CONIC - 0.5}
+      ? fract(atan(v_uv.y, v_uv.x) * ${INV_TAU})
+      : length(v_uv);
+    texel = sampleSlot(v_texSlot, vec2(t, v_post));
+  } else {
+    texel = sampleSlot(v_texSlot, v_uv);
+  }
+  // At 0 the mix is the texel itself, so a solid still gets its color exactly.
+  texel.rgb = mix(texel.rgb, straightRgb(texel), step(${PAINT_MODE_IMAGE - 0.5}, v_paintMode));
+  float isGlyph = step(0.5, v_paintMode) * step(v_paintMode, 2.5);
+  // Unconditional, and multiplied out afterwards rather than branched around:
+  // see the file header.
+  float coverage = glyphCoverage(texel, v_paintMode, u_synthBold, v_uv, u_fieldScale[v_texSlot]);
+  // A glyph's texel is a distance field, so it takes no part in the color; a
+  // plain vertex multiplies its texel in as it always did.
+  vec4 src = mix(texel, vec4(1.0), isGlyph) * u_color * v_vertexColor;
+  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_alpha * mix(v_post, 1.0, isGrad) * mix(1.0, coverage, isGlyph);
+  outColor = vec4(mapped.rgb * a, a);
+}
+`
+);
+var BATCH_FILL_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_samplers",
+  "u_color",
+  "u_alpha",
+  "u_synthBold",
+  "u_fieldScale",
+  "u_colorMatrix",
+  "u_colorBias"
+];
+var BATCH_FILL_ATTRIBUTES = [
+  "a_position",
+  "a_vertexColor",
+  "a_uv",
+  "a_post",
+  "a_texSlot"
+];
+
+// src/batchClip.ts
+function axisAlignedClipRect(path, m) {
+  if (path.kind !== "rect") return null;
+  const keepsAxes = m[1] === 0 && m[3] === 0 || m[0] === 0 && m[4] === 0;
+  if (!keepsAxes) return null;
+  const ax = m[0] * path.x + m[3] * path.y + m[6];
+  const ay = m[1] * path.x + m[4] * path.y + m[7];
+  const x1 = path.x + path.width;
+  const y1 = path.y + path.height;
+  const bx = m[0] * x1 + m[3] * y1 + m[6];
+  const by = m[1] * x1 + m[4] * y1 + m[7];
+  return {
+    x0: Math.min(ax, bx),
+    y0: Math.min(ay, by),
+    x1: Math.max(ax, bx),
+    y1: Math.max(ay, by)
+  };
+}
+function intersectClipRects(a, b) {
+  return {
+    x0: Math.max(a.x0, b.x0),
+    y0: Math.max(a.y0, b.y0),
+    x1: Math.min(a.x1, b.x1),
+    y1: Math.min(a.y1, b.y1)
+  };
+}
+function clipConvexPolygon(src, n, stride, rect, dst, tmp) {
+  let count = clipEdge(src, n, stride, 0, rect.x0, 1, tmp);
+  count = clipEdge(tmp, count, stride, 0, rect.x1, -1, dst);
+  count = clipEdge(dst, count, stride, 1, rect.y0, 1, tmp);
+  return clipEdge(tmp, count, stride, 1, rect.y1, -1, dst);
+}
+function clipEdge(src, n, stride, axis, at, sign, out) {
+  if (n === 0) return 0;
+  let m = 0;
+  let prev = n - 1;
+  let prevIn = sign * (src[prev * stride + axis] - at) >= 0;
+  for (let cur = 0; cur < n; cur++) {
+    const curIn = sign * (src[cur * stride + axis] - at) >= 0;
+    if (curIn !== prevIn) {
+      const a = prev * stride;
+      const b = cur * stride;
+      const t = (at - src[a + axis]) / (src[b + axis] - src[a + axis]);
+      const o = m * stride;
+      for (let k = 0; k < stride; k++) out[o + k] = src[a + k] + t * (src[b + k] - src[a + k]);
+      out[o + axis] = at;
+      m++;
+    }
+    if (curIn) {
+      const o = m * stride;
+      const c = cur * stride;
+      for (let k = 0; k < stride; k++) out[o + k] = src[c + k];
+      m++;
+    }
+    prev = cur;
+    prevIn = curIn;
+  }
+  return m;
+}
+
+// src/drawBatch.ts
+var MAX_VERTICES_PER_BATCH = 32768;
+var FLOATS_PER_VERTEX = 10;
+var INITIAL_VERTICES = 256;
+var INITIAL_INDICES = 384;
+var WHITE_U = 0.5;
+var WHITE_V = 0.5;
+var PLAIN_WHITE = packSlot(WHITE_SLOT, PAINT_MODE_PLAIN);
+var SOLID_RING_SIZE = 64;
+var BATCH_TIERS = [
+  { vertices: 16, indices: 24 },
+  { vertices: 1024, indices: 3072 }
+];
+var SOLID_RING_SLOT_VERTICES = BATCH_TIERS[BATCH_TIERS.length - 1].vertices;
+var SOLID_LARGE_RING_SIZE = 4;
+function doubledTo(from, need) {
+  let capacity = from;
+  while (capacity < need) capacity *= 2;
+  return capacity;
+}
+function quadIndices(quads) {
+  const out = new Uint32Array(quads * 6);
+  for (let q = 0; q < quads; q++) {
+    const b = q * 4;
+    const j = q * 6;
+    out[j] = b;
+    out[j + 1] = b + 1;
+    out[j + 2] = b + 2;
+    out[j + 3] = b;
+    out[j + 4] = b + 2;
+    out[j + 5] = b + 3;
+  }
+  return out;
+}
+var DrawBatch = class {
+  gl;
+  aPos;
+  aColor;
+  aUv;
+  aPost;
+  aSlot;
+  /** One ring per tier, cycled per flush. Slots are created on first use, so a
+   *  renderer that flushes rarely allocates as few as it flushes. */
+  rings = BATCH_TIERS.map(() => new Array(SOLID_RING_SIZE).fill(void 0));
+  nextInRing = BATCH_TIERS.map(() => 0);
+  /** The same, for flushes past the largest tier; these sets grow to fit. */
+  largeRing = new Array(SOLID_LARGE_RING_SIZE).fill(void 0);
+  nextLarge = 0;
+  verts = new Float32Array(INITIAL_VERTICES * FLOATS_PER_VERTEX);
+  idx = new Uint32Array(INITIAL_INDICES);
+  nVerts = 0;
+  nIdx = 0;
+  /** Whether the staged run is quads alone, so its indices are the canonical
+   *  pattern and a slot already holding that pattern needs no upload. */
+  pureRects = true;
+  /** The rect every push is cut to, or `null`. A push returns `false`, having
+   *  staged nothing, for geometry it cannot cut exactly; see `clipQuad`. */
+  clip = null;
+  /** Polygon scratch for `clip`: a quad cut by four edges has at most eight
+   *  corners. */
+  polyIn = new Float32Array(8 * FLOATS_PER_VERTEX);
+  polyOut = new Float32Array(8 * FLOATS_PER_VERTEX);
+  polyTmp = new Float32Array(8 * FLOATS_PER_VERTEX);
+  constructor(gl, prog) {
+    const aPos = prog.attribute("a_position");
+    const aColor = prog.attribute("a_vertexColor");
+    const aUv = prog.attribute("a_uv");
+    const aPost = prog.attribute("a_post");
+    const aSlot = prog.attribute("a_texSlot");
+    if (aPos === void 0 || aColor === void 0 || aUv === void 0 || aPost === void 0 || aSlot === void 0) {
+      throw new Error(
+        "DrawBatch: batch program is missing a_position / a_vertexColor / a_uv / a_post / a_texSlot"
+      );
+    }
+    this.gl = gl;
+    this.aPos = aPos;
+    this.aColor = aColor;
+    this.aUv = aUv;
+    this.aPost = aPost;
+    this.aSlot = aSlot;
+  }
+  get length() {
+    return this.nIdx;
+  }
+  /** Whether staging `vertices` more would put the run past the per-flush cap. */
+  wouldOverflow(vertices) {
+    return this.nVerts + vertices > MAX_VERTICES_PER_BATCH;
+  }
+  /**
+   * Append one rect's four corners through `m`, all carrying `rgba` (straight
+   * alpha).
+   */
+  pushRect(x, y, w, h, m, r, g, b, a) {
+    this.reserve(4, 6);
+    let i = this.nVerts * FLOATS_PER_VERTEX;
+    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
+    const x1 = x + w;
+    const y1 = y + h;
+    const ax = ma * x + mc * y + mtx, ay = mb * x + md * y + mty;
+    const bx = ma * x1 + mc * y + mtx, by = mb * x1 + md * y + mty;
+    const cx = ma * x1 + mc * y1 + mtx, cy = mb * x1 + md * y1 + mty;
+    const dx = ma * x + mc * y1 + mtx, dy = mb * x + md * y1 + mty;
+    const P = PLAIN_WHITE;
+    i = this.writeVertex(i, ax, ay, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    i = this.writeVertex(i, bx, by, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    i = this.writeVertex(i, cx, cy, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    this.writeVertex(i, dx, dy, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    this.pushQuadIndices();
+    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
+  }
+  /**
+   * Append one image quad: the destination rect `(x, y, w, h)` mapped through
+   * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `post` as the
+   * after-the-color-matrix alpha factor and `rgb` as the scale on its texel.
+   * `slot` is the texture unit the corners sample.
+   *
+   * Corners wind top-left, top-right, bottom-right, bottom-left — the same
+   * winding `pushRect` uses, which is what lets a run of mixed rects and quads
+   * keep the canonical index pattern.
+   */
+  pushQuad(x, y, w, h, m, u0, v0, u1, v1, post, slot, r = 1, g = 1, b = 1) {
+    this.reserve(4, 6);
+    let i = this.nVerts * FLOATS_PER_VERTEX;
+    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
+    const x1 = x + w;
+    const y1 = y + h;
+    const ax = ma * x + mc * y + mtx, ay = mb * x + md * y + mty;
+    const bx = ma * x1 + mc * y + mtx, by = mb * x1 + md * y + mty;
+    const cx = ma * x1 + mc * y1 + mtx, cy = mb * x1 + md * y1 + mty;
+    const dx = ma * x + mc * y1 + mtx, dy = mb * x + md * y1 + mty;
+    const P = packSlot(slot, PAINT_MODE_IMAGE);
+    i = this.writeVertex(i, ax, ay, r, g, b, 1, u0, v0, post, P);
+    i = this.writeVertex(i, bx, by, r, g, b, 1, u1, v0, post, P);
+    i = this.writeVertex(i, cx, cy, r, g, b, 1, u1, v1, post, P);
+    this.writeVertex(i, dx, dy, r, g, b, 1, u0, v1, post, P);
+    this.pushQuadIndices();
+    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
+  }
+  /**
+   * Append one glyph quad: the box `(x0, y0)`-`(x1, y1)` mapped through `m`,
+   * sampling `(u0, v0)`-`(u1, v1)` of the font atlas at `slot`, painted in
+   * `rgba`.
+   *
+   * `mode` says which channels of that atlas carry the distance field, and
+   * rides the vertices packed into the slot. The synthetic-bold threshold does
+   * not: it is `u_synthBold`, and the caller breaks the run when it changes.
+   *
+   * A synthetic oblique is sheared here, before `m`; `tanItalic` is 0 for an
+   * upright face. Corners wind as `pushQuad`'s do.
+   */
+  pushGlyph(x0, y0, x1, y1, baselineY, tanItalic, m, u0, v0, u1, v1, r, g, b, a, slot, mode) {
+    this.reserve(4, 6);
+    let i = this.nVerts * FLOATS_PER_VERTEX;
+    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
+    const topShift = (baselineY - y0) * tanItalic;
+    const botShift = (baselineY - y1) * tanItalic;
+    const tx0 = x0 + topShift, tx1 = x1 + topShift;
+    const bx0 = x0 + botShift, bx1 = x1 + botShift;
+    const ax = ma * tx0 + mc * y0 + mtx, ay = mb * tx0 + md * y0 + mty;
+    const bx = ma * tx1 + mc * y0 + mtx, by = mb * tx1 + md * y0 + mty;
+    const cx = ma * bx1 + mc * y1 + mtx, cy = mb * bx1 + md * y1 + mty;
+    const dx = ma * bx0 + mc * y1 + mtx, dy = mb * bx0 + md * y1 + mty;
+    const P = packSlot(slot, mode);
+    i = this.writeVertex(i, ax, ay, r, g, b, a, u0, v0, 1, P);
+    i = this.writeVertex(i, bx, by, r, g, b, a, u1, v0, 1, P);
+    i = this.writeVertex(i, cx, cy, r, g, b, a, u1, v1, 1, P);
+    this.writeVertex(i, dx, dy, r, g, b, a, u0, v1, 1, P);
+    this.pushQuadIndices();
+    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
+  }
+  /**
+   * Append one rect filled by a gradient: the corners of `(x, y, w, h)` mapped
+   * through `m`, sampling the ramp atlas at `slot`.
+   *
+   * `uv` gives each channel of `a_uv` as an affine function of the coordinates
+   * the corners arrive in. `mode` says whether that is a ramp position or a
+   * gradient-space coordinate, and `post` carries the atlas row for the modes
+   * that read it — see `shaders/batchFill.ts`. Values outside 0..1 clamp to
+   * the atlas's edge texel.
+   */
+  pushGradientRect(x, y, w, h, m, uv, post, slot, mode, r, g, b, a) {
+    this.reserve(4, 6);
+    let i = this.nVerts * FLOATS_PER_VERTEX;
+    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
+    const x1 = x + w;
+    const y1 = y + h;
+    const P = packSlot(slot, mode);
+    const corner = (cx, cy) => {
+      const at = i;
+      i = this.writeVertex(
+        at,
+        ma * cx + mc * cy + mtx,
+        mb * cx + md * cy + mty,
+        r,
+        g,
+        b,
+        a,
+        uv.ux * cx + uv.uy * cy + uv.u0,
+        uv.vx * cx + uv.vy * cy + uv.v0,
+        post,
+        P
+      );
+      return i;
+    };
+    corner(x, y);
+    corner(x1, y);
+    corner(x1, y1);
+    corner(x, y1);
+    this.pushQuadIndices();
+    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
+  }
+  /** `pushMesh` for a mesh filled by a gradient — see `pushGradientRect` for
+   *  what `uv`, `post` and `mode` carry. */
+  pushGradientMesh(mesh, m, uv, post, slot, mode, r, g, b, a) {
+    const src = mesh.vertices;
+    const srcIdx = mesh.indices;
+    const n = src.length >> 1;
+    this.reserve(n, srcIdx.length);
+    this.pureRects = false;
+    const v = this.verts;
+    let i = this.nVerts * FLOATS_PER_VERTEX;
+    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
+    const P = packSlot(slot, mode);
+    for (let k = 0; k < n; k++) {
+      const x = src[k * 2];
+      const y = src[k * 2 + 1];
+      v[i++] = ma * x + mc * y + mtx;
+      v[i++] = mb * x + md * y + mty;
+      v[i++] = r;
+      v[i++] = g;
+      v[i++] = b;
+      v[i++] = a;
+      v[i++] = uv.ux * x + uv.uy * y + uv.u0;
+      v[i++] = uv.vx * x + uv.vy * y + uv.v0;
+      v[i++] = post;
+      v[i++] = P;
+    }
+    const base = this.nVerts;
+    const out = this.idx;
+    let j = this.nIdx;
+    for (let k = 0; k < srcIdx.length; k++) out[j++] = base + srcIdx[k];
+    this.nVerts += n;
+    this.nIdx += srcIdx.length;
+    return this.clip === null || this.clipMesh(base, this.nIdx - srcIdx.length, this.clip);
+  }
+  /**
+   * Append a tessellated mesh through `m`, all vertices carrying `rgba`. The
+   * mesh's own indices are rebased onto the staged vertices, which is why the
+   * index buffer is uploaded per flush rather than written once.
+   */
+  pushMesh(mesh, m, r, g, b, a) {
+    const src = mesh.vertices;
+    const srcIdx = mesh.indices;
+    const n = src.length >> 1;
+    this.reserve(n, srcIdx.length);
+    this.pureRects = false;
+    const v = this.verts;
+    let i = this.nVerts * FLOATS_PER_VERTEX;
+    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
+    for (let k = 0; k < n; k++) {
+      const x = src[k * 2];
+      const y = src[k * 2 + 1];
+      v[i++] = ma * x + mc * y + mtx;
+      v[i++] = mb * x + md * y + mty;
+      v[i++] = r;
+      v[i++] = g;
+      v[i++] = b;
+      v[i++] = a;
+      v[i++] = WHITE_U;
+      v[i++] = WHITE_V;
+      v[i++] = 1;
+      v[i++] = PLAIN_WHITE;
+    }
+    const base = this.nVerts;
+    const out = this.idx;
+    let j = this.nIdx;
+    for (let k = 0; k < srcIdx.length; k++) out[j++] = base + srcIdx[k];
+    this.nVerts += n;
+    this.nIdx += srcIdx.length;
+    return this.clip === null || this.clipMesh(base, this.nIdx - srcIdx.length, this.clip);
+  }
+  /** Upload the staged geometry into the next set of buffers and bind its VAO.
+   *  Returns the index count for the caller's `drawElements`. */
+  uploadAndBind() {
+    const gl = this.gl;
+    const tier = BATCH_TIERS.findIndex(
+      (t) => this.nVerts <= t.vertices && this.nIdx <= t.indices
+    );
+    const set = tier < 0 ? this.nextLargeSlot() : this.nextRingSlot(tier);
+    gl.bindVertexArray(set.vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);
+    gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.verts, 0, this.nVerts * FLOATS_PER_VERTEX);
+    if (!this.pureRects) {
+      gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, this.idx, 0, this.nIdx);
+      set.canonicalQuads = 0;
+    } else if (set.canonicalQuads < this.nVerts >> 2) {
+      const quads = Math.min(set.vertexCapacity >> 2, Math.floor(set.indexCapacity / 6));
+      gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, quadIndices(quads));
+      set.canonicalQuads = quads;
+    }
+    return this.nIdx;
+  }
+  reset() {
+    this.nVerts = 0;
+    this.nIdx = 0;
+    this.pureRects = true;
+  }
+  dispose() {
+    for (const set of [...this.rings.flat(), ...this.largeRing]) {
+      if (set) this.deleteSet(set);
+    }
+    for (const ring of this.rings) ring.fill(void 0);
+    this.largeRing.fill(void 0);
+  }
+  writeVertex(i, x, y, r, g, b, a, u, v, post, packed) {
+    const out = this.verts;
+    out[i] = x;
+    out[i + 1] = y;
+    out[i + 2] = r;
+    out[i + 3] = g;
+    out[i + 4] = b;
+    out[i + 5] = a;
+    out[i + 6] = u;
+    out[i + 7] = v;
+    out[i + 8] = post;
+    out[i + 9] = packed;
+    return i + FLOATS_PER_VERTEX;
+  }
+  /**
+   * Fit the quad just written at `v0` to `rect`: keep it if it lies inside,
+   * drop it if it misses, and cut it if it crosses — but only if its edges
+   * run along the axes. Cutting a slanted edge moves its endpoint off the
+   * subpixel grid the rasterizer snaps to, and the shortened edge then covers
+   * different samples than the whole one did; along an axis the cut edge is
+   * the same line exactly. So a slanted quad that crosses is rolled back and
+   * refused, for the caller to clip through the stencil instead.
+   */
+  clipQuad(v0, i0, rect) {
+    const v = this.verts;
+    const at = v0 * FLOATS_PER_VERTEX;
+    const F = FLOATS_PER_VERTEX;
+    const ax = v[at], ay = v[at + 1], bx = v[at + F], by = v[at + F + 1];
+    const cx = v[at + 2 * F], cy = v[at + 2 * F + 1], dx = v[at + 3 * F], dy = v[at + 3 * F + 1];
+    const minX = Math.min(ax, bx, cx, dx), maxX = Math.max(ax, bx, cx, dx);
+    const minY = Math.min(ay, by, cy, dy), maxY = Math.max(ay, by, cy, dy);
+    if (minX >= rect.x0 && maxX <= rect.x1 && minY >= rect.y0 && maxY <= rect.y1) return true;
+    this.nVerts = v0;
+    this.nIdx = i0;
+    if (maxX <= rect.x0 || minX >= rect.x1 || maxY <= rect.y0 || minY >= rect.y1) return true;
+    const alongAxes = ay === by && bx === cx && cy === dy && dx === ax || ax === bx && by === cy && cx === dx && dy === ay;
+    if (!alongAxes) return false;
+    this.polyIn.set(v.subarray(at, at + 4 * F));
+    const n = clipConvexPolygon(this.polyIn, 4, F, rect, this.polyOut, this.polyTmp);
+    this.appendFan(this.polyOut, n);
+    return true;
+  }
+  /** `clipQuad` for a mesh staged from `v0`. A mesh's edges are slanted in
+   *  general, so one that crosses is refused rather than cut. */
+  clipMesh(v0, i0, rect) {
+    const v = this.verts;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (let i = v0 * FLOATS_PER_VERTEX; i < this.nVerts * FLOATS_PER_VERTEX; i += FLOATS_PER_VERTEX) {
+      const x = v[i];
+      const y = v[i + 1];
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      if (y > maxY) maxY = y;
+    }
+    if (minX >= rect.x0 && maxX <= rect.x1 && minY >= rect.y0 && maxY <= rect.y1) return true;
+    this.nVerts = v0;
+    this.nIdx = i0;
+    return maxX <= rect.x0 || minX >= rect.x1 || maxY <= rect.y0 || minY >= rect.y1;
+  }
+  /** Append the `n`-corner convex polygon in `poly` as a triangle fan. */
+  appendFan(poly, n) {
+    if (n < 3) return;
+    this.reserve(n, (n - 2) * 3);
+    if (n !== 4) this.pureRects = false;
+    const base = this.nVerts;
+    this.verts.set(poly.subarray(0, n * FLOATS_PER_VERTEX), base * FLOATS_PER_VERTEX);
+    let j = this.nIdx;
+    for (let k = 1; k < n - 1; k++) {
+      this.idx[j++] = base;
+      this.idx[j++] = base + k;
+      this.idx[j++] = base + k + 1;
+    }
+    this.nVerts += n;
+    this.nIdx = j;
+  }
+  /** Two triangles over the four corners just written. */
+  pushQuadIndices() {
+    const base = this.nVerts;
+    let j = this.nIdx;
+    this.idx[j++] = base;
+    this.idx[j++] = base + 1;
+    this.idx[j++] = base + 2;
+    this.idx[j++] = base;
+    this.idx[j++] = base + 2;
+    this.idx[j++] = base + 3;
+    this.nVerts += 4;
+    this.nIdx += 6;
+  }
+  /** Grow the CPU arrays so `vertices` / `indices` more fit. */
+  reserve(vertices, indices) {
+    const needVerts = (this.nVerts + vertices) * FLOATS_PER_VERTEX;
+    if (needVerts > this.verts.length) {
+      const grown = new Float32Array(doubledTo(this.verts.length, needVerts));
+      grown.set(this.verts);
+      this.verts = grown;
+    }
+    const needIdx = this.nIdx + indices;
+    if (needIdx > this.idx.length) {
+      const grown = new Uint32Array(doubledTo(this.idx.length, needIdx));
+      grown.set(this.idx);
+      this.idx = grown;
+    }
+  }
+  nextRingSlot(tier) {
+    const ring = this.rings[tier];
+    const slot = this.nextInRing[tier];
+    this.nextInRing[tier] = (slot + 1) % ring.length;
+    const existing = ring[slot];
+    if (existing) return existing;
+    const set = this.createSet(BATCH_TIERS[tier].vertices, BATCH_TIERS[tier].indices);
+    ring[slot] = set;
+    return set;
+  }
+  nextLargeSlot() {
+    const gl = this.gl;
+    const slot = this.nextLarge;
+    this.nextLarge = (slot + 1) % SOLID_LARGE_RING_SIZE;
+    let set = this.largeRing[slot];
+    if (!set) {
+      set = this.createSet(
+        doubledTo(SOLID_RING_SLOT_VERTICES, this.nVerts),
+        doubledTo(BATCH_TIERS[BATCH_TIERS.length - 1].indices, this.nIdx)
+      );
+      this.largeRing[slot] = set;
+      return set;
+    }
+    if (this.nVerts > set.vertexCapacity) {
+      set.vertexCapacity = doubledTo(set.vertexCapacity, this.nVerts);
+      gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);
+      gl.bufferData(gl.ARRAY_BUFFER, set.vertexCapacity * FLOATS_PER_VERTEX * 4, gl.DYNAMIC_DRAW);
+    }
+    if (this.nIdx > set.indexCapacity) {
+      set.indexCapacity = doubledTo(set.indexCapacity, this.nIdx);
+      gl.bindVertexArray(set.vao);
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, set.ibo);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, set.indexCapacity * 4, gl.DYNAMIC_DRAW);
+      gl.bindVertexArray(null);
+      set.canonicalQuads = 0;
+    }
+    return set;
+  }
+  createSet(vertices, indices) {
+    const gl = this.gl;
+    const vao = gl.createVertexArray();
+    const vbo = gl.createBuffer();
+    const ibo = gl.createBuffer();
+    if (!vao || !vbo || !ibo) throw new Error("DrawBatch: failed to create GL objects");
+    const stride = FLOATS_PER_VERTEX * 4;
+    gl.bindVertexArray(vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+    gl.bufferData(gl.ARRAY_BUFFER, vertices * stride, gl.DYNAMIC_DRAW);
+    gl.enableVertexAttribArray(this.aPos);
+    gl.vertexAttribPointer(this.aPos, 2, gl.FLOAT, false, stride, 0);
+    gl.enableVertexAttribArray(this.aColor);
+    gl.vertexAttribPointer(this.aColor, 4, gl.FLOAT, false, stride, 8);
+    gl.enableVertexAttribArray(this.aUv);
+    gl.vertexAttribPointer(this.aUv, 2, gl.FLOAT, false, stride, 24);
+    gl.enableVertexAttribArray(this.aPost);
+    gl.vertexAttribPointer(this.aPost, 1, gl.FLOAT, false, stride, 32);
+    gl.enableVertexAttribArray(this.aSlot);
+    gl.vertexAttribPointer(this.aSlot, 1, gl.FLOAT, false, stride, 36);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices * 4, gl.DYNAMIC_DRAW);
+    gl.bindVertexArray(null);
+    return { vao, vbo, ibo, vertexCapacity: vertices, indexCapacity: indices, canonicalQuads: 0 };
+  }
+  deleteSet(set) {
+    const gl = this.gl;
+    gl.deleteBuffer(set.vbo);
+    gl.deleteBuffer(set.ibo);
+    gl.deleteVertexArray(set.vao);
+  }
+};
+var MAX_VECTOR_RASTER_PIXELS = 4096 * 4096;
+var SHRINK_SLACK = 4;
+var FALLBACK_WIDTH = 300;
+var FALLBACK_HEIGHT = 150;
+var DEFAULT_BUDGET_BYTES = 256 * 1024 * 1024;
+var cache6 = /* @__PURE__ */ new Map();
+var budgetBytes = DEFAULT_BUDGET_BYTES;
+var reads = 0;
+var readsAtLastPass = 0;
+var ready = createEmitter();
+var decodedVectors = /* @__PURE__ */ new Map();
+function isVectorImageSrc(src) {
+  if (/^data:image\/svg\+xml[;,]/i.test(src)) return true;
+  if (/^(data|blob):/i.test(src)) return false;
+  return /\.svgz?$/i.test(src.replace(/[?#].*$/, ""));
+}
+function requireDom() {
+  if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
+    throw new Error("weasel imageCache: no DOM image loader in this environment");
+  }
+}
+async function decodeImage(src) {
+  const img = new Image();
+  img.crossOrigin = "anonymous";
+  img.src = src;
+  await img.decode();
+  return img;
+}
+function decodeVector(src) {
+  let decoded = decodedVectors.get(src);
+  if (!decoded) {
+    decoded = decodeImage(src);
+    decodedVectors.set(src, decoded);
+    decoded.catch(() => decodedVectors.delete(src));
+  }
+  return decoded;
+}
+async function rasterizeVector(src, size) {
+  const img = await decodeVector(src);
+  const width = size?.width ?? (img.naturalWidth || FALLBACK_WIDTH);
+  const height = size?.height ?? (img.naturalHeight || FALLBACK_HEIGHT);
+  const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(width, height) : Object.assign(document.createElement("canvas"), { width, height });
+  const c2d = canvas.getContext("2d");
+  if (!c2d) throw new Error("weasel imageCache: no 2D context to rasterize an SVG");
+  c2d.drawImage(img, 0, 0, width, height);
+  return createImageBitmap(canvas);
+}
+var defaultLoader = async (src, size) => {
+  requireDom();
+  if (isVectorImageSrc(src)) return rasterizeVector(src, size);
+  return createImageBitmap(await decodeImage(src));
+};
+var loader = defaultLoader;
+function notify() {
+  ready.emit();
+}
+var bytesOf = (bitmap) => bitmap ? bitmap.width * bitmap.height * 4 : 0;
+function enforceBudget(landed) {
+  let total = 0;
+  for (const entry of cache6.values()) total += bytesOf(entry.bitmap);
+  if (total > budgetBytes) {
+    const idle = [...cache6].filter(([src, entry]) => src !== landed && entry.bitmap !== void 0 && entry.readAt <= readsAtLastPass && !imageSourceInLatestFrame(entry.bitmap));
+    idle.sort((a, b) => a[1].readAt - b[1].readAt);
+    for (const [src, entry] of idle) {
+      if (total <= budgetBytes) break;
+      total -= bytesOf(entry.bitmap);
+      releaseImage(src);
+    }
+  }
+  readsAtLastPass = reads;
+}
+function setImageCacheBudget(bytes) {
+  const previous = budgetBytes;
+  budgetBytes = bytes;
+  return previous;
+}
+function startLoad2(src) {
+  const entry = { status: "loading", readAt: ++reads };
+  cache6.set(src, entry);
+  loader(src).then(
+    (bitmap) => {
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, {
+        status: "ready",
+        bitmap,
+        readAt: entry.readAt,
+        ...isVectorImageSrc(src) ? { vector: { natural: { width: bitmap.width, height: bitmap.height }, scale: 1, failed: /* @__PURE__ */ new Set(), floor: 0 } } : {}
+      });
+      enforceBudget(src);
+      notify();
+    },
+    () => {
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, { status: "error", readAt: entry.readAt });
+      notify();
+    }
+  );
+}
+function rasterScaleFor(natural, drawnAt) {
+  const need = Math.max(drawnAt.width / natural.width, drawnAt.height / natural.height);
+  if (!(need > 0) || !Number.isFinite(need)) return void 0;
+  const side = maxImageTextureSide();
+  const cap = Math.min(
+    side / natural.width,
+    side / natural.height,
+    Math.sqrt(MAX_VECTOR_RASTER_PIXELS / (natural.width * natural.height))
+  );
+  return Math.min(2 ** Math.ceil(Math.log2(need)), cap);
+}
+function maybeReraster(src, entry, v, drawnAt) {
+  if (v.pending !== void 0) return;
+  const wanted = rasterScaleFor(v.natural, drawnAt);
+  if (wanted === void 0) return;
+  const grow = wanted > v.scale;
+  if (grow && v.shrunkTo === v.scale) v.floor = Math.max(v.floor, wanted);
+  const target = grow ? wanted : Math.max(wanted, v.floor);
+  if (!grow && target * SHRINK_SLACK > v.scale) return;
+  for (const f of v.failed) if (target === f || grow && f > v.scale && target >= f) return;
+  v.pending = target;
+  const size = {
+    width: Math.max(1, Math.round(v.natural.width * target)),
+    height: Math.max(1, Math.round(v.natural.height * target))
+  };
+  loader(src, size).then(
+    (bitmap) => {
+      if (cache6.get(src) !== entry) return;
+      v.pending = void 0;
+      const old = entry.bitmap;
+      entry.bitmap = bitmap;
+      v.shrunkTo = grow ? void 0 : target;
+      v.scale = target;
+      if (old && old !== bitmap) releaseImageSource(old);
+      enforceBudget(src);
+      notify();
+    },
+    () => {
+      if (cache6.get(src) !== entry) return;
+      v.pending = void 0;
+      v.failed.add(target);
+    }
+  );
+}
+function getImageBitmap(src, drawnAt) {
+  const entry = cache6.get(src);
+  if (!entry) {
+    startLoad2(src);
+    return void 0;
+  }
+  entry.readAt = ++reads;
+  if (drawnAt && entry.vector) maybeReraster(src, entry, entry.vector, drawnAt);
+  return entry.bitmap;
+}
+function imageStatus(src) {
+  return cache6.get(src)?.status ?? "idle";
+}
+function releaseImage(src) {
+  const entry = cache6.get(src);
+  cache6.delete(src);
+  decodedVectors.delete(src);
+  if (entry?.bitmap) releaseImageSource(entry.bitmap);
+}
+function retryImage(src) {
+  if (cache6.get(src)?.status !== "error") return;
+  startLoad2(src);
+  notify();
+}
+function subscribeImageReady(cb) {
+  return ready.subscribe(cb);
+}
+function __setImageLoaderForTests(fn) {
+  loader = fn;
+}
+function _resetImageCacheForTests() {
+  cache6.clear();
+  ready = createEmitter();
+  decodedVectors.clear();
+  loader = defaultLoader;
+  budgetBytes = DEFAULT_BUDGET_BYTES;
+  reads = 0;
+  readsAtLastPass = 0;
+}
+
+export { BATCH_ATTRIBUTE_LOCATIONS, BATCH_FILL_ATTRIBUTES, BATCH_FILL_UNIFORMS, BATCH_FRAG_SRC, BATCH_TEXTURE_SLOTS, BATCH_VERT_SRC, DrawBatch, FLOATS_PER_VERTEX, GLImageCache, PAINT_MODE_CONIC, PAINT_MODE_PLAIN, PAINT_MODE_RADIAL, STRAIGHT_RGB_GLSL, __setImageLoaderForTests, _resetCacheForTests, _resetImageCacheForTests, _resetMarkerCommandCacheForTests, _resetOutlineMeshCacheForTests, _resetOutlineStrokeMeshCacheForTests, _resetPaintDrawKindsForTests, _resetPatternSpecCacheForTests, _resetProgramRegistryForTests, _resetStrokeMeshCacheForTests, axisAlignedClipRect, cachedMarkerCommands, commandFill, commandPaint, commandStroke, fillInPoseFrame, fillToBoundsFrame, getImageBitmap, getMesh, getPaintDrawKind, getProgramSource, imageStatus, intersectClipRects, isPaintKindKnown, isVectorImageSrc, outlineMesh, outlineStrokeMesh, paintDrawKindRegistry, programSourceRegistry, quantizeEmWidth, quantizeStrokeScale, registerPaintDrawKind, registerPaintDrawKindLoader, registerProgram, releaseImage, releaseImageSource, resolveFillPattern, resolvePatternSpec, retryImage, setImageCacheBudget, strokeMesh, subscribeImageReady, uploadPremultiplied, warmPaintKinds };
+//# sourceMappingURL=chunk-LFD47OV2.js.map
+//# sourceMappingURL=chunk-LFD47OV2.js.map