@pixerate/editor 0.267.0 → 0.268.0

package/dist/{chunk-4IDUYB45.js → chunk-UVTO3D4E.js}

@@ -4,10 +4,11 @@ import {
   VECTOR_PROFILE,
   checkBrush,
   closest,
+  isBrushSourceRef,
   listPresets,
   normalizeBrushSpec,
   resolveBrush
-} from "./chunk-AGNUD5BI.js";
+} from "./chunk-KZI3YWKW.js";
 import {
   editorStampOf,
   stampCoverage
@@ -75,24 +76,24 @@ import {
 } from "./chunk-GSTSZPSR.js";
 import {
   BrushstrokeCache,
-  GRAIN_PATTERNS,
-  PaperGrain,
   brushstrokeDataUrl,
   brushstrokeSamples,
-  grainCatch,
   isBrushstrokeBrush
-} from "./chunk-TXFWZ5ZJ.js";
+} from "./chunk-W6JDUXP3.js";
 import {
   CoverageMap,
   EMPTY_MIXER_LOAD,
+  GRAIN_PATTERNS,
   PaintExchange,
   PaintGradientSampler,
+  PaperGrain,
   SmudgeTip,
   TileMedium,
   blenderDab,
   createBlenderScratch,
   dabRect,
   exchangeRates,
+  grainCatch,
   loadMixer,
   mixerRates,
   parsePaintSource,
@@ -100,7 +101,7 @@ import {
   readPaintSource,
   resolvePaintGradient,
   scalePaintGradient
-} from "./chunk-GCVFEPJG.js";
+} from "./chunk-ACTHSQOI.js";
 import {
   rand01,
   randSigned
@@ -2726,7 +2727,18 @@ function effectDabField(img, rect, cov, centre, mixed, field, steps = 0, dab = n
 
 // src/paint-editor/stamp-tip.ts
 var samplers = /* @__PURE__ */ new WeakMap();
-function stampSampler(ref, art) {
+function stampSampler(ref, art, hardness = 1) {
+  const sampler = baseSampler(ref, art);
+  if (!sampler || hardness >= 1 || !isBrushSourceRef(ref)) return sampler;
+  const h = Math.max(0, hardness);
+  return (u, v2, seed) => {
+    const r = Math.hypot(u, v2) / Math.SQRT2;
+    if (r <= h) return sampler(u, v2, seed);
+    const t = Math.min(1, (r - h) / (1 - h));
+    return sampler(u, v2, seed) * (1 - t * t * (3 - 2 * t));
+  };
+}
+function baseSampler(ref, art) {
   let kind = null;
   try {
     kind = editorStampOf(ref.includes(":") ? ref : `editor:${ref}`);
@@ -2771,6 +2783,8 @@ function rasterizeStampDab(d, sample, seed, rect, out) {
   const sn = Math.sin(d.angle);
   const cs = Math.cos(d.angle);
   const ss = r < 6 ? 3 : 1;
+  const fu = d.flip && d.flip & 1 ? -1 : 1;
+  const fv = d.flip && d.flip & 2 ? -1 : 1;
   for (let yy = 0; yy < h; yy++) {
     for (let xx = 0; xx < w; xx++) {
       let sum = 0;
@@ -2778,8 +2792,8 @@ function rasterizeStampDab(d, sample, seed, rect, out) {
         for (let sx = 0; sx < ss; sx++) {
           const dx = rect.x + xx + (sx + 0.5) / ss - d.x;
           const dy = rect.y + yy + (sy + 0.5) / ss - d.y;
-          const u = (dx * cs - dy * sn) / r;
-          const v2 = (dx * sn + dy * cs) / (r * ro);
+          const u = (dx * cs - dy * sn) / r * fu;
+          const v2 = (dx * sn + dy * cs) / (r * ro) * fv;
           if (u > -1.05 && u < 1.05 && v2 > -1.05 && v2 < 1.05) sum += sample(u, v2, seed);
         }
       }
@@ -2790,7 +2804,7 @@ function rasterizeStampDab(d, sample, seed, rect, out) {
 }
 function brushStickerRefs(brush) {
   const refs = brush.engine === "sticker" ? [...brush.sticker.stamps] : brush.engine === "particle" ? [...brush.particle.dotTextures] : brush.engine === "dab" && brush.stamp ? [brush.stamp] : [];
-  return [...new Set(refs.filter((r) => r.includes(":") && !r.startsWith("editor:")))];
+  return [...new Set(refs.filter((r) => r.includes(":") && !r.startsWith("editor:") && !isBrushSourceRef(r)))];
 }
 function sprayDroplets(d, spray, seed) {
   const count = 1 + Math.round(spray.density * 31);
@@ -2936,6 +2950,86 @@ function renderPaper(paper, rect, grain = new PaperGrain(paper), light) {
   return out;
 }
 
+// src/paint-editor/tip-grain.ts
+var ImageGrain = class {
+  constructor(w, h, alpha, contrast, invert2, scale3) {
+    this.w = w;
+    this.h = h;
+    this.scale = scale3;
+    this.heights = new Float32Array(w * h);
+    for (let i = 0; i < w * h; i++) {
+      const v2 = Math.min(1, Math.max(0, (alpha[i * 4 + 3] / 255 - 0.5) * contrast + 0.5));
+      this.heights[i] = invert2 ? 1 - v2 : v2;
+    }
+  }
+  w;
+  h;
+  scale;
+  heights;
+  at(x, y) {
+    const { w, h } = this;
+    const u = x / this.scale - 0.5;
+    const v2 = y / this.scale - 0.5;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v2);
+    const fx = u - x0;
+    const fy = v2 - y0;
+    const xa = (x0 % w + w) % w;
+    const ya = (y0 % h + h) % h;
+    const xb = (xa + 1) % w;
+    const yb = (ya + 1) % h;
+    const hs = this.heights;
+    return (hs[ya * w + xa] * (1 - fx) + hs[ya * w + xb] * fx) * (1 - fy) + (hs[yb * w + xa] * (1 - fx) + hs[yb * w + xb] * fx) * fy;
+  }
+};
+var TipGrain = class _TipGrain {
+  constructor(field, settings) {
+    this.field = field;
+    this.settings = settings;
+  }
+  field;
+  settings;
+  /**
+   * The grain for `settings`, or `null` when there is none to apply: no depth, or an image source
+   * whose art is not loaded (the dabs then paint without it).
+   */
+  static create(settings, art) {
+    if (!settings || settings.depth <= 0) return null;
+    if (GRAIN_PATTERNS.includes(settings.source)) {
+      if (settings.source === "smooth") return null;
+      const tuning2 = { contrast: settings.contrast, invert: settings.invert };
+      const paper = new PaperGrain({ pattern: settings.source, seed: 0, scale: settings.scale, tiling: "repeat", dry: tuning2, wet: tuning2 });
+      return new _TipGrain(paper, settings);
+    }
+    const a = art?.(settings.source);
+    if (!a || !(a.width > 0 && a.height > 0)) return null;
+    return new _TipGrain(new ImageGrain(a.width, a.height, a.data, settings.contrast, settings.invert, settings.scale), settings);
+  }
+  /** Multiplies the dab's coverage `vals` (over `rect`) by the grain. */
+  apply(vals, rect, d) {
+    const depth = this.settings.depth;
+    const moving = this.settings.mode === "moving";
+    const cs = Math.cos(d.angle);
+    const sn = Math.sin(d.angle);
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const py = rect.y + yy + 0.5;
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        if (!(vals[k] > 0)) continue;
+        const px = rect.x + xx + 0.5;
+        let gx = px;
+        let gy = py;
+        if (moving) {
+          const dx = px - d.x;
+          const dy = py - d.y;
+          gx = dx * cs - dy * sn + d.travel;
+          gy = dx * sn + dy * cs;
+        }
+        vals[k] *= 1 - depth * (1 - this.field.at(gx, gy));
+      }
+    }
+  }
+};
+
 // src/paint-editor/engine.ts
 function penOrientation(p) {
   if (typeof p.altitude === "number" && Number.isFinite(p.altitude)) {
@@ -3075,7 +3169,13 @@ var PenDabWalker = class {
       x += Math.sin(this.dir) * off;
       y += Math.cos(this.dir) * off;
     }
+    let flip = 0;
+    if (dyn.flip && dyn.flip !== "none") {
+      if (dyn.flip !== "y" && rand01(seed, i, 5 /* FlipX */) < 0.5) flip |= 1;
+      if (dyn.flip !== "x" && rand01(seed, i, 6 /* FlipY */) < 0.5) flip |= 2;
+    }
     return {
+      ...flip ? { flip } : {},
       x,
       y,
       radius: Math.max(0.5, diameter / 2),
@@ -3106,7 +3206,7 @@ var PenDabWalker = class {
     const len2 = Math.hypot(dx, dy);
     if (len2 > 1e-9) this.dir = Math.atan2(-dy, dx);
     if (this.pendingFirst) {
-      out.push(this.dab(this.pendingFirst));
+      this.lay(this.pendingFirst, out);
       this.pendingFirst = null;
     }
     if (len2 > 1e-9) {
@@ -3124,7 +3224,7 @@ var PenDabWalker = class {
           travel: a.travel + this.nextAt,
           time: a.time !== null && s.time !== null ? lerp4(a.time, s.time) : s.time
         };
-        out.push(this.dab(q));
+        this.lay(q, out);
         this.nextAt += this.stepLen(q);
       }
       this.nextAt -= len2;
@@ -3133,10 +3233,15 @@ var PenDabWalker = class {
   }
   finish(out) {
     if (this.pendingFirst) {
-      out.push(this.dab(this.pendingFirst));
+      this.lay(this.pendingFirst, out);
       this.pendingFirst = null;
     }
   }
+  /** The dabs of one spacing step: `dynamics.count` of them, each with its own index and so its own jitter. */
+  lay(s, out) {
+    const n = this.brush.dynamics.count ?? 1;
+    for (let k = 0; k < n; k++) out.push(this.dab(s));
+  }
 };
 function lerpAngle(a, b, t) {
   let d = b - a;
@@ -3154,7 +3259,8 @@ var DryStroke = class {
   constructor(brush, options) {
     this.brush = brush;
     this.options = options;
-    this.stamp = brush.stamp ? stampSampler(brush.stamp, options.stampArt) : null;
+    this.stamp = brush.stamp ? stampSampler(brush.stamp, options.stampArt, brush.tip.hardness) : null;
+    this.tipGrain = TipGrain.create(brush.tipGrain, options.stampArt);
     this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
     this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
     this.walkers = this.copies.map((c, i) => new PenDabWalker(brush, (options.seed ?? 0) + i * 7919 | 0, c.linear));
@@ -3174,6 +3280,8 @@ var DryStroke = class {
   lastFed = null;
   /** The stamp tip's shape, or `null` for the round computed tip. */
   stamp;
+  /** The tip's own grain, or `null`. */
+  tipGrain;
   /** Feeds raw pen samples; returns the document rectangles the new dabs touched. */
   push(points) {
     const dabs = [];
@@ -3207,7 +3315,7 @@ var DryStroke = class {
     }
     return rects;
   }
-  /** Lays one mark (a dab, or a spray droplet of dab `d`): the round tip or the stamp, the paper grain, effect paint. */
+  /** Lays one mark (a dab, or a spray droplet of dab `d`): the round tip or the stamp, the tip grain, the paper grain, effect paint. */
   mark(m, d, rects) {
     const hardness = this.brush.tip.hardness;
     const grain = this.options.grain;
@@ -3217,6 +3325,7 @@ var DryStroke = class {
     const vals = this.buf.subarray(0, n);
     if (this.stamp) rasterizeStampDab(m, this.stamp, d.index, rect, vals);
     else rasterizeDab(m, hardness, rect, vals);
+    this.tipGrain?.apply(vals, rect, { x: m.x, y: m.y, angle: m.angle, travel: d.travel });
     if (this.depth > 0 && grain) {
       for (let yy = 0, k = 0; yy < rect.height; yy++) {
         const y = rect.y + yy + 0.5;
@@ -3294,7 +3403,8 @@ var PaintDabStroke = class {
   constructor(brush, options) {
     this.brush = brush;
     this.options = options;
-    this.stamp = brush.engine === "dab" && brush.stamp ? stampSampler(brush.stamp, options.stampArt) : null;
+    this.stamp = brush.engine === "dab" && brush.stamp ? stampSampler(brush.stamp, options.stampArt, brush.tip.hardness) : null;
+    this.tipGrain = TipGrain.create(brush.tipGrain, options.stampArt);
     this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
     this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
     const exchanging = brush.engine === "mixer" || brush.engine === "dab";
@@ -3340,6 +3450,8 @@ var PaintDabStroke = class {
   lastFed = null;
   /** The stamp tip's shape (dab brushes), or `null` for the round computed tip. */
   stamp;
+  /** The tip's own grain, or `null`. */
+  tipGrain;
   /** What copy 0's brush carries after the dabs so far (mixer and wet-capable dab brushes). */
   get load() {
     return this.states[0].exchange?.load ?? null;
@@ -3392,6 +3504,7 @@ var PaintDabStroke = class {
     tip.fill(0);
     if (this.stamp) rasterizeStampDab({ ...d, alpha: 1 }, this.stamp, d.index, rect, tip);
     else rasterizeDab({ ...d, alpha: 1 }, this.brush.tip.hardness, rect, tip);
+    this.tipGrain?.apply(tip, rect, d);
     if (!(this.depth > 0 && this.options.grain)) return { tip, cov: tip };
     const cov = this.cov.subarray(0, n);
     const grain = this.options.grain;
@@ -12971,6 +13084,7 @@ export {
   normalizePaper,
   hexToRgb8,
   renderPaper,
+  TipGrain,
   penOrientation,
   tiltToOrientation,
   PenSmoother,

package/dist/{chunk-TXFWZ5ZJ.js → chunk-W6JDUXP3.js}

@@ -1,6 +1,7 @@
 import {
   CoverageMap,
   PaintGradientSampler,
+  PaperGrain,
   TIP_GRADIENT_STEPS,
   applyStrokeToTile,
   dabRect,
@@ -9,11 +10,10 @@ import {
   normalizeBrush,
   rasterizeDab,
   resolvePaintGradient,
-  scalePaintGradient
-} from "./chunk-GCVFEPJG.js";
+  scalePaintGradient,
+  strokeGrainCatch
+} from "./chunk-ACTHSQOI.js";
 import {
-  TileableNoise,
-  hash2,
   randSigned
 } from "./chunk-4D6KP5BV.js";
 import {
@@ -34,180 +34,6 @@ import {
   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;
@@ -574,12 +400,6 @@ var BrushstrokeCache = class {
 };
 
 export {
-  GRAIN_PATTERNS,
-  GRAIN_TILE,
-  grainHeights,
-  PaperGrain,
-  grainCatch,
-  strokeGrainCatch,
   pathStrokeDabs,
   pathStrokeCoverage,
   paintPathStroke,

package/dist/{chunk-LA5Y4ETA.cjs → chunk-YOVXQHA3.cjs}

@@ -5,7 +5,7 @@
 
 
 
-var _chunkOKHKA43Lcjs = require('./chunk-OKHKA43L.cjs');
+var _chunkJBB3GDBBcjs = require('./chunk-JBB3GDBB.cjs');
 
 
 var _chunkGF2RBSDMcjs = require('./chunk-GF2RBSDM.cjs');
@@ -1361,12 +1361,12 @@ var unit = (x, y) => {
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
 function cubicOf(sp, i) {
-  const s = _chunkOKHKA43Lcjs.subpathSegment.call(void 0, sp, i);
+  const s = _chunkJBB3GDBBcjs.subpathSegment.call(void 0, sp, i);
   if (s.length === 4) return s;
   const [a, b] = s;
   return [a, [a[0] + (b[0] - a[0]) / 3, a[1] + (b[1] - a[1]) / 3], [a[0] + 2 * (b[0] - a[0]) / 3, a[1] + 2 * (b[1] - a[1]) / 3], b];
 }
-var isLine = (sp, i) => _chunkOKHKA43Lcjs.subpathSegment.call(void 0, sp, i).length === 2;
+var isLine = (sp, i) => _chunkJBB3GDBBcjs.subpathSegment.call(void 0, sp, i).length === 2;
 function startTangent(c) {
   for (let k = 1; k < 4; k++) {
     const u = unit(c[k][0] - c[0][0], c[k][1] - c[0][1]);
@@ -1386,10 +1386,10 @@ function sample(c, n, out, withStart) {
 }
 var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
 function tidy(a, keepType = true) {
-  const next = _chunkOKHKA43Lcjs.cloneAnchor.call(void 0, a);
+  const next = _chunkJBB3GDBBcjs.cloneAnchor.call(void 0, a);
   if (onAnchor(next, next.in)) delete next.in;
   if (onAnchor(next, next.out)) delete next.out;
-  const shown = _chunkOKHKA43Lcjs.inferAnchorType.call(void 0, next);
+  const shown = _chunkJBB3GDBBcjs.inferAnchorType.call(void 0, next);
   const type = keepType && a.type ? a.type === "symmetric" && shown !== "symmetric" ? shown === "corner" ? "corner" : "smooth" : a.type === "smooth" && shown === "corner" ? "corner" : a.type : shown;
   if (type === "corner") delete next.type;
   else next.type = type;
@@ -1433,7 +1433,7 @@ function fitAcross(pts, N, t0, t1) {
   return goldenMin(fit, 0, 1);
 }
 function removeAnchorKeepingShape(sp, index) {
-  const anchors = sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor);
   const n = anchors.length;
   if (index < 0 || index >= n) return { anchors, closed: sp.closed };
   if ((sp.closed || index > 0 && index < n - 1) && n >= 3) {
@@ -1467,12 +1467,12 @@ function removeAnchorKeepingShape(sp, index) {
 }
 function removeAnchorsKeepingShape(sp, indices) {
   const order = [...new Set(indices)].filter((i) => i >= 0 && i < sp.anchors.length).sort((a, b) => b - a);
-  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor), closed: sp.closed });
+  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor), closed: sp.closed });
 }
 function bendSegment(sp, segment, t, p) {
-  const anchors = sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor);
   const n = anchors.length;
-  if (segment < 0 || segment >= _chunkOKHKA43Lcjs.subpathSegmentCount.call(void 0, sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
+  if (segment < 0 || segment >= _chunkJBB3GDBBcjs.subpathSegmentCount.call(void 0, sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
   const tc = Math.min(0.95, Math.max(0.05, t));
   const ia = segment;
   const ib = (segment + 1) % n;
@@ -1483,16 +1483,16 @@ function bendSegment(sp, segment, t, p) {
   const oy = (p.y - (a.y + (b.y - a.y) * tc)) / k;
   const c1 = { x: a.x + (b.x - a.x) / 3 + ox, y: a.y + (b.y - a.y) / 3 + oy };
   const c2 = { x: b.x + (a.x - b.x) / 3 + ox, y: b.y + (a.y - b.y) / 3 + oy };
-  anchors[ia] = _chunkOKHKA43Lcjs.moveAnchorHandle.call(void 0, a, "out", c1);
-  anchors[ib] = _chunkOKHKA43Lcjs.moveAnchorHandle.call(void 0, b, "in", c2);
+  anchors[ia] = _chunkJBB3GDBBcjs.moveAnchorHandle.call(void 0, a, "out", c1);
+  anchors[ib] = _chunkJBB3GDBBcjs.moveAnchorHandle.call(void 0, b, "in", c2);
   return { anchors, closed: sp.closed };
 }
 function subpathPointAt(sp, segment, t) {
-  const [x, y] = _chunkGF2RBSDMcjs.segmentPoint.call(void 0, _chunkOKHKA43Lcjs.subpathSegment.call(void 0, sp, segment), t);
+  const [x, y] = _chunkGF2RBSDMcjs.segmentPoint.call(void 0, _chunkJBB3GDBBcjs.subpathSegment.call(void 0, sp, segment), t);
   return { x, y };
 }
 function curvatureMoveAnchor(sp, index, q) {
-  const anchors = sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor);
   const a = sp.anchors[index];
   if (!a) return { anchors, closed: sp.closed };
   const own = [
@@ -1538,7 +1538,7 @@ function curvatureMoveAnchor(sp, index, q) {
 function cutSubpathAt(sp, at) {
   const n = sp.anchors.length;
   const cuts = [...new Set(at)].filter((i) => Number.isInteger(i) && i >= 0 && i < n && (sp.closed || i > 0 && i < n - 1)).sort((a, b) => a - b);
-  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor), closed: sp.closed }];
+  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor), closed: sp.closed }];
   const first = cuts[0];
   const run = sp.closed ? Array.from({ length: n + 1 }, (_, i) => sp.anchors[(first + i) % n]) : sp.anchors;
   const cutSet = new Set(sp.closed ? [...cuts.map((c) => (c - first + n) % n), n] : cuts);
@@ -1546,7 +1546,7 @@ function cutSubpathAt(sp, at) {
   let cur = [];
   run.forEach((a, i) => {
     if (!cutSet.has(i)) {
-      cur.push(_chunkOKHKA43Lcjs.cloneAnchor.call(void 0, a));
+      cur.push(_chunkJBB3GDBBcjs.cloneAnchor.call(void 0, a));
       return;
     }
     if (cur.length) {
@@ -1561,10 +1561,10 @@ function cutSubpathAt(sp, at) {
 }
 function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   const n = sp.anchors.length;
-  if (segment < 0 || segment >= _chunkOKHKA43Lcjs.subpathSegmentCount.call(void 0, sp)) return [{ anchors: sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor), closed: sp.closed }];
+  if (segment < 0 || segment >= _chunkJBB3GDBBcjs.subpathSegmentCount.call(void 0, sp)) return [{ anchors: sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor), closed: sp.closed }];
   if (t <= endTolerance) return cutSubpathAt(sp, [segment]);
   if (t >= 1 - endTolerance) return cutSubpathAt(sp, [(segment + 1) % n]);
-  const { subpath, index } = _chunkOKHKA43Lcjs.insertAnchor.call(void 0, sp, segment, t);
+  const { subpath, index } = _chunkJBB3GDBBcjs.insertAnchor.call(void 0, sp, segment, t);
   return cutSubpathAt(subpath, [index]);
 }
 var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
@@ -1587,7 +1587,7 @@ function joinSubpaths(subpaths, tolerance) {
   const closed = [];
   let open = [];
   for (const sp of subpaths) {
-    const copy = { anchors: sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor), closed: sp.closed };
+    const copy = { anchors: sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor), closed: sp.closed };
     if (sp.closed || sp.anchors.length < 2) {
       if (sp.anchors.length) closed.push(copy);
     } else open.push(copy);
@@ -1642,7 +1642,7 @@ function smoothSubpath(sp, amount = 1, only) {
   const t = Math.min(1, Math.max(0, amount));
   const orig = sp.anchors;
   const n = orig.length;
-  const anchors = orig.map(_chunkOKHKA43Lcjs.cloneAnchor);
+  const anchors = orig.map(_chunkJBB3GDBBcjs.cloneAnchor);
   if (n < 3 || t === 0) return { anchors, closed: sp.closed };
   for (let i = 0; i < n; i++) {
     if (!sp.closed && (i === 0 || i === n - 1)) continue;
@@ -1671,8 +1671,8 @@ function smoothSubpath(sp, amount = 1, only) {
 }
 function segsOf(sp) {
   const out = [];
-  for (let i = 0; i < _chunkOKHKA43Lcjs.subpathSegmentCount.call(void 0, sp); i++) {
-    const s = _chunkOKHKA43Lcjs.subpathSegment.call(void 0, sp, i);
+  for (let i = 0; i < _chunkJBB3GDBBcjs.subpathSegmentCount.call(void 0, sp); i++) {
+    const s = _chunkJBB3GDBBcjs.subpathSegment.call(void 0, sp, i);
     out.push(s.length === 2 ? { c: s, line: true } : { c: s, line: false });
   }
   return out;
@@ -1729,7 +1729,7 @@ function removeRedundantPoints(sp, tolerance) {
   const tol = Math.max(tolerance, 1e-9);
   const types = new Map(sp.anchors.filter((a) => a.type).map((a) => [`${a.x},${a.y}`, a.type]));
   const segs = segsOf(sp).filter((s) => !isZeroSeg(s));
-  if (!segs.length) return { anchors: sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor), closed: sp.closed };
+  if (!segs.length) return { anchors: sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor), closed: sp.closed };
   const minSegs = sp.closed ? 2 : 1;
   let changed = true;
   while (changed && segs.length > minSegs) {
@@ -1747,7 +1747,7 @@ function removeRedundantPoints(sp, tolerance) {
       break;
     }
   }
-  return _nullishCoalesce(segsToSubpath(segs, sp.closed, types), () => ( { anchors: sp.anchors.map(_chunkOKHKA43Lcjs.cloneAnchor), closed: sp.closed }));
+  return _nullishCoalesce(segsToSubpath(segs, sp.closed, types), () => ( { anchors: sp.anchors.map(_chunkJBB3GDBBcjs.cloneAnchor), closed: sp.closed }));
 }