@pixerate/editor 0.246.0 → 0.249.0

package/dist/{chunk-VDAWA546.js → chunk-J7T5QZ45.js}

@@ -1,3 +1,12 @@
+import {
+  STAMP_KINDS,
+  StickerError,
+  describeStickerRef,
+  editorStampOf,
+  normalizeStickerRef,
+  stampCoverage,
+  stickerIdFor
+} from "./chunk-5RH3VXAK.js";
 import {
   CoverageMap,
   DEFAULT_BLENDER,
@@ -11,16 +20,22 @@ import {
   TileMedium,
   dabRect,
   grainCatch,
-  hash2,
   normalizeBlender,
   normalizeBrush,
   normalizeMixer,
   normalizeSmudge,
-  rand01,
-  randSigned,
   rasterizeDab,
   readPaintSource
-} from "./chunk-2PBZBRP5.js";
+} from "./chunk-D5KGAO4Z.js";
+import {
+  hash2,
+  rand01,
+  randSigned
+} from "./chunk-4D6KP5BV.js";
+import {
+  decodePng,
+  parseDataUrl
+} from "./chunk-OTTT5N3K.js";
 import {
   TILE,
   TiledSurface,
@@ -586,14 +601,129 @@ function toStrokePoint(p) {
   return { x: p.x, y: p.y, pressure: pressureOf(p), ...typeof p.t === "number" ? { t: p.t } : {} };
 }
 
+// src/paint-editor/sticker-art.ts
+var STICKER_ART_SIZE = 256;
+var defaultStickerRasterizer = async (asset, size) => {
+  if (asset.kind === "image") {
+    const parsed = parseDataUrl(asset.url);
+    if (parsed && parsed.mime === "image/png") {
+      const png = decodePng(parsed.bytes);
+      return { width: png.width, height: png.height, data: new Uint8ClampedArray(png.data) };
+    }
+  }
+  const g = globalThis;
+  if (!g.createImageBitmap || !g.OffscreenCanvas) {
+    throw new StickerError("unsupported_format", `This environment can't draw ${asset.kind === "svg" ? "SVG" : "non-PNG"} sticker art; pass rasterizeSticker in the paint editor's options (or use a provider that offers png).`);
+  }
+  const blob = asset.kind === "svg" ? new Blob([asset.svg], { type: "image/svg+xml" }) : await (await g.fetch(asset.url)).blob();
+  const bitmap = await g.createImageBitmap(blob);
+  const scale = size / Math.max(bitmap.width, bitmap.height, 1);
+  const w = Math.max(1, Math.round(bitmap.width * scale));
+  const h = Math.max(1, Math.round(bitmap.height * scale));
+  const canvas = new g.OffscreenCanvas(w, h);
+  const ctx = canvas.getContext("2d");
+  ctx.drawImage(bitmap, 0, 0, w, h);
+  const img = ctx.getImageData(0, 0, w, h);
+  return { width: w, height: h, data: img.data };
+};
+var StickerArtCache = class {
+  entries = /* @__PURE__ */ new Map();
+  /** The art for `ref` when it has loaded (editor stamps never need any). */
+  get = (ref) => {
+    const e = this.entries.get(ref);
+    return e?.status === "ready" ? e.art : void 0;
+  };
+  /** `ready`, `loading`, `failed` (with the reason) or `none` (never asked for). Editor stamps are always `ready`. */
+  status(ref) {
+    if (editorStampOf(ref)) return { status: "ready" };
+    const e = this.entries.get(ref);
+    if (!e) return { status: "none" };
+    return e.status === "failed" ? { status: "failed", error: e.error } : { status: e.status };
+  }
+  /**
+   * Loads and rasterises `ref` from `provider` once (later calls share the load). Unknown refs
+   * reject with the closest known ones; failures are kept so they are reported, and retried on
+   * the next call.
+   */
+  ensure(provider, ref, rasterize) {
+    if (editorStampOf(ref)) return Promise.resolve(null);
+    const e = this.entries.get(ref);
+    if (e?.status === "ready") return Promise.resolve(e.art);
+    if (e?.status === "loading") return e.promise;
+    const promise = (async () => {
+      const d = await describeStickerRef(provider, ref);
+      const id = stickerIdFor(provider, ref);
+      const max = provider.capabilities.maxSize ?? STICKER_ART_SIZE;
+      const size = Math.min(STICKER_ART_SIZE, max);
+      const asset = await provider.load(id, d.formats.includes("png") ? { format: "png", size } : { format: d.formats[0] ?? "svg", size });
+      const px = await rasterize(asset, size);
+      if (!(px.width > 0 && px.height > 0) || px.data.length !== px.width * px.height * 4) throw new StickerError("load_failed", `The art for "${ref}" came back empty or the wrong size.`);
+      return { ...px, tintable: d.tintable };
+    })();
+    this.entries.set(ref, { status: "loading", promise });
+    return promise.then(
+      (art) => {
+        this.entries.set(ref, { status: "ready", art });
+        return art;
+      },
+      (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        this.entries.set(ref, { status: "failed", error: message });
+        throw err;
+      }
+    );
+  }
+  /** Forgets every load (a new provider). */
+  clear() {
+    this.entries.clear();
+  }
+};
+function sampleArt(art, x, y, out) {
+  const { width: w, height: h, data } = art;
+  const fx = x - 0.5;
+  const fy = y - 0.5;
+  const x0 = Math.floor(fx);
+  const y0 = Math.floor(fy);
+  const tx = fx - x0;
+  const ty = fy - y0;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 0;
+  for (let k = 0; k < 4; k++) {
+    const xx = x0 + (k & 1);
+    const yy = y0 + (k >> 1);
+    if (xx < 0 || yy < 0 || xx >= w || yy >= h) continue;
+    const wgt = (k & 1 ? tx : 1 - tx) * (k >> 1 ? ty : 1 - ty);
+    const i = (yy * w + xx) * 4;
+    const al = data[i + 3] * wgt;
+    r += data[i] * al;
+    g += data[i + 1] * al;
+    b += data[i + 2] * al;
+    a += al;
+  }
+  out[0] = a > 0 ? r / a / 255 : 0;
+  out[1] = a > 0 ? g / a / 255 : 0;
+  out[2] = a > 0 ? b / a / 255 : 0;
+  out[3] = a / 255;
+  return out;
+}
+
 // src/paint-editor/stickers.ts
-var STAMP_KINDS = ["dot", "star", "heart", "leaf", "flower", "confetti", "splat", "sparkle", "ring"];
-var DEFAULT_STICKER = { stamps: ["star"], density: 0.4, sizeJitter: 0.4, rotationJitter: 1, scatter: 0.5, colorJitter: 0.2 };
+var MAX_STICKER_STAMPS = 16;
+var DEFAULT_STICKER = { stamps: ["editor:star"], density: 0.4, sizeJitter: 0.4, rotationJitter: 1, scatter: 0.5, colorJitter: 0.2 };
 var unit2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
 function normalizeStickerSettings(raw = {}, base = DEFAULT_STICKER) {
-  const stamps = Array.isArray(raw.stamps) ? raw.stamps.filter((s) => STAMP_KINDS.includes(s)) : base.stamps;
+  const refs = (list) => list.flatMap((s) => {
+    try {
+      return [normalizeStickerRef(s)];
+    } catch {
+      return [];
+    }
+  });
+  const stamps = Array.isArray(raw.stamps) ? refs(raw.stamps) : refs(base.stamps);
   return {
-    stamps: stamps.length ? [...new Set(stamps)] : [...base.stamps],
+    stamps: stamps.length ? [...new Set(stamps)].slice(0, MAX_STICKER_STAMPS) : refs(base.stamps.length ? base.stamps : DEFAULT_STICKER.stamps),
     density: unit2(raw.density, base.density),
     sizeJitter: unit2(raw.sizeJitter, base.sizeJitter),
     rotationJitter: unit2(raw.rotationJitter, base.rotationJitter),
@@ -601,59 +731,6 @@ function normalizeStickerSettings(raw = {}, base = DEFAULT_STICKER) {
     colorJitter: unit2(raw.colorJitter, base.colorJitter)
   };
 }
-function stampCoverage(kind, u, v, t) {
-  const r = Math.hypot(u, v);
-  const a = Math.atan2(v, u);
-  const edge = (d) => Math.min(1, Math.max(0, d * 24 + 0.5));
-  switch (kind) {
-    case "dot":
-      return edge(0.95 - r);
-    case "ring":
-      return edge(Math.min(0.95 - r, r - 0.6));
-    case "star": {
-      const f = (a + Math.PI / 2) * 5 / (2 * Math.PI) % 1;
-      const notch = Math.min(f < 0 ? f + 1 : f, 1 - (f < 0 ? f + 1 : f)) * 2;
-      return edge(0.95 - 0.55 * notch - r);
-    }
-    case "sparkle": {
-      const q = Math.pow(Math.abs(u) / 0.95, 0.6) + Math.pow(Math.abs(v) / 0.95, 0.6);
-      return edge((1 - q) * 0.4);
-    }
-    case "heart": {
-      const x = u * 1.1;
-      const y = -v * 1.1 + 0.15;
-      const q = x * x + y * y - 0.55;
-      return edge(-(q * q * q - x * x * y * y * y) * 3);
-    }
-    case "leaf": {
-      const w = 0.42 * Math.sqrt(Math.max(0, 1 - u * u));
-      const inside = edge(w - Math.abs(v + 0.15 * u * u));
-      const rib = Math.abs(v + 0.15 * u * u) < 0.03 && Math.abs(u) < 0.85 ? 0.65 : 1;
-      return inside * rib;
-    }
-    case "flower": {
-      const petals = 0.6 + 0.35 * Math.abs(Math.cos(2.5 * a));
-      const body = edge(petals - r);
-      return r < 0.22 ? Math.max(body, 1) * 0.85 : body;
-    }
-    case "confetti": {
-      return edge(Math.min(0.9 - Math.abs(u), 0.35 - Math.abs(v)));
-    }
-    case "splat": {
-      let rr = 0.55;
-      for (let k = 1; k <= 3; k++) rr += 0.08 * Math.sin(a * (k + 2) + hash2(k, 1, t) * 6.28) / k;
-      let c = edge(rr - r);
-      for (let k = 0; k < 4; k++) {
-        const ang = hash2(k, 7, t) * Math.PI * 2;
-        const dist = 0.72 + 0.2 * hash2(k, 9, t);
-        const dx = u - Math.cos(ang) * dist;
-        const dy = v - Math.sin(ang) * dist;
-        c = Math.max(c, edge(0.08 + 0.06 * hash2(k, 11, t) - Math.hypot(dx, dy)));
-      }
-      return c;
-    }
-  }
-}
 function hexRgb(hex) {
   const n = parseInt(hex.slice(1, 7), 16);
   return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
@@ -664,7 +741,22 @@ function stickerRect(s) {
   const y0 = Math.floor(s.y - r);
   return { x: x0, y: y0, width: Math.ceil(s.x + r) - x0, height: Math.ceil(s.y + r) - y0 };
 }
-function drawSticker(medium, s) {
+function stickerStamp(s) {
+  if (s.ref) {
+    try {
+      return editorStampOf(s.ref);
+    } catch {
+      return null;
+    }
+  }
+  return s.stamp && STAMP_KINDS.includes(s.stamp) ? s.stamp : null;
+}
+function drawSticker(medium, s, art) {
+  const kind = stickerStamp(s);
+  if (!kind) {
+    const a2 = art?.(s.ref);
+    return a2 ? drawArtSticker(medium, s, a2) : stickerRect(s);
+  }
   const rect = stickerRect(s);
   const n = rect.width * rect.height;
   const cov = new Float32Array(n);
@@ -682,7 +774,7 @@ function drawSticker(medium, s) {
       const v = (-dx * sa + dy * ca) / rad;
       if (u < -1.05 || u > 1.05 || v < -1.05 || v > 1.05) continue;
       let c = 0;
-      for (let k = 0; k < 4; k++) c += stampCoverage(s.stamp, u + ((k & 1) - 0.5) / rad / 2, v + ((k >> 1) - 0.5) / rad / 2, s.seed);
+      for (let k = 0; k < 4; k++) c += stampCoverage(kind, u + ((k & 1) - 0.5) / rad / 2, v + ((k >> 1) - 0.5) / rad / 2, s.seed);
       c /= 4;
       if (c <= 0) continue;
       cov[p] = c;
@@ -695,6 +787,35 @@ function drawSticker(medium, s) {
   medium.deposit(rect, cov, s.opacity, [r, g, b], null, field);
   return rect;
 }
+function drawArtSticker(medium, s, art) {
+  const rect = stickerRect(s);
+  const n = rect.width * rect.height;
+  const cov = new Float32Array(n);
+  const field = new Float32Array(n * 3);
+  const a = s.rotation * Math.PI / 180;
+  const ca = Math.cos(a);
+  const sa = Math.sin(a);
+  const scale = Math.max(art.width, art.height) / s.size;
+  const [r, g, b] = hexRgb(s.color);
+  const px = [0, 0, 0, 0];
+  for (let yy = 0, p = 0; yy < rect.height; yy++) {
+    for (let xx = 0; xx < rect.width; xx++, p++) {
+      const dx = rect.x + xx + 0.5 - s.x;
+      const dy = rect.y + yy + 0.5 - s.y;
+      const ax = (dx * ca + dy * sa) * scale + art.width / 2;
+      const ay = (-dx * sa + dy * ca) * scale + art.height / 2;
+      if (ax < -1 || ay < -1 || ax > art.width + 1 || ay > art.height + 1) continue;
+      sampleArt(art, ax, ay, px);
+      if (!(px[3] > 0)) continue;
+      cov[p] = px[3];
+      field[p * 3] = art.tintable ? r : px[0];
+      field[p * 3 + 1] = art.tintable ? g : px[1];
+      field[p * 3 + 2] = art.tintable ? b : px[2];
+    }
+  }
+  medium.deposit(rect, cov, s.opacity, [r, g, b], null, field);
+  return rect;
+}
 function jitterColor(hex, amount, seed, i) {
   const [r, g, b] = hexRgb(hex);
   const lch = oklabToOklch(rgbToOklab({ r, g, b, a: 1 }));
@@ -730,6 +851,8 @@ var StickerSpray = class {
   init;
   dabCount = 0;
   stickers = [];
+  /** Refs the spray picked but could not draw because their art had not loaded. */
+  skipped = /* @__PURE__ */ new Set();
   smoother;
   walkers;
   copies;
@@ -776,9 +899,17 @@ var StickerSpray = class {
       this.next++;
       return;
     }
+    const ref = st.stamps[Math.floor(rand01(seed, i, 57) * st.stamps.length)] ?? "editor:dot";
+    const stamp = stickerStamp({ ref });
+    if (!stamp && !this.init.art?.(ref)) {
+      this.skipped.add(ref);
+      this.next++;
+      return;
+    }
     const sticker = {
       id: `st${this.next++}`,
-      stamp: st.stamps[Math.floor(rand01(seed, i, 57) * st.stamps.length)] ?? "dot",
+      ref,
+      ...stamp ? { stamp } : {},
       x: Math.round((d.x + Math.cos(a) * dist) * 100) / 100,
       y: Math.round((d.y + Math.sin(a) * dist) * 100) / 100,
       size: Math.max(2, Math.round(size * 10) / 10),
@@ -788,7 +919,7 @@ var StickerSpray = class {
       seed: Math.floor(rand01(seed, i, 65) * 1e9)
     };
     this.stickers.push(sticker);
-    rects.push(drawSticker(this.medium, sticker));
+    rects.push(drawSticker(this.medium, sticker, this.init.art));
     this.dabCount++;
   }
   sampler;
@@ -807,16 +938,24 @@ var StickerSpray = class {
     return { color: "#" + s.rgb.map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join(""), alpha: s.alpha };
   }
 };
-function renderStickers(stickers, target) {
+function renderStickers(stickers, target, art) {
   const medium = new TileMedium(target, {});
-  for (const s of stickers) drawSticker(medium, s);
+  for (const s of stickers) drawSticker(medium, s, art);
 }
 function normalizeStickerUpdate(u) {
   const out = {};
+  if (u.ref !== void 0 && u.stamp !== void 0) throw new Error("Give ref or stamp, not both (stamp is the older name for an editor stamp).");
   if (u.stamp !== void 0) {
-    if (!STAMP_KINDS.includes(u.stamp)) throw new Error(`stamp ${JSON.stringify(u.stamp)} is not a stamp; use ${STAMP_KINDS.join(", ")}.`);
+    if (!STAMP_KINDS.includes(u.stamp)) throw new Error(`stamp ${JSON.stringify(u.stamp)} is not a stamp; use ${STAMP_KINDS.join(", ")}, or ref for any sticker (find_stickers).`);
+    out.ref = `editor:${u.stamp}`;
     out.stamp = u.stamp;
   }
+  if (u.ref !== void 0) {
+    out.ref = normalizeStickerRef(u.ref);
+    const stamp = stickerStamp({ ref: out.ref });
+    if (stamp) out.stamp = stamp;
+    else out.stamp = void 0;
+  }
   for (const k of ["x", "y"]) if (u[k] !== void 0) {
     if (!Number.isFinite(u[k])) throw new Error(`${k} must be a number of pixels.`);
     out[k] = u[k];
@@ -839,7 +978,7 @@ function normalizeStickerUpdate(u) {
   }
   return out;
 }
-function stickerSurface(stickers, base, dirty) {
+function stickerSurface(stickers, base, dirty, art) {
   const only = base && dirty ? new Set(dirty.flatMap((r) => tilesInRect(r).map(({ tx, ty }) => tileKey(tx, ty)))) : null;
   const live = /* @__PURE__ */ new Map();
   let scratch = null;
@@ -857,7 +996,7 @@ function stickerSurface(stickers, base, dirty) {
     }
   };
   const reaches = (s) => !only || tilesInRect(stickerRect(s)).some(({ tx, ty }) => only.has(tileKey(tx, ty)));
-  renderStickers(stickers.filter(reaches), target);
+  renderStickers(stickers.filter(reaches), target, art);
   const tiles = /* @__PURE__ */ new Map();
   if (only && base) {
     for (const [k, t] of base.tiles) if (!only.has(k)) tiles.set(k, t);
@@ -868,7 +1007,7 @@ function stickerSurface(stickers, base, dirty) {
   }
   return new TiledSurface(4, tiles, 0);
 }
-function stickerAt(stickers, x, y) {
+function stickerAt(stickers, x, y, art) {
   for (let i = stickers.length - 1; i >= 0; i--) {
     const s = stickers[i];
     const rad = s.size / 2;
@@ -878,7 +1017,16 @@ function stickerAt(stickers, x, y) {
     const u = (dx * Math.cos(a) + dy * Math.sin(a)) / rad;
     const v = (-dx * Math.sin(a) + dy * Math.cos(a)) / rad;
     if (Math.abs(u) > 1.05 || Math.abs(v) > 1.05) continue;
-    if (s.size < 16 || stampCoverage(s.stamp, u, v, s.seed) > 0.25) return s;
+    if (s.size < 16) return s;
+    const kind = stickerStamp(s);
+    if (kind) {
+      if (stampCoverage(kind, u, v, s.seed) > 0.25) return s;
+      continue;
+    }
+    const pic = art?.(s.ref);
+    if (!pic) return s;
+    const scale = Math.max(pic.width, pic.height) / 2;
+    if (sampleArt(pic, u * scale + pic.width / 2, v * scale + pic.height / 2, [0, 0, 0, 0])[3] > 0.25) return s;
   }
   return null;
 }
@@ -964,9 +1112,56 @@ var MarkStroke = class {
     const rect = dabRect(dab, hardness);
     const n = rect.width * rect.height;
     if (n <= 0) return;
+    const vals = this.scratch(n);
+    rasterizeDab(dab, hardness, rect, vals);
+    this.lay(rect, vals, dab.opacity, pressure, x, y, rects);
+  }
+  /**
+   * Stamps a textured mark: `kind` from the sticker stamps over a square of half-size `r`, turned
+   * `rotation` radians clockwise, with flow `alpha` towards `opacity`. Small marks are supersampled.
+   */
+  stamp(x, y, r, kind, rotation, seed, alpha, opacity, pressure, rects) {
+    if (!(r > 0.05) || !(alpha > 0)) return;
+    const reach = Math.max(0.5, r) * Math.SQRT2 + 1;
+    const rect = { x: Math.floor(x - reach), y: Math.floor(y - reach), width: 0, height: 0 };
+    rect.width = Math.ceil(x + reach) - rect.x;
+    rect.height = Math.ceil(y + reach) - rect.y;
+    const n = rect.width * rect.height;
+    const vals = this.scratch(n);
+    const ss = r < 10 ? 3 : 1;
+    const c = Math.cos(rotation);
+    const s = Math.sin(rotation);
+    const inv = 1 / Math.max(0.5, r);
+    const a = Math.min(1, alpha);
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        let sum = 0;
+        for (let sy = 0; sy < ss; sy++) {
+          for (let sx = 0; sx < ss; sx++) {
+            const dx = rect.x + xx + (sx + 0.5) / ss - x;
+            const dy = rect.y + yy + (sy + 0.5) / ss - y;
+            sum += stampCoverage(kind, (dx * c + dy * s) * inv, (dy * c - dx * s) * inv, seed);
+          }
+        }
+        vals[k] = sum / (ss * ss) * a;
+      }
+    }
+    this.lay(rect, vals, Math.min(1, opacity), pressure, x, y, rects);
+  }
+  /** A scratch buffer of `n` values (reused; valid until the next mark). */
+  scratch(n) {
     if (this.buf.length < n) this.buf = new Float32Array(n);
     const vals = this.buf.subarray(0, n);
-    rasterizeDab(dab, hardness, rect, vals);
+    vals.fill(0);
+    return vals;
+  }
+  /**
+   * Lays coverage `vals` over `rect` towards `opacity`: paper grain, then effect paint or the
+   * colour of a mark at (x, y) (gradient paint), into the stroke's coverage.
+   */
+  lay(rect, vals, opacity, pressure, x, y, rects) {
+    const n = rect.width * rect.height;
+    if (n <= 0) return;
     const grain = this.options.grain;
     if (this.depth > 0 && grain) {
       for (let yy = 0, k = 0; yy < rect.height; yy++)
@@ -976,11 +1171,11 @@ var MarkStroke = class {
       if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
       const field = this.field.subarray(0, n * 3);
       sampleEffectField(this.options.effect, rect, vals, field, this.pen);
-      this.coverage.accumulate(rect, vals, dab.opacity, null, field);
+      this.coverage.accumulate(rect, vals, opacity, null, field);
     } else {
       const color = this.markColor(x, y);
       if (color && color.alpha < 1) for (let k = 0; k < n; k++) vals[k] *= color.alpha;
-      this.coverage.accumulate(rect, vals, dab.opacity, color ? color.rgb : null);
+      this.coverage.accumulate(rect, vals, opacity, color ? color.rgb : null);
     }
     rects.push(rect);
     this.dabCount++;
@@ -993,14 +1188,41 @@ var MarkStroke = class {
     for (let i = 1; i <= n; i++) this.mark(x0 + (x1 - x0) * i / n, y0 + (y1 - y0) * i / n, r, alpha, opacity, pressure, rects);
   }
 };
-var PARTICLE_KINDS = ["string", "spring", "orbit", "flow"];
-var PARTICLE_RENDERS = ["dot", "line", "sequence"];
-var DEFAULT_PARTICLE = { kind: "spring", render: "line", count: 12, size: 0.08, spread: 0.5, stiffness: 0.4, damping: 0.25, speed: 0.5, gravity: 0, life: 0.5, interval: 0.3 };
+var PARTICLE_KINDS = ["string", "spring", "orbit", "flow", "elastic", "fuzzy"];
+var PARTICLE_RENDERS = ["dot", "line", "sequence", "ribbon"];
+var RIBBON_PAIRS = ["adjacent", "first-last"];
+var DOT_TEXTURE_ORDERS = ["sequence", "random"];
+var DOT_ROTATIONS = ["follow", "random", "fixed"];
+var MAX_DOT_TEXTURES = 4;
+var DEFAULT_PARTICLE = {
+  kind: "spring",
+  render: "line",
+  count: 12,
+  size: 0.08,
+  spread: 0.5,
+  stiffness: 0.4,
+  damping: 0.25,
+  speed: 0.5,
+  gravity: 0,
+  life: 0.5,
+  interval: 0.3,
+  ribbonFill: 0.5,
+  ribbonPairs: "adjacent",
+  waveAmplitude: 0,
+  waveLength: 60,
+  waveSpeed: 0,
+  wavePhaseJitter: 0,
+  dotTextures: [],
+  dotTextureOrder: "sequence",
+  dotRotation: "random"
+};
 var unit3 = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+var oneOf = (v, all, d) => all.includes(v) ? v : d;
 function normalizeParticle(raw = {}, base = DEFAULT_PARTICLE) {
+  const textures = Array.isArray(raw.dotTextures) ? raw.dotTextures.filter((t) => STAMP_KINDS.includes(t)).slice(0, MAX_DOT_TEXTURES) : [...base.dotTextures ?? []];
   return {
-    kind: PARTICLE_KINDS.includes(raw.kind) ? raw.kind : base.kind,
-    render: PARTICLE_RENDERS.includes(raw.render) ? raw.render : base.render,
+    kind: oneOf(raw.kind, PARTICLE_KINDS, base.kind),
+    render: oneOf(raw.render, PARTICLE_RENDERS, base.render),
     count: typeof raw.count === "number" && Number.isFinite(raw.count) ? Math.min(64, Math.max(1, Math.round(raw.count))) : base.count,
     size: unit3(raw.size, base.size),
     spread: unit3(raw.spread, base.spread),
@@ -1009,9 +1231,61 @@ function normalizeParticle(raw = {}, base = DEFAULT_PARTICLE) {
     speed: unit3(raw.speed, base.speed),
     gravity: typeof raw.gravity === "number" && Number.isFinite(raw.gravity) ? Math.min(1, Math.max(-1, raw.gravity)) : base.gravity,
     life: unit3(raw.life, base.life),
-    interval: unit3(raw.interval, base.interval)
+    interval: unit3(raw.interval, base.interval),
+    ribbonFill: unit3(raw.ribbonFill, base.ribbonFill ?? DEFAULT_PARTICLE.ribbonFill),
+    ribbonPairs: oneOf(raw.ribbonPairs, RIBBON_PAIRS, base.ribbonPairs ?? DEFAULT_PARTICLE.ribbonPairs),
+    waveAmplitude: unit3(raw.waveAmplitude, base.waveAmplitude ?? 0),
+    waveLength: typeof raw.waveLength === "number" && Number.isFinite(raw.waveLength) ? Math.min(2e3, Math.max(4, raw.waveLength)) : base.waveLength ?? DEFAULT_PARTICLE.waveLength,
+    waveSpeed: unit3(raw.waveSpeed, base.waveSpeed ?? 0),
+    wavePhaseJitter: unit3(raw.wavePhaseJitter, base.wavePhaseJitter ?? 0),
+    dotTextures: textures,
+    dotTextureOrder: oneOf(raw.dotTextureOrder, DOT_TEXTURE_ORDERS, base.dotTextureOrder ?? DEFAULT_PARTICLE.dotTextureOrder),
+    dotRotation: oneOf(raw.dotRotation, DOT_ROTATIONS, base.dotRotation ?? DEFAULT_PARTICLE.dotRotation)
   };
 }
+var FUZZY_AMPLITUDE = 0.12;
+var NOMINAL_MS_PER_PX = 2;
+var RIBBON_SUB = 4;
+function chainDamp(damp, k) {
+  return Math.min(damp, 1 / (1 + 0.8 * Math.sqrt(Math.max(0, k))) ** 2);
+}
+function addPolygonArea(pts, rect, out, weight = 1) {
+  const n = pts.length >> 1;
+  if (n < 3) return;
+  let y0 = Infinity;
+  let y1 = -Infinity;
+  for (let i = 1; i < pts.length; i += 2) {
+    if (pts[i] < y0) y0 = pts[i];
+    if (pts[i] > y1) y1 = pts[i];
+  }
+  const r0 = Math.max(0, Math.floor(y0) - rect.y);
+  const r1 = Math.min(rect.height - 1, Math.floor(y1) - rect.y);
+  const xs = [];
+  const w = weight / RIBBON_SUB;
+  for (let row = r0; row <= r1; row++) {
+    const base = row * rect.width;
+    for (let sub = 0; sub < RIBBON_SUB; sub++) {
+      const y = rect.y + row + (sub + 0.5) / RIBBON_SUB;
+      xs.length = 0;
+      for (let i = 0, j = n - 1; i < n; j = i++) {
+        const yi = pts[i * 2 + 1];
+        const yj = pts[j * 2 + 1];
+        if (yi <= y !== yj <= y) xs.push(pts[i * 2] + (y - yi) / (yj - yi) * (pts[j * 2] - pts[i * 2]));
+      }
+      if (xs.length < 2) continue;
+      xs.sort((a, b) => a - b);
+      for (let k = 0; k + 1 < xs.length; k += 2) {
+        const a = Math.max(rect.x, xs[k]);
+        const b = Math.min(rect.x + rect.width, xs[k + 1]);
+        if (!(b > a)) continue;
+        for (let px = Math.floor(a); px < b; px++) {
+          const cover = Math.min(b, px + 1) - Math.max(a, px);
+          if (cover > 0) out[base + px - rect.x] += cover * w;
+        }
+      }
+    }
+  }
+}
 function curl(x, y, seed) {
   const n = (u, v) => {
     const x0 = Math.floor(u);
@@ -1032,12 +1306,51 @@ function curl(x, y, seed) {
 }
 var ParticleStroke = class extends MarkStroke {
   sets;
+  /** Ribbon pairs per copy: particles in their order around the pen (non-flow kinds). */
+  orders;
   s;
   spawn = 0;
+  /** Textured dots drawn so far, per copy (sequence order, random picks). */
+  dots;
+  /** Ribbon fill: the area each pixel has had so far this stroke (telescoped into the coverage). */
+  filled = /* @__PURE__ */ new Map();
+  pts = [];
   constructor(brush, options) {
     super(brush, options);
     this.s = brush.particle;
     this.sets = this.copies.map(() => []);
+    this.orders = this.copies.map(() => []);
+    this.dots = this.copies.map(() => 0);
+  }
+  /** Strand kinds: a chain of masses behind each particle. */
+  get strands() {
+    return this.s.kind === "string" || this.s.kind === "elastic" || this.s.kind === "fuzzy";
+  }
+  newParticle(x, y, ox, oy, k, phase, i, copy) {
+    const s = this.s;
+    const fuzzy = s.kind === "fuzzy";
+    const jitter = fuzzy ? 1 : s.wavePhaseJitter;
+    return {
+      x,
+      y,
+      vx: 0,
+      vy: 0,
+      ox,
+      oy,
+      k,
+      phase,
+      age: 0,
+      run: 0,
+      bead: 0,
+      alive: true,
+      wavePhase: jitter > 0 ? jitter * Math.PI * 2 * rand01(this.seed, i, 43 + copy) : 0,
+      waveScale: fuzzy ? 0.6 + 0.8 * rand01(this.seed, i, 47 + copy) : 1,
+      dx: x,
+      dy: y,
+      px: NaN,
+      py: NaN,
+      fade: 1
+    };
   }
   init(copy, d) {
     const s = this.s;
@@ -1048,18 +1361,28 @@ var ParticleStroke = class extends MarkStroke {
       const a = rand01(this.seed, i, 5 + copy) * Math.PI * 2;
       const ox = Math.cos(a) * r;
       const oy = Math.sin(a) * r;
-      const p = { x: d.x + ox, y: d.y + oy, vx: 0, vy: 0, ox, oy, k: 0.6 + 0.8 * rand01(this.seed, i, 7), phase: a, age: 0, run: 0, bead: 0, alive: true };
-      if (s.kind === "string") p.strand = Array.from({ length: 6 }, () => ({ x: d.x + ox, y: d.y + oy, vx: 0, vy: 0 }));
+      const p = this.newParticle(d.x + ox, d.y + oy, ox, oy, 0.6 + 0.8 * rand01(this.seed, i, 7), a, i, copy);
+      if (this.strands) p.strand = Array.from({ length: 6 }, () => ({ x: d.x + ox, y: d.y + oy, vx: 0, vy: 0 }));
       if (s.kind === "orbit") {
         p.ox = Math.max(1, r + size * 0.15);
         p.oy = 0;
       }
       list.push(p);
     }
+    this.orders[copy] = list.map((_, i) => i).sort((i, j) => list[i].phase - list[j].phase || i - j);
+  }
+  /** The sideways wave of particle `p` at pen dab `d` (px along the normal to the pen's direction). */
+  wave(p, d, size) {
+    const s = this.s;
+    const amp = s.kind === "fuzzy" ? Math.max(FUZZY_AMPLITUDE, s.waveAmplitude) : s.waveAmplitude;
+    if (!(amp > 0)) return 0;
+    const ms = d.time ?? d.travel * NOMINAL_MS_PER_PX;
+    const phase = 2 * Math.PI * d.travel / (s.waveLength * p.waveScale) - s.waveSpeed * 0.025 * ms + p.wavePhase;
+    return amp * size * Math.sin(phase);
   }
   advance(copy, d, rects) {
     const s = this.s;
-    const list = this.sets[copy];
+    let list = this.sets[copy];
     if (d.index === 0 && !list.length) this.init(copy, d);
     const size = Math.max(1, d.radius * 2);
     const markR = Math.max(0.5, size * s.size / 2);
@@ -1068,6 +1391,8 @@ var ParticleStroke = class extends MarkStroke {
     const g = s.gravity * 0.15;
     const op = d.opacity;
     const al = Math.max(0.05, d.alpha);
+    const nx = Math.sin(d.direction);
+    const ny = Math.cos(d.direction);
     if (s.kind === "flow") {
       this.spawn += s.count / 8;
       while (this.spawn >= 1) {
@@ -1075,15 +1400,13 @@ var ParticleStroke = class extends MarkStroke {
         const i = this.dabCount + list.length * 31 + Math.floor(d.index);
         const a = rand01(this.seed, i, 11 + copy) * Math.PI * 2;
         const r = rand01(this.seed, i, 13 + copy) * s.spread * size * 0.5;
-        list.push({ x: d.x + Math.cos(a) * r, y: d.y + Math.sin(a) * r, vx: 0, vy: 0, ox: 0, oy: 0, k: 1, phase: a, age: 0, run: 0, bead: 0, alive: true });
+        list.push(this.newParticle(d.x + Math.cos(a) * r, d.y + Math.sin(a) * r, 0, 0, 1, a, i, copy));
       }
     }
     const lifeSteps = 8 + 120 * s.life;
     for (let i = 0; i < list.length; i++) {
       const p = list[i];
       if (!p.alive) continue;
-      const px = p.x;
-      const py = p.y;
       switch (s.kind) {
         case "spring": {
           p.vx = (p.vx + (d.x + p.ox - p.x) * k * p.k) * damp;
@@ -1092,13 +1415,38 @@ var ParticleStroke = class extends MarkStroke {
           p.y += p.vy;
           break;
         }
-        case "string": {
+        case "string":
+        case "fuzzy": {
           const strand = p.strand;
+          const dm = s.kind === "fuzzy" ? chainDamp(damp, k * p.k) : damp;
           let ax = d.x + p.ox;
           let ay = d.y + p.oy;
           for (const m of strand) {
-            m.vx = (m.vx + (ax - m.x) * k * p.k + 0) * damp;
-            m.vy = (m.vy + (ay - m.y) * k * p.k + g) * damp;
+            m.vx = (m.vx + (ax - m.x) * k * p.k + 0) * dm;
+            m.vy = (m.vy + (ay - m.y) * k * p.k + g) * dm;
+            m.x += m.vx;
+            m.y += m.vy;
+            ax = m.x;
+            ay = m.y;
+          }
+          p.x = strand[strand.length - 1].x;
+          p.y = strand[strand.length - 1].y;
+          break;
+        }
+        case "elastic": {
+          const strand = p.strand;
+          const rest = size * 0.12;
+          const ke = Math.min(0.9, (0.1 + 0.6 * s.stiffness) * p.k);
+          const dm = chainDamp(damp, ke);
+          let ax = d.x + p.ox;
+          let ay = d.y + p.oy;
+          for (const m of strand) {
+            const ex = ax - m.x;
+            const ey = ay - m.y;
+            const len = Math.hypot(ex, ey);
+            const pull = len > rest ? (len - rest) / len : 0;
+            m.vx = (m.vx + ex * pull * ke) * dm;
+            m.vy = (m.vy + ey * pull * ke + g) * dm;
             m.x += m.vx;
             m.y += m.vy;
             ax = m.x;
@@ -1127,11 +1475,21 @@ var ParticleStroke = class extends MarkStroke {
           break;
         }
       }
+      const w = this.wave(p, d, size);
+      const qx = w ? p.x + nx * w : p.x;
+      const qy = w ? p.y + ny * w : p.y;
+      const px = p.dx;
+      const py = p.dy;
+      p.px = p.dx;
+      p.py = p.dy;
+      p.dx = qx;
+      p.dy = qy;
       const fade = s.kind === "flow" ? 1 - p.age / lifeSteps : 1;
-      const moved = Math.hypot(p.x - px, p.y - py);
+      p.fade = fade;
+      const moved = Math.hypot(qx - px, qy - py);
       if (d.index === 0 && s.kind !== "flow") continue;
-      if (s.render === "dot") this.mark(p.x, p.y, markR * fade, al * fade, op, d.pressure, rects);
-      else if (s.render === "line") this.segment(px, py, p.x, p.y, markR * fade, al * fade, op, d.pressure, rects);
+      if (s.render === "dot") this.dot(copy, qx, qy, qx - px, qy - py, markR * fade, al * fade, op, d, rects);
+      else if (s.render === "line" || s.render === "ribbon") this.segment(px, py, qx, qy, markR * fade, al * fade, op, d.pressure, rects);
       else {
         p.run += moved;
         const gap = Math.max(markR * 2, size * (0.05 + s.interval));
@@ -1139,13 +1497,101 @@ var ParticleStroke = class extends MarkStroke {
           p.run -= gap;
           p.bead++;
           const t = moved > 0 ? 1 - p.run / Math.max(moved, 1e-6) : 1;
-          const bx = px + (p.x - px) * Math.min(1, Math.max(0, t));
-          const by = py + (p.y - py) * Math.min(1, Math.max(0, t));
-          this.mark(bx, by, markR * (0.7 + 0.6 * (p.bead % 3 / 2)) * fade, al * fade, op, d.pressure, rects);
+          const bx = px + (qx - px) * Math.min(1, Math.max(0, t));
+          const by = py + (qy - py) * Math.min(1, Math.max(0, t));
+          this.dot(copy, bx, by, qx - px, qy - py, markR * (0.7 + 0.6 * (p.bead % 3 / 2)) * fade, al * fade, op, d, rects);
         }
       }
     }
-    if (s.kind === "flow" && list.length > 512) this.sets[copy] = list.filter((p) => p.alive);
+    if (s.render === "ribbon" && !(d.index === 0 && s.kind !== "flow")) this.ribbon(copy, list, op, al, d, rects);
+    if (s.kind === "flow" && list.length > 512) {
+      list = list.filter((p) => p.alive);
+      this.sets[copy] = list;
+    }
+  }
+  /** A dot (or bead): round, or a textured stamp turned by the particle's motion (mx, my), at random or to the tip angle. */
+  dot(copy, x, y, mx, my, r, alpha, opacity, d, rects) {
+    const s = this.s;
+    const textures = s.dotTextures;
+    if (!textures.length) return this.mark(x, y, r, alpha, opacity, d.pressure, rects);
+    const n = this.dots[copy]++;
+    const pick = s.dotTextureOrder === "random" ? Math.min(textures.length - 1, Math.floor(rand01(this.seed, n, 31 + copy) * textures.length)) : n % textures.length;
+    const rotation = s.dotRotation === "random" ? rand01(this.seed, n, 37 + copy) * Math.PI * 2 : s.dotRotation === "follow" ? mx || my ? Math.atan2(my, mx) : -d.direction : -this.brush.tip.angle * Math.PI / 180;
+    this.stamp(x, y, r, textures[pick], rotation, this.seed + n * 2654435761 >>> 0, alpha, opacity, d.pressure, rects);
+  }
+  /**
+   * Ribbon fill for one step: the band between each pair of joined particles, from where they
+   * were drawn last step to where they are drawn now. Bands of one step, and of consecutive steps,
+   * share edges exactly, so the fill has no seams; it is telescoped into the coverage
+   * (`telescope`), so it does not build up at the joins.
+   */
+  ribbon(copy, list, opacity, alpha, d, rects) {
+    const s = this.s;
+    if (!(s.ribbonFill > 0)) return;
+    const live = (p) => !!p && p.alive && !Number.isNaN(p.px);
+    let order;
+    if (s.kind === "flow") order = list.filter(live);
+    else order = this.orders[copy].map((i) => list[i]).filter(live);
+    if (order.length < 2) return;
+    const pairs = [];
+    if (s.ribbonPairs === "first-last") pairs.push([order[0], order[order.length - 1]]);
+    else for (let i = 0; i + 1 < order.length; i++) pairs.push([order[i], order[i + 1]]);
+    const pts = this.pts;
+    const ceil = Math.min(1, opacity * s.ribbonFill);
+    for (const [a, b] of pairs) {
+      pts.length = 0;
+      pts.push(a.px, a.py, a.dx, a.dy, b.dx, b.dy, b.px, b.py);
+      let x0 = Infinity;
+      let y0 = Infinity;
+      let x1 = -Infinity;
+      let y1 = -Infinity;
+      for (let i = 0; i < 8; i += 2) {
+        x0 = Math.min(x0, pts[i]);
+        x1 = Math.max(x1, pts[i]);
+        y0 = Math.min(y0, pts[i + 1]);
+        y1 = Math.max(y1, pts[i + 1]);
+      }
+      const rect = { x: Math.floor(x0), y: Math.floor(y0), width: Math.floor(x1) - Math.floor(x0) + 1, height: Math.floor(y1) - Math.floor(y0) + 1 };
+      const area = this.scratch(rect.width * rect.height);
+      addPolygonArea(pts, rect, area, Math.min(a.fade, b.fade) * alpha);
+      if (this.telescope(rect, area)) this.lay(rect, area, ceil, d.pressure, (a.dx + b.dx) / 2, (a.dy + b.dy) / 2, rects);
+    }
+  }
+  /**
+   * Turns the area newly filled over `rect` into coverage to lay towards the fill's ceiling: the
+   * share of what was left unfilled, so after any number of bands (in any grouping) a pixel's
+   * coverage is the ceiling times the area filled there. False when nothing was added.
+   */
+  telescope(rect, area) {
+    let any = false;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const gy = rect.y + yy;
+      const ty = Math.floor(gy / TILE);
+      let t;
+      let tx = NaN;
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        const add = area[k];
+        if (!(add > 0)) continue;
+        const gx = rect.x + xx;
+        const ntx = Math.floor(gx / TILE);
+        if (ntx !== tx || !t) {
+          tx = ntx;
+          const key = tileKey(tx, ty);
+          t = this.filled.get(key);
+          if (!t) {
+            t = new Float32Array(TILE * TILE);
+            this.filled.set(key, t);
+          }
+        }
+        const ti = (gy - ty * TILE) * TILE + (gx - tx * TILE);
+        const before = t[ti];
+        const after = Math.min(1, before + add);
+        t[ti] = after;
+        area[k] = before < 1 ? (after - before) / (1 - before) : 0;
+        any = true;
+      }
+    }
+    return any;
   }
 };
 var DEFAULT_BRISTLE = { count: 32, stiffness: 0.5, splay: 0.5, thickness: 0.06, load: 0.6, jitter: 0.4 };
@@ -1897,6 +2343,66 @@ var BUILTIN_BRUSHES = [
     particle: { kind: "flow", render: "dot", count: 8, size: 0.06, spread: 0.7, speed: 0.9, life: 0.3 },
     light: { amount: 1 }
   }),
+  builtin({
+    // Silk of light: strands dragged behind the pen on slow waves, the bands between them filled.
+    id: "light-ribbon",
+    name: "Light ribbon",
+    category: "light",
+    engine: "particle",
+    tip: { size: 80, hardness: 0.8, opacity: 0.9, flow: 1, smoothing: 0.35, pressureSize: false, pressureOpacity: false },
+    particle: { kind: "string", render: "ribbon", count: 5, size: 0.015, spread: 1, stiffness: 0.05, damping: 0.3, ribbonFill: 0.45, waveAmplitude: 0.25, waveLength: 220, wavePhaseJitter: 0.25 },
+    light: { amount: 0.8 }
+  }),
+  builtin({
+    // Flames: short-lived bands thrown off the pen, rising and curling in the flow.
+    id: "flame-ribbon",
+    name: "Flame ribbon",
+    category: "light",
+    engine: "particle",
+    tip: { size: 50, hardness: 0.6, opacity: 0.85, flow: 1, smoothing: 0.25, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "flow", render: "ribbon", count: 4, size: 0.012, spread: 0.5, speed: 0.6, gravity: -0.6, life: 0.2, ribbonFill: 0.5 },
+    light: { amount: 1 }
+  }),
+  builtin({
+    // A neon tube that lags and snaps back, with a slow shimmer.
+    id: "neon-strand",
+    name: "Neon strand",
+    category: "light",
+    engine: "particle",
+    tip: { size: 40, hardness: 0.9, opacity: 1, flow: 1, smoothing: 0.4, pressureSize: false, pressureOpacity: false },
+    particle: { kind: "elastic", render: "line", count: 3, size: 0.05, spread: 0.25, stiffness: 0.6, damping: 0.3, waveAmplitude: 0.06, waveLength: 120 },
+    light: { amount: 1 }
+  }),
+  builtin({
+    // Smoke lit from within: thin bands thrown into a slow, rising flow.
+    id: "smoke-ribbon",
+    name: "Smoke ribbon",
+    category: "light",
+    engine: "particle",
+    tip: { size: 70, hardness: 0.3, opacity: 0.45, flow: 1, smoothing: 0.3, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "flow", render: "ribbon", count: 3, size: 5e-3, spread: 0.5, speed: 0.15, gravity: -0.15, life: 0.35, ribbonFill: 0.25, waveAmplitude: 0.1, waveLength: 140, wavePhaseJitter: 1 },
+    light: { amount: 0.3 }
+  }),
+  builtin({
+    // Out-of-focus lights: soft discs and rings spaced along springy paths.
+    id: "bokeh-dots",
+    name: "Bokeh dots",
+    category: "light",
+    engine: "particle",
+    tip: { size: 80, hardness: 0.7, opacity: 0.6, flow: 1, smoothing: 0.3, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "spring", render: "sequence", count: 3, size: 0.3, spread: 1, stiffness: 0.15, damping: 0.4, interval: 1, dotTextures: ["dot", "dot", "ring"], dotTextureOrder: "random" },
+    light: { amount: 0.9 }
+  }),
+  builtin({
+    // Sparks: twinkles and stars thrown into the flow, spaced along it.
+    id: "twinkle-sparks",
+    name: "Twinkle sparks",
+    category: "light",
+    engine: "particle",
+    tip: { size: 50, hardness: 0.8, opacity: 1, flow: 1, smoothing: 0.1, pressureSize: true, pressureOpacity: false },
+    particle: { kind: "flow", render: "sequence", count: 3, size: 0.25, spread: 0.8, speed: 0.9, life: 0.35, interval: 0.6, dotTextures: ["sparkle", "sparkle", "star"], dotTextureOrder: "random", dotRotation: "random" },
+    light: { amount: 1 }
+  }),
   builtin({
     id: "glow-wash",
     name: "Glow wash",
@@ -2067,11 +2573,15 @@ export {
   DryStroke,
   mixerTip,
   toStrokePoint,
-  STAMP_KINDS,
+  STICKER_ART_SIZE,
+  defaultStickerRasterizer,
+  StickerArtCache,
+  sampleArt,
+  MAX_STICKER_STAMPS,
   DEFAULT_STICKER,
   normalizeStickerSettings,
-  stampCoverage,
   stickerRect,
+  stickerStamp,
   drawSticker,
   StickerSpray,
   renderStickers,
@@ -2080,8 +2590,13 @@ export {
   stickerAt,
   PARTICLE_KINDS,
   PARTICLE_RENDERS,
+  RIBBON_PAIRS,
+  DOT_TEXTURE_ORDERS,
+  DOT_ROTATIONS,
+  MAX_DOT_TEXTURES,
   DEFAULT_PARTICLE,
   normalizeParticle,
+  addPolygonArea,
   ParticleStroke,
   DEFAULT_BRISTLE,
   normalizeBristle,