@pixerate/editor 0.250.0 → 0.251.0

package/dist/chunk-TXFWZ5ZJ.js

@@ -0,0 +1,594 @@
+import {
+  CoverageMap,
+  PaintGradientSampler,
+  TIP_GRADIENT_STEPS,
+  applyStrokeToTile,
+  dabRect,
+  gradientDabColor,
+  hexToPaintRgb,
+  normalizeBrush,
+  rasterizeDab,
+  resolvePaintGradient,
+  scalePaintGradient
+} from "./chunk-GCVFEPJG.js";
+import {
+  TileableNoise,
+  hash2,
+  randSigned
+} from "./chunk-4D6KP5BV.js";
+import {
+  BRUSHSTROKE_MAX_SCALE,
+  BRUSHSTROKE_MIN_SCALE
+} from "./chunk-ODBT55Q7.js";
+import {
+  pngDataUrl
+} from "./chunk-OTTT5N3K.js";
+import {
+  TILE,
+  TiledSurface,
+  emptySurface,
+  finishTile,
+  readRegion,
+  tileCoord,
+  tileKey,
+  tilesInRect
+} from "./chunk-HVVR5PZW.js";
+
+// src/paint/grain.ts
+var GRAIN_PATTERNS = ["smooth", "cold-pressed", "hot-pressed", "rough", "vellum", "laid", "ingres", "sanded", "canvas", "linen", "gesso"];
+var GRAIN_TILE = 256;
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function patternHeights(pattern, n, seed) {
+  const out = new Float32Array(n * n);
+  const salt = Math.imul(seed | 0, 2654435761) + 17;
+  if (pattern === "smooth") return out.fill(1);
+  const noise = (cx, cy, oct, s = 0) => new TileableNoise(n, cx, cy, oct, salt + s);
+  const k = n / GRAIN_TILE;
+  switch (pattern) {
+    case "cold-pressed": {
+      const base = noise(20 * k, 20 * k, 4);
+      const fine = noise(64 * k, 64 * k, 2, 3);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.8 + 0.5 + (fine.at(x, y) - 0.5) * 0.5 + (hash2(x, y, salt) - 0.5) * 0.12);
+      break;
+    }
+    case "hot-pressed": {
+      const base = noise(40 * k, 40 * k, 3);
+      for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.1 + 0.6 + (hash2(x, y, salt) - 0.5) * 0.08);
+      break;
+    }
+    case "rough": {
+      const base = noise(10 * k, 10 * k, 5);
+      const blot = noise(28 * k, 28 * k, 2, 5);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 2.4 + 0.5 + (blot.at(x, y) - 0.5) * 0.7 + (hash2(x, y, salt) - 0.5) * 0.15);
+      break;
+    }
+    case "vellum": {
+      const base = noise(40 * k, 40 * k, 3);
+      for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.6 + 0.55 + (hash2(x, y, salt) - 0.5) * 0.2);
+      break;
+    }
+    case "laid": {
+      const pulp = noise(32 * k, 32 * k, 3);
+      const chain = n / 8;
+      for (let y = 0; y < n; y++) {
+        const laid = 0.5 + 0.5 * Math.cos(2 * Math.PI * y / 4);
+        for (let x = 0; x < n; x++) {
+          const c = Math.abs((x + 0.5) % chain - chain / 2) / (chain / 2);
+          const chainLine = c > 0.94 ? -0.35 : 0;
+          out[y * n + x] = clamp01(0.3 + 0.5 * laid + chainLine + (pulp.at(x, y) - 0.5) * 0.6);
+        }
+      }
+      break;
+    }
+    case "ingres": {
+      const fibres = noise(64 * k, 12 * k, 3);
+      const base = noise(16 * k, 16 * k, 3, 7);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const g = hash2(x, y, salt ^ 85);
+          out[y * n + x] = clamp01((fibres.at(x, y) - 0.5) * 1.5 + (base.at(x, y) - 0.5) * 0.7 + 0.55 + (g < 0.1 ? -0.3 : 0));
+        }
+      break;
+    }
+    case "sanded": {
+      const grit = noise(96 * k, 96 * k, 2);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const h = hash2(x, y, salt);
+          out[y * n + x] = clamp01((grit.at(x, y) - 0.5) * 2.4 + 0.5 + (h - 0.5) * 0.7);
+        }
+      break;
+    }
+    case "canvas":
+    case "linen": {
+      const period = (pattern === "canvas" ? 8 : 5) * k;
+      const threads = Math.max(2, 2 * Math.round(n / period / 2));
+      const p = n / threads;
+      const slub = noise(threads, threads, 2, 11);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const fx = (x + 0.5) / p;
+          const fy = (y + 0.5) / p;
+          const cx = Math.floor(fx);
+          const cy = Math.floor(fy);
+          const warp = Math.sin(Math.PI * (fx - cx));
+          const weft = Math.sin(Math.PI * (fy - cy));
+          const top = (cx + cy) % 2 === 0 ? warp : weft;
+          const irregular = pattern === "linen" ? (slub.at(x, y) - 0.5) * 0.5 : 0;
+          out[y * n + x] = clamp01(0.2 + 0.7 * top + irregular + (hash2(x, y, salt) - 0.5) * 0.15);
+        }
+      break;
+    }
+    case "gesso": {
+      const streaks = noise(2 * k, 28 * k, 3);
+      const tooth = noise(64 * k, 64 * k, 2, 13);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((streaks.at(x, y) - 0.5) * 1.8 + (tooth.at(x, y) - 0.5) * 0.9 + 0.55);
+      break;
+    }
+  }
+  return out;
+}
+var rawCache = /* @__PURE__ */ new Map();
+function grainHeights(pattern, seed, size = GRAIN_TILE) {
+  const key = `${pattern}:${seed}:${size}`;
+  let h = rawCache.get(key);
+  if (!h) {
+    h = patternHeights(pattern, size, seed);
+    if (rawCache.size > 32) rawCache.delete(rawCache.keys().next().value);
+    rawCache.set(key, h);
+  }
+  return h;
+}
+var PaperGrain = class {
+  size = GRAIN_TILE;
+  heights;
+  scale;
+  mirror;
+  ox;
+  oy;
+  flat;
+  constructor(paper, media = "dry") {
+    const raw = grainHeights(paper.pattern, paper.seed);
+    const t = paper[media];
+    this.flat = paper.pattern === "smooth";
+    if (t.contrast === 1 && !t.invert) this.heights = raw;
+    else {
+      const out = new Float32Array(raw.length);
+      for (let i = 0; i < raw.length; i++) {
+        const v = clamp01((raw[i] - 0.5) * t.contrast + 0.5);
+        out[i] = t.invert ? 1 - v : v;
+      }
+      this.heights = out;
+    }
+    this.scale = paper.scale;
+    this.mirror = paper.tiling === "mirror";
+    this.ox = paper.offset?.x ?? 0;
+    this.oy = paper.offset?.y ?? 0;
+  }
+  /** Tile cell index for a coordinate in grain pixels (mirrored on odd tiles when mirroring). */
+  wrap(v) {
+    const n = this.size;
+    if (!this.mirror) return (v % n + n) % n;
+    const p = (v % (2 * n) + 2 * n) % (2 * n);
+    return p < n ? p : 2 * n - 1 - p;
+  }
+  /** Height 0..1 at document position (x, y). */
+  at(x, y) {
+    const u = (x - this.ox) / this.scale - 0.5;
+    const v = (y - this.oy) / this.scale - 0.5;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    const n = this.size;
+    const h = this.heights;
+    const a = this.wrap(x0);
+    const b = this.wrap(x0 + 1);
+    const c = this.wrap(y0) * n;
+    const d = this.wrap(y0 + 1) * n;
+    const top = h[c + a] + (h[c + b] - h[c + a]) * fx;
+    const bot = h[d + a] + (h[d + b] - h[d + a]) * fx;
+    return top + (bot - top) * fy;
+  }
+};
+function grainCatch(h, depth, pressure) {
+  if (depth <= 0) return 1;
+  const t = depth * (0.75 - 0.65 * Math.min(1, Math.max(0, pressure)));
+  const u = clamp01((h - t + 0.18) / 0.36);
+  return 1 - depth + depth * u * u * (3 - 2 * u);
+}
+function strokeGrainCatch(h, depth, pressure) {
+  if (depth <= 0) return 1;
+  const p = Math.min(1, Math.max(0, pressure));
+  const amount = Math.min(1, depth * (1.4 - 0.6 * p));
+  const u = clamp01((h - 0.2 - 0.25 * (1 - p)) / 0.5);
+  return 1 - amount + amount * u * u * (3 - 2 * u);
+}
+
+// src/paint/path-stroke.ts
+var JITTER_SIZE = 1;
+var JITTER_ANGLE = 2;
+var JITTER_OPACITY = 3;
+var JITTER_SCATTER = 4;
+function lean(s) {
+  if (typeof s.altitude === "number" && Number.isFinite(s.altitude)) {
+    return { amount: 1 - Math.min(1, Math.max(0, s.altitude / (Math.PI / 2))), azimuth: s.azimuth ?? 0 };
+  }
+  if (typeof s.tiltX === "number" || typeof s.tiltY === "number") {
+    const tx = (s.tiltX ?? 0) * Math.PI / 180;
+    const ty = (s.tiltY ?? 0) * Math.PI / 180;
+    if (tx === 0 && ty === 0) return { amount: 0, azimuth: 0 };
+    const az = Math.atan2(Math.tan(ty), Math.tan(tx));
+    const alt = Math.atan(1 / Math.hypot(Math.tan(tx), Math.tan(ty)));
+    return { amount: 1 - alt / (Math.PI / 2), azimuth: az };
+  }
+  return null;
+}
+function pathStrokeDabs(samples, options) {
+  const brush = normalizeBrush(options.brush);
+  const pts = options.closed && samples.length > 2 ? [...samples, samples[0]] : [...samples];
+  if (!pts.length) return [];
+  const tilt = options.tilt ?? {};
+  const minSize = Math.min(1, Math.max(0, options.minSize ?? 0));
+  let index = 0;
+  const t0 = pts.find((s) => typeof s.t === "number" && Number.isFinite(s.t))?.t ?? null;
+  const dab = (x, y, p, l, dir, travel = 0, time = null, speed = null) => {
+    const pr = Math.min(1, Math.max(0, p));
+    const lean0 = l?.amount ?? 0;
+    const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * pr : 1) * (1 + 1.5 * (tilt.size ?? 0) * lean0);
+    let angle = brush.angle * Math.PI / 180;
+    if (options.followPath) angle += dir;
+    if (tilt.followAzimuth && l) angle = -l.azimuth;
+    const roundness = Math.max(0.05, brush.roundness * (1 - 0.85 * (tilt.roundness ?? 0) * lean0));
+    const op = brush.pressureOpacity ? pr : 1;
+    const i = index++;
+    const params = { travel, index: i, pressure: pr, lean: lean0, speed, direction: dir, time: time === null || t0 === null ? null : time - t0 };
+    let diameter = size;
+    let opacity = brush.opacity * op;
+    const j = options.jitter;
+    if (j) {
+      if (j.size) diameter *= Math.max(0.05, 1 + j.size * randSigned(j.seed, i, JITTER_SIZE));
+      if (j.angle) angle += j.angle * Math.PI * randSigned(j.seed, i, JITTER_ANGLE);
+      if (j.opacity) opacity *= 1 - j.opacity * (randSigned(j.seed, i, JITTER_OPACITY) * 0.5 + 0.5);
+      if (j.scatter) {
+        const off = j.scatter * diameter * randSigned(j.seed, i, JITTER_SCATTER);
+        x += Math.sin(dir) * off;
+        y += Math.cos(dir) * off;
+      }
+    }
+    return { x, y, radius: Math.max(0.5, diameter / 2), alpha: brush.flow, opacity, angle, roundness, params };
+  };
+  const out = [];
+  const pressure = (s) => typeof s.pressure === "number" && Number.isFinite(s.pressure) ? s.pressure : 1;
+  if (pts.length === 1) {
+    out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), 0));
+    return out;
+  }
+  let carry = 0;
+  let along = 0;
+  const timeOf = (s) => typeof s.t === "number" && Number.isFinite(s.t) ? s.t : null;
+  out.push(dab(pts[0].x, pts[0].y, pressure(pts[0]), lean(pts[0]), Math.atan2(-(pts[1].y - pts[0].y), pts[1].x - pts[0].x), 0, timeOf(pts[0])));
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const a = pts[i];
+    const b = pts[i + 1];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len = Math.hypot(dx, dy);
+    if (len === 0) continue;
+    const dir = Math.atan2(-dy, dx);
+    const la = lean(a);
+    const lb = lean(b);
+    const ta = timeOf(a);
+    const tb = timeOf(b);
+    const speed = ta !== null && tb !== null && tb > ta ? len / (tb - ta) : null;
+    let t = carry;
+    for (; ; ) {
+      const f = t / len;
+      if (f > 1) break;
+      const p = pressure(a) + (pressure(b) - pressure(a)) * f;
+      const l = la && lb ? { amount: la.amount + (lb.amount - la.amount) * f, azimuth: la.azimuth + (lb.azimuth - la.azimuth) * f } : la ?? lb;
+      const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * p : 1);
+      const step = Math.max(0.5, size * brush.spacing);
+      if (t > 0 || i > 0) out.push(dab(a.x + dx * f, a.y + dy * f, p, l, dir, along + t, ta !== null && tb !== null ? ta + (tb - ta) * f : null, speed));
+      t += step;
+    }
+    carry = t - len;
+    along += len;
+  }
+  return out;
+}
+function pathStrokeCoverage(samples, options) {
+  const brush = normalizeBrush(options.brush);
+  const coverage = new CoverageMap();
+  const dabs = pathStrokeDabs(samples, options);
+  const g = options.gradient?.paint.type === "gradient" ? options.gradient : null;
+  const sampler = g ? new PaintGradientSampler(resolvePaintGradient(g.paint, g.colors ?? { paint: "#000000", secondary: "#ffffff" }), g.seed ?? 0) : null;
+  const tipTable = sampler?.acrossTip ? sampler.tipTable(TIP_GRADIENT_STEPS) : null;
+  const scratch = { field: new Float32Array(0), sample: { rgb: [0, 0, 0], alpha: 1 } };
+  let buf = new Float32Array(0);
+  let bounds = null;
+  for (const d of dabs) {
+    const rect = dabRect(d, brush.hardness);
+    const n = rect.width * rect.height;
+    if (n <= 0) continue;
+    if (buf.length < n) buf = new Float32Array(n);
+    const vals = buf.subarray(0, n);
+    rasterizeDab(d, brush.hardness, rect, vals);
+    if (sampler) {
+      const { color, field } = gradientDabColor(sampler, tipTable, d, d.params, rect, vals, scratch);
+      coverage.accumulate(rect, vals, d.opacity, color, field);
+    } else coverage.accumulate(rect, vals, d.opacity);
+    if (!bounds) bounds = { ...rect };
+    else {
+      const x = Math.min(bounds.x, rect.x);
+      const y = Math.min(bounds.y, rect.y);
+      bounds = { x, y, width: Math.max(bounds.x + bounds.width, rect.x + rect.width) - x, height: Math.max(bounds.y + bounds.height, rect.y + rect.height) - y };
+    }
+  }
+  const grain = options.grain;
+  if (grain && grain.depth > 0 && dabs.length) {
+    const pressure = dabs.reduce((sum, d) => sum + (d.params?.pressure ?? 1), 0) / dabs.length;
+    for (const [key, t] of coverage.tiles) {
+      const { tx, ty } = tileCoord(key);
+      for (let y = 0, k = 0; y < TILE; y++) {
+        const gy = ty * TILE + y + 0.5;
+        for (let x = 0; x < TILE; x++, k++) if (t[k] > 0) t[k] *= strokeGrainCatch(grain.at(tx * TILE + x + 0.5, gy), grain.depth, pressure);
+      }
+    }
+  }
+  return { coverage, bounds, dabs: dabs.length };
+}
+function paintPathStroke(surface, samples, options) {
+  if (surface.channels !== 4) throw new Error("paintPathStroke paints RGBA surfaces (4 channels).");
+  const brush = normalizeBrush(options.brush);
+  const hex = (c) => "#" + [0, 1, 2].map((i) => Math.round(Math.min(255, Math.max(0, c[i]))).toString(16).padStart(2, "0")).join("");
+  let color = options.color;
+  if (options.paint?.paint.type === "color") {
+    const rgb = hexToPaintRgb(options.paint.paint.color).map((v) => Math.round(v * 255));
+    color = [rgb[0], rgb[1], rgb[2], color[3]];
+  }
+  const gradient = options.paint?.paint.type === "gradient" ? { ...options.paint, colors: options.paint.colors ?? { paint: hex(color), secondary: "#ffffff" } } : null;
+  const { coverage, bounds, dabs } = pathStrokeCoverage(samples, { ...options, gradient });
+  if (!bounds) return { surface, bounds: null, dabs };
+  const offset = options.offset ?? { x: 0, y: 0 };
+  const apply = {
+    mode: options.mode ?? "paint",
+    color,
+    background: [0, 0, 0, 0],
+    opacity: brush.opacity,
+    blend: options.blend ?? brush.blend,
+    lockTransparency: options.lockTransparency ?? false,
+    selection: options.selection ?? null,
+    offset
+  };
+  const tiles = new Map(surface.tiles);
+  for (const { tx, ty } of tilesInRect({ x: bounds.x - offset.x, y: bounds.y - offset.y, width: bounds.width, height: bounds.height })) {
+    const key = tileKey(tx, ty);
+    const src = surface.tiles.get(key)?.data;
+    const base = src && src.length === TILE * TILE * 4 ? src : new Uint8ClampedArray(TILE * TILE * 4);
+    const t = finishTile(applyStrokeToTile(coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
+    if (t) tiles.set(key, t);
+    else tiles.delete(key);
+  }
+  return { surface: new TiledSurface(4, tiles, surface.defaultValue), bounds, dabs };
+}
+
+// src/paint/brushstroke.ts
+var DEFAULT_MAX_PIXELS = 4096 * 4096;
+var isProfilePath = (input) => !Array.isArray(input) && typeof input === "object" && input !== null && "points" in input;
+function profileAt(profile, f) {
+  if (!profile || !profile.length) return void 0;
+  if (profile.length === 1) return profile[0];
+  const u = Math.min(1, Math.max(0, f)) * (profile.length - 1);
+  const i = Math.min(profile.length - 2, Math.floor(u));
+  return profile[i] + (profile[i + 1] - profile[i]) * (u - i);
+}
+function brushstrokeSamples(input) {
+  if (!isProfilePath(input)) return input.map((s) => ({ ...s }));
+  const pts = input.points;
+  const lengths = [0];
+  for (let i = 1; i < pts.length; i++) lengths.push(lengths[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y));
+  const total = lengths.at(-1) ?? 0;
+  return pts.map((p, i) => {
+    const f = total > 0 ? lengths[i] / total : pts.length > 1 ? i / (pts.length - 1) : 0;
+    const s = { x: p.x, y: p.y };
+    const pressure = profileAt(input.pressure, f);
+    const tiltX = profileAt(input.tiltX, f);
+    const tiltY = profileAt(input.tiltY, f);
+    if (pressure !== void 0) s.pressure = pressure;
+    if (tiltX !== void 0) s.tiltX = tiltX;
+    if (tiltY !== void 0) s.tiltY = tiltY;
+    return s;
+  });
+}
+var REFUSED_ENGINES = {
+  wet: "is a wet brush, and wet paint needs an area to flow in (paint it on a wet layer in the paint editor)",
+  mixer: "is a Mixer Brush, which picks up paint from under the tip and has none on a standalone stroke",
+  blender: "is a blender, which only moves paint that is already there",
+  smudge: "is a smudge brush, which only moves paint that is already there",
+  eraser: "is an eraser, which has nothing to remove on a standalone stroke"
+};
+function brushstrokeStrokeOptions(brush) {
+  if (!brush || typeof brush !== "object") throw new Error("A brushstroke needs a brush: tip settings ({ size, hardness, \u2026 }) or a paint brush preset.");
+  if (!("tip" in brush) || !brush.tip) return { brush: normalizeBrush(brush) };
+  const engine = brush.engine ?? "dab";
+  if (engine !== "dab") {
+    const label = brush.name ?? brush.id ?? "This brush";
+    const why = REFUSED_ENGINES[engine] ?? `uses the '${engine}' engine, which renderBrushstroke does not draw`;
+    throw new Error(`Brushstrokes render dry media only: '${label}' ${why}. Pick a dry brush (a dab-engine preset such as a pencil, pastel, charcoal, marker, ink or airbrush) or plain tip settings.`);
+  }
+  const d = brush.dynamics ?? {};
+  const tilt = { size: d.tiltSize ?? 0, roundness: d.tiltRoundness ?? 0 };
+  return {
+    brush: normalizeBrush(brush.tip),
+    followPath: brush.rotation === "stroke",
+    minSize: d.minSize ?? 0,
+    ...tilt.size || tilt.roundness ? { tilt } : {}
+  };
+}
+function isBrushstrokeBrush(brush) {
+  return !("tip" in brush) || !brush.tip || (brush.engine ?? "dab") === "dab";
+}
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+function brushCharacterOf(brush) {
+  if (!("tip" in brush) || !brush.tip) return { grain: 0, size: 0, angle: 0, opacity: 0, scatter: 0 };
+  const d = brush.dynamics ?? {};
+  const u = (v, hi = 1) => finite(v) ? Math.min(hi, Math.max(0, v)) : 0;
+  return { grain: u(brush.grain), size: u(d.sizeJitter), angle: u(d.angleJitter), opacity: u(d.opacityJitter), scatter: u(d.scatter, 4) };
+}
+var papers = /* @__PURE__ */ new Map();
+function paperGrain(paper) {
+  const pattern = paper.pattern ?? "sanded";
+  const seed = finite(paper.seed) ? Math.round(Math.abs(paper.seed)) : 1;
+  const scale = finite(paper.scale) && paper.scale > 0 ? Math.min(8, Math.max(0.25, paper.scale)) : 1;
+  const key = `${pattern}:${seed}:${scale}`;
+  let g = papers.get(key);
+  if (!g) {
+    g = new PaperGrain({ pattern, seed, scale, tiling: "mirror", dry: { contrast: 1, invert: false }, wet: { contrast: 1, invert: false } });
+    if (papers.size > 16) papers.delete(papers.keys().next().value);
+    papers.set(key, g);
+  }
+  return g;
+}
+function renderBrushstroke(input, brush, options = {}) {
+  const strokeOptions = brushstrokeStrokeOptions(brush);
+  const samples = brushstrokeSamples(input);
+  for (const s of samples) if (!finite(s.x) || !finite(s.y)) throw new Error("Brushstroke samples need finite x and y.");
+  const solid = options.paint && !("type" in options.paint) ? options.paint.color : null;
+  const source = options.paint && "type" in options.paint ? options.paint : null;
+  const color = solid ?? options.color ?? [0, 0, 0, 255];
+  let scale = finite(options.scale) && options.scale > 0 ? Math.min(BRUSHSTROKE_MAX_SCALE, Math.max(BRUSHSTROKE_MIN_SCALE, options.scale)) : 1;
+  if (!samples.length) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs: 0 };
+  const tip = strokeOptions.brush;
+  const reach = tip.size * (1 + 1.5 * (strokeOptions.tilt?.size ?? 0)) + 4;
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const s of samples) {
+    x0 = Math.min(x0, s.x);
+    y0 = Math.min(y0, s.y);
+    x1 = Math.max(x1, s.x);
+    y1 = Math.max(y1, s.y);
+  }
+  const maxPixels = finite(options.maxPixels) && options.maxPixels > 0 ? options.maxPixels : DEFAULT_MAX_PIXELS;
+  const area = (x1 - x0 + reach) * (y1 - y0 + reach);
+  if (area * scale * scale > maxPixels) scale = Math.max(BRUSHSTROKE_MIN_SCALE, Math.sqrt(maxPixels / area));
+  const scaled = samples.map((s) => ({ ...s, x: s.x * scale, y: s.y * scale }));
+  let character = {};
+  if (options.character) {
+    const c = brushCharacterOf(brush);
+    const ch = options.character;
+    const seed = finite(ch.seed) ? ch.seed | 0 : hashString(JSON.stringify(input));
+    const jitter = c.size || c.angle || c.opacity || c.scatter ? { seed, size: c.size, angle: c.angle, opacity: c.opacity, scatter: c.scatter } : void 0;
+    const paper = ch.paper === null ? null : ch.paper ?? {};
+    const depth = paper ? Math.min(1, Math.max(0, (finite(paper.depth) ? paper.depth : 0.5) * c.grain)) : 0;
+    let grain;
+    if (paper && depth > 0) {
+      const g = paperGrain(paper);
+      const ox = ch.origin?.x ?? 0;
+      const oy = ch.origin?.y ?? 0;
+      const k = (finite(ch.unit) && ch.unit > 0 ? ch.unit : 1) / scale;
+      grain = { depth, at: (x, y) => g.at(ox + x * k, oy + y * k) };
+    }
+    character = { ...jitter ? { jitter } : {}, ...grain ? { grain } : {} };
+  }
+  const { surface, bounds, dabs } = paintPathStroke(emptySurface(4), scaled, {
+    ...strokeOptions,
+    ...character,
+    brush: { ...tip, size: tip.size * scale },
+    closed: options.closed ?? strokeOptions.closed,
+    color,
+    // Gradient lengths are in path units: scale them with the image.
+    ...source ? { paint: { paint: source.type === "gradient" ? scalePaintGradient(source, scale) : source, seed: options.seed ?? 0 } } : {}
+  });
+  if (!bounds) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs };
+  const rect = bounds;
+  const data = readRegion(surface, rect);
+  return {
+    image: { width: rect.width, height: rect.height, data },
+    bounds: { x: rect.x / scale, y: rect.y / scale, width: rect.width / scale, height: rect.height / scale },
+    scale,
+    dabs
+  };
+}
+function brushstrokeDataUrl(stroke) {
+  const { width, height, data } = stroke.image;
+  return width && height ? pngDataUrl(width, height, data) : "";
+}
+function brushstrokeToCanvas(stroke, createCanvas) {
+  const { width, height, data } = stroke.image;
+  if (!width || !height) return null;
+  const canvas = createCanvas(width, height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return null;
+  const img = ctx.createImageData(width, height);
+  img.data.set(data);
+  ctx.putImageData(img, 0, 0);
+  return canvas;
+}
+function hashString(s, h = 2166136261) {
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h;
+}
+function brushstrokeKey(input, brush, options = {}) {
+  const path = JSON.stringify(input);
+  const { brush: tip, ...rest } = brushstrokeStrokeOptions(brush);
+  const character = options.character ? [options.character, brushCharacterOf(brush)] : null;
+  const rest2 = JSON.stringify([tip, rest, options.paint ?? options.color ?? null, options.seed ?? 0, options.closed ?? false, options.maxPixels ?? null, ...character ? [character] : []]);
+  const scale = finite(options.scale) ? options.scale : 1;
+  return `${hashString(path).toString(16)}:${path.length}:${hashString(rest2).toString(16)}:${scale}`;
+}
+var BrushstrokeCache = class {
+  constructor(capacity = 64) {
+    this.capacity = capacity;
+  }
+  capacity;
+  entries = /* @__PURE__ */ new Map();
+  /** Renders that missed the cache (for tests and stats). */
+  misses = 0;
+  get size() {
+    return this.entries.size;
+  }
+  /** The cached stroke for these arguments, rendering (and caching) it on a miss. */
+  render(input, brush, options = {}) {
+    const key = brushstrokeKey(input, brush, options);
+    const hit = this.entries.get(key);
+    if (hit) {
+      this.entries.delete(key);
+      this.entries.set(key, hit);
+      return hit;
+    }
+    this.misses++;
+    const out = renderBrushstroke(input, brush, options);
+    this.entries.set(key, out);
+    while (this.entries.size > Math.max(1, this.capacity)) this.entries.delete(this.entries.keys().next().value);
+    return out;
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+
+export {
+  GRAIN_PATTERNS,
+  GRAIN_TILE,
+  grainHeights,
+  PaperGrain,
+  grainCatch,
+  strokeGrainCatch,
+  pathStrokeDabs,
+  pathStrokeCoverage,
+  paintPathStroke,
+  brushstrokeSamples,
+  brushstrokeStrokeOptions,
+  isBrushstrokeBrush,
+  renderBrushstroke,
+  brushstrokeDataUrl,
+  brushstrokeToCanvas,
+  brushstrokeKey,
+  BrushstrokeCache
+};

package/dist/{chunk-GXAK6Q5J.js → chunk-UFEDHACQ.js}

@@ -11,10 +11,10 @@ import {
   CHART_OOXML_NS,
   CHART_OOXML_RELATIONSHIP,
   chartToOoxml
-} from "./chunk-36ZTV7WO.js";
+} from "./chunk-L6Y7TSQ4.js";
 import {
   normalizeChartSpec
-} from "./chunk-QARCM66V.js";
+} from "./chunk-6ZZKRH7R.js";
 
 // src/export/images.ts
 var DOCX_IMAGE_TYPES = {

package/dist/{chunk-GA4EU4P3.cjs → chunk-UXETV2NC.cjs}

@@ -8,7 +8,7 @@ var _chunkA6QWKBJPcjs = require('./chunk-A6QWKBJP.cjs');
 
 
 
-var _chunkRD7RX52Gcjs = require('./chunk-RD7RX52G.cjs');
+var _chunk5UEFBM2Mcjs = require('./chunk-5UEFBM2M.cjs');
 
 // src/tokens/types.ts
 var TOKEN_TYPES = ["color", "number", "string", "boolean"];
@@ -1389,10 +1389,10 @@ var contrastPairs = {
         const modes = { [collection.id]: mode.id, [b.collectionId]: _nullishCoalesce(_optionalChain([findTokenMode, 'call', _26 => _26(getTokenCollection(state, b.collectionId), mode.name), 'optionalAccess', _27 => _27.id]), () => ( mode.id)) };
         const fv = resolveToken(state, f.id, modes);
         const bv = resolveToken(state, b.id, modes);
-        const fc = fv.ok && typeof fv.value === "string" ? _chunkRD7RX52Gcjs.parseColor.call(void 0, fv.value) : null;
-        const bc = bv.ok && typeof bv.value === "string" ? _chunkRD7RX52Gcjs.parseColor.call(void 0, bv.value) : null;
+        const fc = fv.ok && typeof fv.value === "string" ? _chunk5UEFBM2Mcjs.parseColor.call(void 0, fv.value) : null;
+        const bc = bv.ok && typeof bv.value === "string" ? _chunk5UEFBM2Mcjs.parseColor.call(void 0, bv.value) : null;
         if (!fc || !bc) continue;
-        const r = _chunkRD7RX52Gcjs.contrastRatio.call(void 0, fc, bc);
+        const r = _chunk5UEFBM2Mcjs.contrastRatio.call(void 0, fc, bc);
         if (r < ratio) {
           findings.push({
             severity: "error",

package/dist/{chunk-N4DFDI73.js → chunk-WKMUBATU.js}

@@ -12,7 +12,7 @@ import {
   chartTreeTotal,
   chartVariesColors,
   shadeChartColor
-} from "./chunk-QARCM66V.js";
+} from "./chunk-6ZZKRH7R.js";
 import {
   NumberFormat
 } from "./chunk-II2WIF5Z.js";

package/dist/{chunk-3R5P3DVY.cjs → chunk-WRZ6C4TU.cjs}

@@ -1,12 +1,12 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunk7PT4RJL5cjs = require('./chunk-7PT4RJL5.cjs');
+var _chunkEUIDTZNQcjs = require('./chunk-EUIDTZNQ.cjs');
 
 
-var _chunkPPFJHTW5cjs = require('./chunk-PPFJHTW5.cjs');
+var _chunkTFF2GTGNcjs = require('./chunk-TFF2GTGN.cjs');
 
 
-var _chunk7AHBW2CQcjs = require('./chunk-7AHBW2CQ.cjs');
+var _chunk5UEFBM2Mcjs = require('./chunk-5UEFBM2M.cjs');
 
 // src/chart/color.ts
 var NAMED = {
@@ -83,18 +83,18 @@ function chartTextOn(fill, fallback, dark = "#0f172a", light = "#ffffff") {
   return darkRatio >= lightRatio ? dark : light;
 }
 function chartRgbToOklab(rgb) {
-  const lab = _chunk7AHBW2CQcjs.rgbToOklab.call(void 0, { r: rgb[0], g: rgb[1], b: rgb[2], a: 1 });
+  const lab = _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, { r: rgb[0], g: rgb[1], b: rgb[2], a: 1 });
   return [lab.l, lab.a, lab.b];
 }
 function chartColorDistance(a, b) {
-  return _chunkPPFJHTW5cjs.deltaEOK.call(void 0, 
+  return _chunkTFF2GTGNcjs.deltaEOK.call(void 0, 
     { r: a[0], g: a[1], b: a[2], a: 1 },
     { r: b[0], g: b[1], b: b[2], a: 1 }
   );
 }
 function simulateChartVision(rgb, vision) {
   if (vision === "normal") return rgb;
-  const c = _chunk7PT4RJL5cjs.simulateColorVision.call(void 0, { r: rgb[0], g: rgb[1], b: rgb[2], a: 1 }, vision);
+  const c = _chunkEUIDTZNQcjs.simulateColorVision.call(void 0, { r: rgb[0], g: rgb[1], b: rgb[2], a: 1 }, vision);
   return [c.r, c.g, c.b];
 }
 function checkChartColors(colors, options = {}) {