@pixerate/editor 0.135.0 → 0.137.0

package/dist/{chunk-6GFRKLLS.cjs → chunk-QBWEH3IM.cjs}

@@ -1,6 +1,7 @@
-"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 _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7;
+"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 _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8;
 
 
+var _chunkSYPFUL5Bcjs = require('./chunk-SYPFUL5B.cjs');
 
 
 
@@ -12,7 +13,16 @@
 
 
 
-var _chunkJ5BA3BQ6cjs = require('./chunk-J5BA3BQ6.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkO7LUD7MHcjs = require('./chunk-O7LUD7MH.cjs');
 
 // src/paint/rand.ts
 function mix32(h) {
@@ -237,7 +247,7 @@ var PaintGradientSampler = class {
       return out;
     }
     if (this.source.space === "pigment") {
-      _chunkJ5BA3BQ6cjs.mixPigment8.call(void 0, q8(ar[0]), q8(ar[1]), q8(ar[2]), q8(br[0]), q8(br[1]), q8(br[2]), v, mixScratch);
+      _chunkO7LUD7MHcjs.mixPigment8.call(void 0, q8(ar[0]), q8(ar[1]), q8(ar[2]), q8(br[0]), q8(br[1]), q8(br[2]), v, mixScratch);
       out.rgb = [mixScratch[0], mixScratch[1], mixScratch[2]];
     } else if (this.source.space === "oklab") {
       const la = a.lab;
@@ -721,7 +731,7 @@ function rasterizeDab(d, hardness, rect, out) {
     }
   }
 }
-var TILE_PIXELS = _chunkJ5BA3BQ6cjs.TILE * _chunkJ5BA3BQ6cjs.TILE;
+var TILE_PIXELS = _chunkO7LUD7MHcjs.TILE * _chunkO7LUD7MHcjs.TILE;
 var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this);_class2.prototype.__init13.call(this);_class2.prototype.__init14.call(this); }
   __init11() {this.tiles = /* @__PURE__ */ new Map()}
   /**
@@ -734,21 +744,21 @@ var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init11.c
   __init14() {this.dirty = /* @__PURE__ */ new Set()}
   /** The colour at a pixel (gradient paint), or `null` when the stroke has one colour there. */
   colorAt(x, y, out) {
-    const tx = Math.floor(x / _chunkJ5BA3BQ6cjs.TILE);
-    const ty = Math.floor(y / _chunkJ5BA3BQ6cjs.TILE);
-    const t = this.colors.get(_chunkJ5BA3BQ6cjs.tileKey.call(void 0, tx, ty));
+    const tx = Math.floor(x / _chunkO7LUD7MHcjs.TILE);
+    const ty = Math.floor(y / _chunkO7LUD7MHcjs.TILE);
+    const t = this.colors.get(_chunkO7LUD7MHcjs.tileKey.call(void 0, tx, ty));
     if (!t) return null;
-    const i = ((y - ty * _chunkJ5BA3BQ6cjs.TILE) * _chunkJ5BA3BQ6cjs.TILE + (x - tx * _chunkJ5BA3BQ6cjs.TILE)) * 3;
+    const i = ((y - ty * _chunkO7LUD7MHcjs.TILE) * _chunkO7LUD7MHcjs.TILE + (x - tx * _chunkO7LUD7MHcjs.TILE)) * 3;
     out[0] = t[i];
     out[1] = t[i + 1];
     out[2] = t[i + 2];
     return out;
   }
   get(x, y) {
-    const tx = Math.floor(x / _chunkJ5BA3BQ6cjs.TILE);
-    const ty = Math.floor(y / _chunkJ5BA3BQ6cjs.TILE);
-    const t = this.tiles.get(_chunkJ5BA3BQ6cjs.tileKey.call(void 0, tx, ty));
-    return t ? t[(y - ty * _chunkJ5BA3BQ6cjs.TILE) * _chunkJ5BA3BQ6cjs.TILE + (x - tx * _chunkJ5BA3BQ6cjs.TILE)] : 0;
+    const tx = Math.floor(x / _chunkO7LUD7MHcjs.TILE);
+    const ty = Math.floor(y / _chunkO7LUD7MHcjs.TILE);
+    const t = this.tiles.get(_chunkO7LUD7MHcjs.tileKey.call(void 0, tx, ty));
+    return t ? t[(y - ty * _chunkO7LUD7MHcjs.TILE) * _chunkO7LUD7MHcjs.TILE + (x - tx * _chunkO7LUD7MHcjs.TILE)] : 0;
   }
   /**
    * Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. With `color`
@@ -758,26 +768,26 @@ var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init11.c
   accumulate(rect, vals, ceil, color = null, field = null) {
     if (rect.width <= 0 || rect.height <= 0) return;
     const w = rect.width;
-    const tx0 = Math.floor(rect.x / _chunkJ5BA3BQ6cjs.TILE);
-    const ty0 = Math.floor(rect.y / _chunkJ5BA3BQ6cjs.TILE);
-    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunkJ5BA3BQ6cjs.TILE);
-    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunkJ5BA3BQ6cjs.TILE);
+    const tx0 = Math.floor(rect.x / _chunkO7LUD7MHcjs.TILE);
+    const ty0 = Math.floor(rect.y / _chunkO7LUD7MHcjs.TILE);
+    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunkO7LUD7MHcjs.TILE);
+    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunkO7LUD7MHcjs.TILE);
     let touched = false;
     for (let ty = ty0; ty <= ty1; ty++) {
       for (let tx = tx0; tx <= tx1; tx++) {
-        const x0 = Math.max(rect.x, tx * _chunkJ5BA3BQ6cjs.TILE);
-        const y0 = Math.max(rect.y, ty * _chunkJ5BA3BQ6cjs.TILE);
-        const x1 = Math.min(rect.x + rect.width, tx * _chunkJ5BA3BQ6cjs.TILE + _chunkJ5BA3BQ6cjs.TILE);
-        const y1 = Math.min(rect.y + rect.height, ty * _chunkJ5BA3BQ6cjs.TILE + _chunkJ5BA3BQ6cjs.TILE);
+        const x0 = Math.max(rect.x, tx * _chunkO7LUD7MHcjs.TILE);
+        const y0 = Math.max(rect.y, ty * _chunkO7LUD7MHcjs.TILE);
+        const x1 = Math.min(rect.x + rect.width, tx * _chunkO7LUD7MHcjs.TILE + _chunkO7LUD7MHcjs.TILE);
+        const y1 = Math.min(rect.y + rect.height, ty * _chunkO7LUD7MHcjs.TILE + _chunkO7LUD7MHcjs.TILE);
         let tile;
         for (let y = y0; y < y1; y++) {
           const row = (y - rect.y) * w;
-          const trow = (y - ty * _chunkJ5BA3BQ6cjs.TILE) * _chunkJ5BA3BQ6cjs.TILE;
+          const trow = (y - ty * _chunkO7LUD7MHcjs.TILE) * _chunkO7LUD7MHcjs.TILE;
           for (let x = x0; x < x1; x++) {
             const v = vals[row + (x - rect.x)];
             if (v <= 0) continue;
             if (!tile) {
-              const key = _chunkJ5BA3BQ6cjs.tileKey.call(void 0, tx, ty);
+              const key = _chunkO7LUD7MHcjs.tileKey.call(void 0, tx, ty);
               tile = this.tiles.get(key);
               if (!tile) {
                 tile = new Float32Array(TILE_PIXELS);
@@ -786,13 +796,13 @@ var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init11.c
               this.dirty.add(key);
               touched = true;
             }
-            const ti = trow + (x - tx * _chunkJ5BA3BQ6cjs.TILE);
+            const ti = trow + (x - tx * _chunkO7LUD7MHcjs.TILE);
             const c = tile[ti];
             if (ceil > c) {
               const next = c + v * (ceil - c);
               tile[ti] = next;
               if (color || field) {
-                const key = _chunkJ5BA3BQ6cjs.tileKey.call(void 0, tx, ty);
+                const key = _chunkO7LUD7MHcjs.tileKey.call(void 0, tx, ty);
                 let ct = this.colors.get(key);
                 if (!ct) {
                   ct = new Float32Array(TILE_PIXELS * 3);
@@ -917,29 +927,29 @@ function gradientDabColor(sampler, tipTable, d, params, rect, vals, scratch) {
 }
 function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}) {
   const out = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);
-  const ox = tx * _chunkJ5BA3BQ6cjs.TILE + s.offset.x;
-  const oy = ty * _chunkJ5BA3BQ6cjs.TILE + s.offset.y;
+  const ox = tx * _chunkO7LUD7MHcjs.TILE + s.offset.x;
+  const oy = ty * _chunkO7LUD7MHcjs.TILE + s.offset.y;
   let x0 = 0;
   let y0 = 0;
-  let x1 = _chunkJ5BA3BQ6cjs.TILE;
-  let y1 = _chunkJ5BA3BQ6cjs.TILE;
+  let x1 = _chunkO7LUD7MHcjs.TILE;
+  let y1 = _chunkO7LUD7MHcjs.TILE;
   if (options.region) {
     const r = options.region;
     x0 = Math.max(0, Math.floor(r.x) - ox);
     y0 = Math.max(0, Math.floor(r.y) - oy);
-    x1 = Math.min(_chunkJ5BA3BQ6cjs.TILE, Math.ceil(r.x + r.width) - ox);
-    y1 = Math.min(_chunkJ5BA3BQ6cjs.TILE, Math.ceil(r.y + r.height) - oy);
+    x1 = Math.min(_chunkO7LUD7MHcjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunkO7LUD7MHcjs.TILE, Math.ceil(r.y + r.height) - oy);
     if (x1 <= x0 || y1 <= y0) return out;
     if (options.into) {
-      for (let y = y0; y < y1; y++) out.set(tileData.subarray((y * _chunkJ5BA3BQ6cjs.TILE + x0) * channels, (y * _chunkJ5BA3BQ6cjs.TILE + x1) * channels), (y * _chunkJ5BA3BQ6cjs.TILE + x0) * channels);
+      for (let y = y0; y < y1; y++) out.set(tileData.subarray((y * _chunkO7LUD7MHcjs.TILE + x0) * channels, (y * _chunkO7LUD7MHcjs.TILE + x1) * channels), (y * _chunkO7LUD7MHcjs.TILE + x0) * channels);
     }
   }
   const sel = s.selection;
   const cb = [0, 0, 0, 0];
   const cs = [s.color[0] / 255, s.color[1] / 255, s.color[2] / 255, s.color[3] / 255];
   const bg = [s.background[0] / 255, s.background[1] / 255, s.background[2] / 255, s.background[3] / 255];
-  const aligned = s.offset.x % _chunkJ5BA3BQ6cjs.TILE === 0 && s.offset.y % _chunkJ5BA3BQ6cjs.TILE === 0;
-  const covTile = aligned ? coverage.tiles.get(_chunkJ5BA3BQ6cjs.tileKey.call(void 0, Math.floor(ox / _chunkJ5BA3BQ6cjs.TILE), Math.floor(oy / _chunkJ5BA3BQ6cjs.TILE))) : void 0;
+  const aligned = s.offset.x % _chunkO7LUD7MHcjs.TILE === 0 && s.offset.y % _chunkO7LUD7MHcjs.TILE === 0;
+  const covTile = aligned ? coverage.tiles.get(_chunkO7LUD7MHcjs.tileKey.call(void 0, Math.floor(ox / _chunkO7LUD7MHcjs.TILE), Math.floor(oy / _chunkO7LUD7MHcjs.TILE))) : void 0;
   if (aligned && !covTile) return out;
   const colored = s.mode === "paint" && coverage.colors.size > 0;
   const own = [0, 0, 0, cs[3]];
@@ -948,7 +958,7 @@ function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}
     const dy = oy + y;
     for (let x = x0; x < x1; x++) {
       const dx = ox + x;
-      const c = covTile ? covTile[y * _chunkJ5BA3BQ6cjs.TILE + x] : coverage.get(dx, dy);
+      const c = covTile ? covTile[y * _chunkO7LUD7MHcjs.TILE + x] : coverage.get(dx, dy);
       if (c <= 0) continue;
       const pixelColor = colored ? coverage.colorAt(dx, dy, own) : null;
       if (pixelColor) for (let ch = 0; ch < 3; ch++) ownBytes[ch] = Math.round(Math.min(1, Math.max(0, own[ch])) * 255);
@@ -959,7 +969,7 @@ function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}
       }
       if (k > 1) k = 1;
       if (k <= 0) continue;
-      const p = y * _chunkJ5BA3BQ6cjs.TILE + x;
+      const p = y * _chunkO7LUD7MHcjs.TILE + x;
       if (channels === 1) {
         const target = s.mode === "erase" ? s.background[0] : pixelColor ? Math.round(0.299 * ownBytes[0] + 0.587 * ownBytes[1] + 0.114 * ownBytes[2]) : s.color[0];
         out[p] = Math.round(out[p] + (target - out[p]) * k);
@@ -977,7 +987,7 @@ function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}
         const as = src[3] * k;
         if (!(as > 0)) continue;
         const ao = as + out[i + 3] / 255 * (1 - as);
-        _chunkJ5BA3BQ6cjs.mixPigment8.call(void 0, out[i], out[i + 1], out[i + 2], bytes[0], bytes[1], bytes[2], as / ao, cb);
+        _chunkO7LUD7MHcjs.mixPigment8.call(void 0, out[i], out[i + 1], out[i + 2], bytes[0], bytes[1], bytes[2], as / ao, cb);
         out[i] = Math.round(cb[0] * 255);
         out[i + 1] = Math.round(cb[1] * 255);
         out[i + 2] = Math.round(cb[2] * 255);
@@ -985,7 +995,7 @@ function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}
         continue;
       }
       for (let ch = 0; ch < 4; ch++) cb[ch] = out[i + ch] / 255;
-      const o = _chunkJ5BA3BQ6cjs.blendPixel.call(void 0, s.blend, cb, src, k);
+      const o = _chunkO7LUD7MHcjs.blendPixel.call(void 0, s.blend, cb, src, k);
       out[i] = Math.round(o[0] * 255);
       out[i + 1] = Math.round(o[1] * 255);
       out[i + 2] = Math.round(o[2] * 255);
@@ -999,25 +1009,25 @@ function applyStrokeToDeepTile(coverage, samples, tx, ty, s, options = {}) {
   const scale = linear ? 1 : 65535;
   const n = _nullishCoalesce(options.channels, () => ( 4));
   const out = (_nullishCoalesce(options.into, () => ( samples))).slice();
-  const ox = tx * _chunkJ5BA3BQ6cjs.TILE + s.offset.x;
-  const oy = ty * _chunkJ5BA3BQ6cjs.TILE + s.offset.y;
+  const ox = tx * _chunkO7LUD7MHcjs.TILE + s.offset.x;
+  const oy = ty * _chunkO7LUD7MHcjs.TILE + s.offset.y;
   let x0 = 0;
   let y0 = 0;
-  let x1 = _chunkJ5BA3BQ6cjs.TILE;
-  let y1 = _chunkJ5BA3BQ6cjs.TILE;
+  let x1 = _chunkO7LUD7MHcjs.TILE;
+  let y1 = _chunkO7LUD7MHcjs.TILE;
   if (options.region) {
     const r = options.region;
     x0 = Math.max(0, Math.floor(r.x) - ox);
     y0 = Math.max(0, Math.floor(r.y) - oy);
-    x1 = Math.min(_chunkJ5BA3BQ6cjs.TILE, Math.ceil(r.x + r.width) - ox);
-    y1 = Math.min(_chunkJ5BA3BQ6cjs.TILE, Math.ceil(r.y + r.height) - oy);
+    x1 = Math.min(_chunkO7LUD7MHcjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunkO7LUD7MHcjs.TILE, Math.ceil(r.y + r.height) - oy);
     if (x1 <= x0 || y1 <= y0) return out;
-    if (options.into) for (let y = y0; y < y1; y++) out.set(samples.subarray((y * _chunkJ5BA3BQ6cjs.TILE + x0) * n, (y * _chunkJ5BA3BQ6cjs.TILE + x1) * n), (y * _chunkJ5BA3BQ6cjs.TILE + x0) * n);
+    if (options.into) for (let y = y0; y < y1; y++) out.set(samples.subarray((y * _chunkO7LUD7MHcjs.TILE + x0) * n, (y * _chunkO7LUD7MHcjs.TILE + x1) * n), (y * _chunkO7LUD7MHcjs.TILE + x0) * n);
   }
   const grey = (s.mode === "erase" ? s.background[0] : s.color[0]) / 255 * scale;
   const colour = (c) => {
     const v = [c[0] / 255, c[1] / 255, c[2] / 255, c[3] / 255];
-    if (linear) for (let k = 0; k < 3; k++) v[k] = _chunkJ5BA3BQ6cjs.srgbDecode.call(void 0, v[k]);
+    if (linear) for (let k = 0; k < 3; k++) v[k] = _chunkO7LUD7MHcjs.srgbDecode.call(void 0, v[k]);
     return v;
   };
   const src0 = colour(s.mode === "erase" ? s.background : s.color);
@@ -1029,7 +1039,7 @@ function applyStrokeToDeepTile(coverage, samples, tx, ty, s, options = {}) {
   const cb = [0, 0, 0, 0];
   const mix = [0, 0, 0];
   const encCb = [0, 0, 0];
-  const encSrc0 = linear ? [_chunkJ5BA3BQ6cjs.srgbEncode.call(void 0, src0[0]), _chunkJ5BA3BQ6cjs.srgbEncode.call(void 0, src0[1]), _chunkJ5BA3BQ6cjs.srgbEncode.call(void 0, src0[2])] : src0;
+  const encSrc0 = linear ? [_chunkO7LUD7MHcjs.srgbEncode.call(void 0, src0[0]), _chunkO7LUD7MHcjs.srgbEncode.call(void 0, src0[1]), _chunkO7LUD7MHcjs.srgbEncode.call(void 0, src0[2])] : src0;
   const put = (i, v) => {
     out[i] = linear ? v : v <= 0 ? 0 : v >= 1 ? 65535 : Math.round(v * 65535);
   };
@@ -1049,17 +1059,17 @@ function applyStrokeToDeepTile(coverage, samples, tx, ty, s, options = {}) {
       if (k <= 0) continue;
       src = src0;
       if (pixelColor) {
-        for (let ch = 0; ch < 3; ch++) ownSrc[ch] = linear ? _chunkJ5BA3BQ6cjs.srgbDecode.call(void 0, own[ch]) : own[ch];
+        for (let ch = 0; ch < 3; ch++) ownSrc[ch] = linear ? _chunkO7LUD7MHcjs.srgbDecode.call(void 0, own[ch]) : own[ch];
         src = ownSrc;
       }
       if (n === 1) {
-        const p = y * _chunkJ5BA3BQ6cjs.TILE + x;
+        const p = y * _chunkO7LUD7MHcjs.TILE + x;
         const g = pixelColor ? (0.299 * own[0] + 0.587 * own[1] + 0.114 * own[2]) * scale : grey;
         const v = out[p] + (g - out[p]) * k;
         out[p] = linear ? v : Math.round(v);
         continue;
       }
-      const i = (y * _chunkJ5BA3BQ6cjs.TILE + x) * 4;
+      const i = (y * _chunkO7LUD7MHcjs.TILE + x) * 4;
       if (s.mode === "erase" && !s.lockTransparency) {
         put(i + 3, out[i + 3] / scale * (1 - k));
         if (out[i + 3] === 0) out[i] = out[i + 1] = out[i + 2] = 0;
@@ -1071,13 +1081,13 @@ function applyStrokeToDeepTile(coverage, samples, tx, ty, s, options = {}) {
         const as = src[3] * k;
         if (!(as > 0)) continue;
         const ao = as + cb[3] * (1 - as);
-        for (let ch = 0; ch < 3; ch++) encCb[ch] = linear ? _chunkJ5BA3BQ6cjs.srgbEncode.call(void 0, cb[ch]) : cb[ch];
-        _chunkJ5BA3BQ6cjs.mixPigmentRgb.call(void 0, encCb, pixelColor ? own : encSrc0, as / ao, mix);
-        for (let ch = 0; ch < 3; ch++) put(i + ch, linear ? _chunkJ5BA3BQ6cjs.srgbDecode.call(void 0, mix[ch]) : mix[ch]);
+        for (let ch = 0; ch < 3; ch++) encCb[ch] = linear ? _chunkO7LUD7MHcjs.srgbEncode.call(void 0, cb[ch]) : cb[ch];
+        _chunkO7LUD7MHcjs.mixPigmentRgb.call(void 0, encCb, pixelColor ? own : encSrc0, as / ao, mix);
+        for (let ch = 0; ch < 3; ch++) put(i + ch, linear ? _chunkO7LUD7MHcjs.srgbDecode.call(void 0, mix[ch]) : mix[ch]);
         if (!s.lockTransparency) put(i + 3, ao);
         continue;
       }
-      const o = _chunkJ5BA3BQ6cjs.blendPixel.call(void 0, s.blend, cb, src, k);
+      const o = _chunkO7LUD7MHcjs.blendPixel.call(void 0, s.blend, cb, src, k);
       put(i, o[0]);
       put(i + 1, o[1]);
       put(i + 2, o[2]);
@@ -1087,9 +1097,305 @@ function applyStrokeToDeepTile(coverage, samples, tx, ty, s, options = {}) {
   return out;
 }
 function coverageTileCoord(key) {
-  return _chunkJ5BA3BQ6cjs.tileCoord.call(void 0, key);
+  return _chunkO7LUD7MHcjs.tileCoord.call(void 0, key);
+}
+
+// src/paint/path-stroke.ts
+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: _nullishCoalesce(s.azimuth, () => ( 0)) };
+  }
+  if (typeof s.tiltX === "number" || typeof s.tiltY === "number") {
+    const tx = (_nullishCoalesce(s.tiltX, () => ( 0))) * Math.PI / 180;
+    const ty = (_nullishCoalesce(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 = _nullishCoalesce(options.tilt, () => ( {}));
+  const minSize = Math.min(1, Math.max(0, _nullishCoalesce(options.minSize, () => ( 0))));
+  let index = 0;
+  const t0 = _nullishCoalesce(_optionalChain([pts, 'access', _5 => _5.find, 'call', _6 => _6((s) => typeof s.t === "number" && Number.isFinite(s.t)), 'optionalAccess', _7 => _7.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 = _nullishCoalesce(_optionalChain([l, 'optionalAccess', _8 => _8.amount]), () => ( 0));
+    const size = brush.size * (brush.pressureSize ? minSize + (1 - minSize) * pr : 1) * (1 + 1.5 * (_nullishCoalesce(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 * (_nullishCoalesce(tilt.roundness, () => ( 0))) * lean0));
+    const op = brush.pressureOpacity ? pr : 1;
+    const params = { travel, index: index++, pressure: pr, lean: lean0, speed, direction: dir, time: time === null || t0 === null ? null : time - t0 };
+    return { x, y, radius: Math.max(0.5, size / 2), alpha: brush.flow, opacity: brush.opacity * op, 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 } : _nullishCoalesce(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 = _optionalChain([options, 'access', _9 => _9.gradient, 'optionalAccess', _10 => _10.paint, 'access', _11 => _11.type]) === "gradient" ? options.gradient : null;
+  const sampler = g ? new PaintGradientSampler(resolvePaintGradient(g.paint, _nullishCoalesce(g.colors, () => ( { paint: "#000000", secondary: "#ffffff" }))), _nullishCoalesce(g.seed, () => ( 0))) : null;
+  const tipTable = _optionalChain([sampler, 'optionalAccess', _12 => _12.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 };
+    }
+  }
+  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 (_optionalChain([options, 'access', _13 => _13.paint, 'optionalAccess', _14 => _14.paint, 'access', _15 => _15.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 = _optionalChain([options, 'access', _16 => _16.paint, 'optionalAccess', _17 => _17.paint, 'access', _18 => _18.type]) === "gradient" ? { ...options.paint, colors: _nullishCoalesce(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 = _nullishCoalesce(options.offset, () => ( { x: 0, y: 0 }));
+  const apply = {
+    mode: _nullishCoalesce(options.mode, () => ( "paint")),
+    color,
+    background: [0, 0, 0, 0],
+    opacity: brush.opacity,
+    blend: _nullishCoalesce(options.blend, () => ( brush.blend)),
+    lockTransparency: _nullishCoalesce(options.lockTransparency, () => ( false)),
+    selection: _nullishCoalesce(options.selection, () => ( null)),
+    offset
+  };
+  const tiles = new Map(surface.tiles);
+  for (const { tx, ty } of _chunkO7LUD7MHcjs.tilesInRect.call(void 0, { x: bounds.x - offset.x, y: bounds.y - offset.y, width: bounds.width, height: bounds.height })) {
+    const key = _chunkO7LUD7MHcjs.tileKey.call(void 0, tx, ty);
+    const src = _optionalChain([surface, 'access', _19 => _19.tiles, 'access', _20 => _20.get, 'call', _21 => _21(key), 'optionalAccess', _22 => _22.data]);
+    const base = src && src.length === _chunkO7LUD7MHcjs.TILE * _chunkO7LUD7MHcjs.TILE * 4 ? src : new Uint8ClampedArray(_chunkO7LUD7MHcjs.TILE * _chunkO7LUD7MHcjs.TILE * 4);
+    const t = _chunkO7LUD7MHcjs.finishTile.call(void 0, applyStrokeToTile(coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
+    if (t) tiles.set(key, t);
+    else tiles.delete(key);
+  }
+  return { surface: new (0, _chunkO7LUD7MHcjs.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 = _nullishCoalesce(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 = _nullishCoalesce(brush.engine, () => ( "dab"));
+  if (engine !== "dab") {
+    const label = _nullishCoalesce(_nullishCoalesce(brush.name, () => ( brush.id)), () => ( "This brush"));
+    const why = _nullishCoalesce(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 = _nullishCoalesce(brush.dynamics, () => ( {}));
+  const tilt = { size: _nullishCoalesce(d.tiltSize, () => ( 0)), roundness: _nullishCoalesce(d.tiltRoundness, () => ( 0)) };
+  return {
+    brush: normalizeBrush(brush.tip),
+    followPath: brush.rotation === "stroke",
+    minSize: _nullishCoalesce(d.minSize, () => ( 0)),
+    ...tilt.size || tilt.roundness ? { tilt } : {}
+  };
+}
+function isBrushstrokeBrush(brush) {
+  return !("tip" in brush) || !brush.tip || (_nullishCoalesce(brush.engine, () => ( "dab"))) === "dab";
+}
+var finite2 = (v) => typeof v === "number" && Number.isFinite(v);
+function renderBrushstroke(input, brush, options = {}) {
+  const strokeOptions = brushstrokeStrokeOptions(brush);
+  const samples = brushstrokeSamples(input);
+  for (const s of samples) if (!finite2(s.x) || !finite2(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 = _nullishCoalesce(_nullishCoalesce(solid, () => ( options.color)), () => ( [0, 0, 0, 255]));
+  let scale = finite2(options.scale) && options.scale > 0 ? Math.min(_chunkSYPFUL5Bcjs.BRUSHSTROKE_MAX_SCALE, Math.max(_chunkSYPFUL5Bcjs.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 * (_nullishCoalesce(_optionalChain([strokeOptions, 'access', _23 => _23.tilt, 'optionalAccess', _24 => _24.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 = finite2(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(_chunkSYPFUL5Bcjs.BRUSHSTROKE_MIN_SCALE, Math.sqrt(maxPixels / area));
+  const scaled = samples.map((s) => ({ ...s, x: s.x * scale, y: s.y * scale }));
+  const { surface, bounds, dabs } = paintPathStroke(_chunkO7LUD7MHcjs.emptySurface.call(void 0, 4), scaled, {
+    ...strokeOptions,
+    brush: { ...tip, size: tip.size * scale },
+    closed: _nullishCoalesce(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: _nullishCoalesce(options.seed, () => ( 0)) } } : {}
+  });
+  if (!bounds) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs };
+  const rect = bounds;
+  const data = _chunkO7LUD7MHcjs.readRegion.call(void 0, 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 ? _chunkO7LUD7MHcjs.pngDataUrl.call(void 0, 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 rest2 = JSON.stringify([tip, rest, _nullishCoalesce(_nullishCoalesce(options.paint, () => ( options.color)), () => ( null)), _nullishCoalesce(options.seed, () => ( 0)), _nullishCoalesce(options.closed, () => ( false)), _nullishCoalesce(options.maxPixels, () => ( null))]);
+  const scale = finite2(options.scale) ? options.scale : 1;
+  return `${hashString(path).toString(16)}:${path.length}:${hashString(rest2).toString(16)}:${scale}`;
+}
+var BrushstrokeCache = (_class4 = class {
+  constructor(capacity = 64) {;_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);
+    this.capacity = capacity;
+  }
+  
+  __init21() {this.entries = /* @__PURE__ */ new Map()}
+  /** Renders that missed the cache (for tests and stats). */
+  __init22() {this.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();
+  }
+}, _class4);
+
 // src/paint/exchange.ts
 var MIXING_MODELS = ["rgb", "pigment"];
 var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
@@ -1098,20 +1404,20 @@ var MIXER_DRAIN = 0.08;
 function exchangeRates(pickup, mix, load, mixing) {
   return { pickup: MIXER_PICKUP_RATE * pickup, mix: mix * pickup, drain: MIXER_DRAIN * (1 - load), mixing };
 }
-var PaintExchange = (_class4 = class {
-  constructor(rates, load) {;_class4.prototype.__init21.call(this);
+var PaintExchange = (_class5 = class {
+  constructor(rates, load) {;_class5.prototype.__init23.call(this);
     this.rates = rates;
     this.reservoir = load.reservoir ? [load.reservoir[0], load.reservoir[1], load.reservoir[2]] : null;
     this.amount = this.reservoir ? Math.min(1, Math.max(0, load.amount)) : 0;
     this.well = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;
-    this.pig = rates.mixing === "pigment" ? { res: _chunkJ5BA3BQ6cjs.createPigment.call(void 0, _nullishCoalesce(this.reservoir, () => ( [0, 0, 0]))), well: _chunkJ5BA3BQ6cjs.createPigment.call(void 0, _nullishCoalesce(this.well, () => ( [0, 0, 0]))), paint: _chunkJ5BA3BQ6cjs.createPigment.call(void 0, [0, 0, 0]), canvas: _chunkJ5BA3BQ6cjs.createPigment.call(void 0, [0, 0, 0]) } : null;
+    this.pig = rates.mixing === "pigment" ? { res: _chunkO7LUD7MHcjs.createPigment.call(void 0, _nullishCoalesce(this.reservoir, () => ( [0, 0, 0]))), well: _chunkO7LUD7MHcjs.createPigment.call(void 0, _nullishCoalesce(this.well, () => ( [0, 0, 0]))), paint: _chunkO7LUD7MHcjs.createPigment.call(void 0, [0, 0, 0]), canvas: _chunkO7LUD7MHcjs.createPigment.call(void 0, [0, 0, 0]) } : null;
   }
   
   
   
   
   
-  __init21() {this.out = [0, 0, 0]}
+  __init23() {this.out = [0, 0, 0]}
   /** What the brush carries now. */
   get load() {
     return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.well ? [...this.well] : null };
@@ -1122,7 +1428,7 @@ var PaintExchange = (_class4 = class {
   }
   /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
   get paintPigment() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _5 => _5.pig, 'optionalAccess', _6 => _6.paint]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _25 => _25.pig, 'optionalAccess', _26 => _26.paint]), () => ( null));
   }
   /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */
   setReservoirColor(r, g, b) {
@@ -1134,21 +1440,21 @@ var PaintExchange = (_class4 = class {
       this.reservoir[1] = g;
       this.reservoir[2] = b;
     }
-    if (this.pig) _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, this.pig.res, r, g, b);
+    if (this.pig) _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, this.pig.res, r, g, b);
   }
   /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */
   mix(a, pa, b, pb, t) {
     const o = this.out;
-    if (pa && pb) _chunkJ5BA3BQ6cjs.lerpPigmentInto.call(void 0, pa, pb, t, o, 0);
+    if (pa && pb) _chunkO7LUD7MHcjs.lerpPigmentInto.call(void 0, pa, pb, t, o, 0);
     else for (let c = 0; c < 3; c++) o[c] = a[c] + (b[c] - a[c]) * t;
     return o;
   }
   /** `a` mixed `t` of the way to `b` (sRGB 0..1) by the mixing model, into `out`. */
   mixColors(a, b, t, out) {
     if (this.pig) {
-      _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, this.pig.canvas, a[0], a[1], a[2]);
-      _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, this.pig.paint, b[0], b[1], b[2]);
-      _chunkJ5BA3BQ6cjs.lerpPigmentInto.call(void 0, this.pig.canvas, this.pig.paint, t, out, 0);
+      _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, this.pig.canvas, a[0], a[1], a[2]);
+      _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, this.pig.paint, b[0], b[1], b[2]);
+      _chunkO7LUD7MHcjs.lerpPigmentInto.call(void 0, this.pig.canvas, this.pig.paint, t, out, 0);
     } else for (let c = 0; c < 3; c++) out[c] = a[c] + (b[c] - a[c]) * t;
     return out;
   }
@@ -1158,11 +1464,11 @@ var PaintExchange = (_class4 = class {
     const pig = this.pig;
     if (!this.well) this.well = [sample.rgb[0], sample.rgb[1], sample.rgb[2]];
     else {
-      if (pig) _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, pig.canvas, sample.rgb[0], sample.rgb[1], sample.rgb[2]);
-      const o = this.mix(this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _7 => _7.well]), () => ( null)), sample.rgb, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _8 => _8.canvas]), () => ( null)), this.rates.pickup * sample.contact);
+      if (pig) _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, pig.canvas, sample.rgb[0], sample.rgb[1], sample.rgb[2]);
+      const o = this.mix(this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _27 => _27.well]), () => ( null)), sample.rgb, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _28 => _28.canvas]), () => ( null)), this.rates.pickup * sample.contact);
       this.well = [o[0], o[1], o[2]];
     }
-    if (pig) _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, pig.well, this.well[0], this.well[1], this.well[2]);
+    if (pig) _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, pig.well, this.well[0], this.well[1], this.well[2]);
   }
   /**
    * 2. The dab's paint: the reservoir mixed with the well, written to `out`. Returns the total
@@ -1177,7 +1483,7 @@ var PaintExchange = (_class4 = class {
     if (!(total > 1e-6)) return 0;
     const pig = this.pig;
     if (res && this.well) {
-      const m = this.mix(res, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _9 => _9.res]), () => ( null)), this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _10 => _10.well]), () => ( null)), wp / total);
+      const m = this.mix(res, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _29 => _29.res]), () => ( null)), this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _30 => _30.well]), () => ( null)), wp / total);
       out[0] = m[0];
       out[1] = m[1];
       out[2] = m[2];
@@ -1187,36 +1493,36 @@ var PaintExchange = (_class4 = class {
       out[1] = c[1];
       out[2] = c[2];
     }
-    if (pig) _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, pig.paint, out[0], out[1], out[2]);
+    if (pig) _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, pig.paint, out[0], out[1], out[2]);
     return total;
   }
   /** 3. The reservoir drains. */
   drain() {
     this.amount *= 1 - this.rates.drain;
   }
-}, _class4);
+}, _class5);
 function put255(px, i, v) {
   if (px instanceof Float32Array) px[i] = v > 0 ? v * 255 : 0;
   else px[i] = Math.round(v * 255);
 }
-var TileMedium = (_class5 = class {
-  constructor(target, options = {}) {;_class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);
+var TileMedium = (_class6 = class {
+  constructor(target, options = {}) {;_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);_class6.prototype.__init27.call(this);_class6.prototype.__init28.call(this);_class6.prototype.__init29.call(this);_class6.prototype.__init30.call(this);_class6.prototype.__init31.call(this);_class6.prototype.__init32.call(this);_class6.prototype.__init33.call(this);
     this.target = target;
     this.options = options;
   }
   
   
   // The tile last looked up by `locate` (and whether it came from `writeTile`).
-  __init22() {this.tx = NaN}
-  __init23() {this.ty = NaN}
-  __init24() {this.tile = null}
-  __init25() {this.writable = false}
-  __init26() {this.canvasPig = _chunkJ5BA3BQ6cjs.createPigment.call(void 0, [0, 0, 0])}
-  __init27() {this.paintPig = _chunkJ5BA3BQ6cjs.createPigment.call(void 0, [0, 0, 0])}
-  __init28() {this.paintKey = -1}
-  __init29() {this.cb = [0, 0, 0, 0]}
-  __init30() {this.src = [0, 0, 0, 1]}
-  __init31() {this.o = [0, 0, 0]}
+  __init24() {this.tx = NaN}
+  __init25() {this.ty = NaN}
+  __init26() {this.tile = null}
+  __init27() {this.writable = false}
+  __init28() {this.canvasPig = _chunkO7LUD7MHcjs.createPigment.call(void 0, [0, 0, 0])}
+  __init29() {this.paintPig = _chunkO7LUD7MHcjs.createPigment.call(void 0, [0, 0, 0])}
+  __init30() {this.paintKey = -1}
+  __init31() {this.cb = [0, 0, 0, 0]}
+  __init32() {this.src = [0, 0, 0, 1]}
+  __init33() {this.o = [0, 0, 0]}
   /** Forgets the cached tile (call when another writer may have replaced tiles). */
   reset() {
     this.tx = NaN;
@@ -1229,15 +1535,15 @@ var TileMedium = (_class5 = class {
     const t = this.target;
     const lx = dx - t.offset.x;
     const ly = dy - t.offset.y;
-    const tx = Math.floor(lx / _chunkJ5BA3BQ6cjs.TILE);
-    const ty = Math.floor(ly / _chunkJ5BA3BQ6cjs.TILE);
+    const tx = Math.floor(lx / _chunkO7LUD7MHcjs.TILE);
+    const ty = Math.floor(ly / _chunkO7LUD7MHcjs.TILE);
     if (tx !== this.tx || ty !== this.ty || write && !this.writable) {
       this.tx = tx;
       this.ty = ty;
       this.tile = write ? t.writeTile(tx, ty) : t.readTile(tx, ty);
       this.writable = write;
     }
-    return this.tile ? ((ly - ty * _chunkJ5BA3BQ6cjs.TILE) * _chunkJ5BA3BQ6cjs.TILE + (lx - tx * _chunkJ5BA3BQ6cjs.TILE)) * 4 : -1;
+    return this.tile ? ((ly - ty * _chunkO7LUD7MHcjs.TILE) * _chunkO7LUD7MHcjs.TILE + (lx - tx * _chunkO7LUD7MHcjs.TILE)) * 4 : -1;
   }
   /** The tile `locate` last found. */
   get pixels() {
@@ -1317,7 +1623,7 @@ var TileMedium = (_class5 = class {
           src[0] = pr;
           src[1] = pg;
           src[2] = pb;
-          const r = _chunkJ5BA3BQ6cjs.blendPixel.call(void 0, blend, cb, src, k);
+          const r = _chunkO7LUD7MHcjs.blendPixel.call(void 0, blend, cb, src, k);
           put255(px, i, r[0]);
           put255(px, i + 1, r[1]);
           put255(px, i + 2, r[2]);
@@ -1332,23 +1638,23 @@ var TileMedium = (_class5 = class {
           o[1] = pg;
           o[2] = pb;
         } else if (pigment && field) {
-          _chunkJ5BA3BQ6cjs.mixPigment8.call(void 0, Math.round(px[i]), Math.round(px[i + 1]), Math.round(px[i + 2]), Math.round(pr * 255), Math.round(pg * 255), Math.round(pb * 255), share, o);
+          _chunkO7LUD7MHcjs.mixPigment8.call(void 0, Math.round(px[i]), Math.round(px[i + 1]), Math.round(px[i + 2]), Math.round(pr * 255), Math.round(pg * 255), Math.round(pb * 255), share, o);
         } else if (pigment) {
           const key = px instanceof Float32Array ? -2 : px[i] << 16 | px[i + 1] << 8 | px[i + 2];
           if (key !== lastKey || key === -2) {
-            _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, this.canvasPig, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
+            _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, this.canvasPig, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
             lastKey = key;
           }
           let pp = paintPigment;
           if (!pp) {
             const pkey = Math.round(pr * 255) << 16 | Math.round(pg * 255) << 8 | Math.round(pb * 255);
             if (pkey !== this.paintKey) {
-              _chunkJ5BA3BQ6cjs.setPigmentColor.call(void 0, this.paintPig, pr, pg, pb);
+              _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, this.paintPig, pr, pg, pb);
               this.paintKey = pkey;
             }
             pp = this.paintPig;
           }
-          _chunkJ5BA3BQ6cjs.lerpPigmentInto.call(void 0, this.canvasPig, pp, share, o, 0);
+          _chunkO7LUD7MHcjs.lerpPigmentInto.call(void 0, this.canvasPig, pp, share, o, 0);
         } else {
           o[0] = px[i] / 255 + (pr - px[i] / 255) * share;
           o[1] = px[i + 1] / 255 + (pg - px[i + 1] / 255) * share;
@@ -1361,7 +1667,7 @@ var TileMedium = (_class5 = class {
       }
     }
   }
-}, _class5);
+}, _class6);
 
 // src/paint/blending.ts
 var DEFAULT_BLENDER = { strength: 0.5, distance: 0.35, mixing: "pigment" };
@@ -1377,9 +1683,9 @@ function blendRadius(settings, radius) {
   return Math.max(1, Math.round(settings.distance * 2 * radius));
 }
 function createBlenderScratch() {
-  return { sums: new Float64Array(0), mix: { rgb: [0, 0, 0], strength: 1, ks: new Float32Array(_chunkJ5BA3BQ6cjs.PIGMENT_BANDS), scatter: 1 }, out: [0, 0, 0] };
+  return { sums: new Float64Array(0), mix: { rgb: [0, 0, 0], strength: 1, ks: new Float32Array(_chunkO7LUD7MHcjs.PIGMENT_BANDS), scatter: 1 }, out: [0, 0, 0] };
 }
-var N = _chunkJ5BA3BQ6cjs.PIGMENT_BANDS;
+var N = _chunkO7LUD7MHcjs.PIGMENT_BANDS;
 function blenderDab(medium, rect, cov, opacity, radius, settings, scratch) {
   const R = blendRadius(settings, radius);
   const W = rect.width + 2 * R;
@@ -1404,7 +1710,7 @@ function blenderDab(medium, rect, cov, opacity, radius, settings, scratch) {
         const a = px[i + 3] / 255;
         if (a > 0) {
           if (pigment) {
-            const p = _chunkJ5BA3BQ6cjs.pigment8.call(void 0, Math.round(px[i]), Math.round(px[i + 1]), Math.round(px[i + 2]));
+            const p = _chunkO7LUD7MHcjs.pigment8.call(void 0, Math.round(px[i]), Math.round(px[i + 1]), Math.round(px[i + 2]));
             const sa = p.scatter * p.strength * a;
             for (let k = 0; k < N; k++) row[k] += sa * p.ks[k];
             row[N] += sa;
@@ -1462,8 +1768,8 @@ function blenderDab(medium, rect, cov, opacity, radius, settings, scratch) {
         const sa = sum(N, x1, y1, x2, y2);
         for (let c = 0; c < N; c++) mixPig.ks[c] = sum(c, x1, y1, x2, y2) / sa;
         mixPig.scatter = sa / asum;
-        if (a <= 0 || share >= 1) _chunkJ5BA3BQ6cjs.lerpPigmentInto.call(void 0, mixPig, mixPig, 0, out, 0);
-        else _chunkJ5BA3BQ6cjs.lerpPigmentInto.call(void 0, _chunkJ5BA3BQ6cjs.pigment8.call(void 0, Math.round(px[i]), Math.round(px[i + 1]), Math.round(px[i + 2])), mixPig, share, out, 0);
+        if (a <= 0 || share >= 1) _chunkO7LUD7MHcjs.lerpPigmentInto.call(void 0, mixPig, mixPig, 0, out, 0);
+        else _chunkO7LUD7MHcjs.lerpPigmentInto.call(void 0, _chunkO7LUD7MHcjs.pigment8.call(void 0, Math.round(px[i]), Math.round(px[i + 1]), Math.round(px[i + 2])), mixPig, share, out, 0);
       } else {
         for (let c = 0; c < 3; c++) {
           const m = sum(c, x1, y1, x2, y2) / asum;
@@ -1477,8 +1783,8 @@ function blenderDab(medium, rect, cov, opacity, radius, settings, scratch) {
     }
   }
 }
-var SmudgeTip = (_class6 = class {
-  constructor(settings, diameter) {;_class6.prototype.__init32.call(this);_class6.prototype.__init33.call(this);
+var SmudgeTip = (_class7 = class {
+  constructor(settings, diameter) {;_class7.prototype.__init34.call(this);_class7.prototype.__init35.call(this);
     this.settings = settings;
     this.size = Math.max(2, Math.min(512, Math.ceil(diameter)));
     this.patch = new Float32Array(this.size * this.size * 4);
@@ -1486,8 +1792,8 @@ var SmudgeTip = (_class6 = class {
   
   
   
-  __init32() {this.loaded = false}
-  __init33() {this.out = [0, 0, 0]}
+  __init34() {this.loaded = false}
+  __init35() {this.out = [0, 0, 0]}
   cell(d, px, py) {
     const s = this.size;
     const r = Math.max(0.5, d.radius);
@@ -1523,7 +1829,7 @@ var SmudgeTip = (_class6 = class {
   mix(a0, a1, a2, b0, b1, b2, t) {
     const o = this.out;
     if (this.settings.mixing === "pigment") {
-      _chunkJ5BA3BQ6cjs.mixPigment8.call(void 0, Math.round(a0 * 255), Math.round(a1 * 255), Math.round(a2 * 255), Math.round(b0 * 255), Math.round(b1 * 255), Math.round(b2 * 255), t, o);
+      _chunkO7LUD7MHcjs.mixPigment8.call(void 0, Math.round(a0 * 255), Math.round(a1 * 255), Math.round(a2 * 255), Math.round(b0 * 255), Math.round(b1 * 255), Math.round(b2 * 255), t, o);
     } else {
       o[0] = a0 + (b0 - a0) * t;
       o[1] = a1 + (b1 - a1) * t;
@@ -1598,7 +1904,7 @@ var SmudgeTip = (_class6 = class {
       }
     }
   }
-}, _class6);
+}, _class7);
 
 // src/paint/mixer.ts
 var DEFAULT_MIXER = {
@@ -1631,22 +1937,22 @@ function loadMixer(load, color) {
 function cleanMixer(load) {
   return { reservoir: load.reservoir, amount: load.amount, pickup: null };
 }
-var MixerStroke = (_class7 = class {
-  constructor(brush, settings, load, target) {;_class7.prototype.__init34.call(this);_class7.prototype.__init35.call(this);_class7.prototype.__init36.call(this);_class7.prototype.__init37.call(this);_class7.prototype.__init38.call(this);
+var MixerStroke = (_class8 = class {
+  constructor(brush, settings, load, target) {;_class8.prototype.__init36.call(this);_class8.prototype.__init37.call(this);_class8.prototype.__init38.call(this);_class8.prototype.__init39.call(this);_class8.prototype.__init40.call(this);
     this.brush = brush;
     this.walker = new DabWalker(brush);
     this.exchange = new PaintExchange(mixerRates(normalizeMixer(settings)), load);
     this.medium = new TileMedium(target);
   }
   
-  __init34() {this.dabCount = 0}
-  __init35() {this.bounds = null}
+  __init36() {this.dabCount = 0}
+  __init37() {this.bounds = null}
   
-  __init36() {this.smoothPos = null}
-  __init37() {this.buf = new Float32Array(0)}
+  __init38() {this.smoothPos = null}
+  __init39() {this.buf = new Float32Array(0)}
   
   
-  __init38() {this.paintColor = [0, 0, 0]}
+  __init40() {this.paintColor = [0, 0, 0]}
   /** The brush load after the dabs so far. */
   get load() {
     return this.exchange.load;
@@ -1694,7 +2000,7 @@ var MixerStroke = (_class7 = class {
     }
     ex.drain();
   }
-}, _class7);
+}, _class8);
 function union(a, b) {
   if (!a) return { ...b };
   const x = Math.min(a.x, b.x);
@@ -1778,5 +2084,16 @@ function union(a, b) {
 
 
 
-exports.mix32 = mix32; exports.hash2 = hash2; exports.rand01 = rand01; exports.PAINT_GRADIENT_SPACES = PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_REPEATS = PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_MAPPINGS = PAINT_GRADIENT_MAPPINGS; exports.DEFAULT_PAINT_GRADIENT_MAPPING = DEFAULT_PAINT_GRADIENT_MAPPING; exports.PAINT_GRADIENT_FULL_SPEED = PAINT_GRADIENT_FULL_SPEED; exports.PaintSourceError = PaintSourceError; exports.normalizeHexColor = normalizeHexColor; exports.hexToPaintRgb = hexToPaintRgb; exports.parsePaintSource = parsePaintSource; exports.readPaintSource = readPaintSource; exports.resolvePaintGradient = resolvePaintGradient; exports.scalePaintGradient = scalePaintGradient; exports.solidPaint = solidPaint; exports.isGradientPaint = isGradientPaint; exports.paintSourceColor = paintSourceColor; exports.paintSourceCss = paintSourceCss; exports.PaintGradientSampler = PaintGradientSampler; exports.PAINT_GRADIENT_JSON_SCHEMA = PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_COLOR_JSON_SCHEMA = PAINT_COLOR_JSON_SCHEMA; exports.PAINT_SOURCE_JSON_SCHEMA = PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_GRADIENT_MAPPING_LABELS = PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_SPACE_LABELS = PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_GRADIENT_REPEAT_LABELS = PAINT_GRADIENT_REPEAT_LABELS; exports.DEFAULT_PAINT_GRADIENT = DEFAULT_PAINT_GRADIENT; exports.PAINT_GRADIENT_PRESETS = PAINT_GRADIENT_PRESETS; exports.addPaintGradientStop = addPaintGradientStop; exports.removePaintGradientStop = removePaintGradientStop; exports.updatePaintGradientStop = updatePaintGradientStop; exports.reversePaintGradient = reversePaintGradient; exports.paintGradientMappingFor = paintGradientMappingFor; exports.PAINT_GRADIENT_KIT = PAINT_GRADIENT_KIT; exports.DEFAULT_BRUSH = DEFAULT_BRUSH; exports.MAX_BRUSH_SIZE = MAX_BRUSH_SIZE; exports.normalizeBrush = normalizeBrush; exports.tipShape = tipShape; exports.tipFalloff = tipFalloff; exports.tipReach = tipReach; exports.dabCoverage = dabCoverage; exports.smoothPoints = smoothPoints; exports.DabWalker = DabWalker; exports.walkDabs = walkDabs; exports.dabRect = dabRect; exports.rasterizeDab = rasterizeDab; exports.CoverageMap = CoverageMap; exports.StrokeCoverage = StrokeCoverage; exports.TIP_GRADIENT_STEPS = TIP_GRADIENT_STEPS; exports.gradientDabColor = gradientDabColor; exports.applyStrokeToTile = applyStrokeToTile; exports.applyStrokeToDeepTile = applyStrokeToDeepTile; exports.coverageTileCoord = coverageTileCoord; exports.MIXING_MODELS = MIXING_MODELS; exports.EMPTY_MIXER_LOAD = EMPTY_MIXER_LOAD; exports.MIXER_PICKUP_RATE = MIXER_PICKUP_RATE; exports.MIXER_DRAIN = MIXER_DRAIN; exports.exchangeRates = exchangeRates; exports.PaintExchange = PaintExchange; exports.put255 = put255; exports.TileMedium = TileMedium; exports.DEFAULT_BLENDER = DEFAULT_BLENDER; exports.DEFAULT_SMUDGE = DEFAULT_SMUDGE; exports.normalizeBlender = normalizeBlender; exports.normalizeSmudge = normalizeSmudge; exports.blendRadius = blendRadius; exports.createBlenderScratch = createBlenderScratch; exports.blenderDab = blenderDab; exports.SmudgeTip = SmudgeTip; exports.DEFAULT_MIXER = DEFAULT_MIXER; exports.normalizeMixer = normalizeMixer; exports.mixerRates = mixerRates; exports.loadMixer = loadMixer; exports.cleanMixer = cleanMixer; exports.MixerStroke = MixerStroke;
-//# sourceMappingURL=chunk-6GFRKLLS.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+exports.mix32 = mix32; exports.hash2 = hash2; exports.rand01 = rand01; exports.PAINT_GRADIENT_SPACES = PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_REPEATS = PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_MAPPINGS = PAINT_GRADIENT_MAPPINGS; exports.DEFAULT_PAINT_GRADIENT_MAPPING = DEFAULT_PAINT_GRADIENT_MAPPING; exports.PAINT_GRADIENT_FULL_SPEED = PAINT_GRADIENT_FULL_SPEED; exports.PaintSourceError = PaintSourceError; exports.normalizeHexColor = normalizeHexColor; exports.hexToPaintRgb = hexToPaintRgb; exports.parsePaintSource = parsePaintSource; exports.readPaintSource = readPaintSource; exports.resolvePaintGradient = resolvePaintGradient; exports.scalePaintGradient = scalePaintGradient; exports.solidPaint = solidPaint; exports.isGradientPaint = isGradientPaint; exports.paintSourceColor = paintSourceColor; exports.paintSourceCss = paintSourceCss; exports.PaintGradientSampler = PaintGradientSampler; exports.PAINT_GRADIENT_JSON_SCHEMA = PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_COLOR_JSON_SCHEMA = PAINT_COLOR_JSON_SCHEMA; exports.PAINT_SOURCE_JSON_SCHEMA = PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_GRADIENT_MAPPING_LABELS = PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_SPACE_LABELS = PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_GRADIENT_REPEAT_LABELS = PAINT_GRADIENT_REPEAT_LABELS; exports.DEFAULT_PAINT_GRADIENT = DEFAULT_PAINT_GRADIENT; exports.PAINT_GRADIENT_PRESETS = PAINT_GRADIENT_PRESETS; exports.addPaintGradientStop = addPaintGradientStop; exports.removePaintGradientStop = removePaintGradientStop; exports.updatePaintGradientStop = updatePaintGradientStop; exports.reversePaintGradient = reversePaintGradient; exports.paintGradientMappingFor = paintGradientMappingFor; exports.PAINT_GRADIENT_KIT = PAINT_GRADIENT_KIT; exports.DEFAULT_BRUSH = DEFAULT_BRUSH; exports.MAX_BRUSH_SIZE = MAX_BRUSH_SIZE; exports.normalizeBrush = normalizeBrush; exports.tipShape = tipShape; exports.tipFalloff = tipFalloff; exports.tipReach = tipReach; exports.dabCoverage = dabCoverage; exports.smoothPoints = smoothPoints; exports.DabWalker = DabWalker; exports.walkDabs = walkDabs; exports.dabRect = dabRect; exports.rasterizeDab = rasterizeDab; exports.CoverageMap = CoverageMap; exports.StrokeCoverage = StrokeCoverage; exports.TIP_GRADIENT_STEPS = TIP_GRADIENT_STEPS; exports.gradientDabColor = gradientDabColor; exports.applyStrokeToTile = applyStrokeToTile; exports.applyStrokeToDeepTile = applyStrokeToDeepTile; exports.coverageTileCoord = coverageTileCoord; exports.pathStrokeDabs = pathStrokeDabs; exports.pathStrokeCoverage = pathStrokeCoverage; exports.paintPathStroke = paintPathStroke; exports.brushstrokeSamples = brushstrokeSamples; exports.brushstrokeStrokeOptions = brushstrokeStrokeOptions; exports.isBrushstrokeBrush = isBrushstrokeBrush; exports.renderBrushstroke = renderBrushstroke; exports.brushstrokeDataUrl = brushstrokeDataUrl; exports.brushstrokeToCanvas = brushstrokeToCanvas; exports.brushstrokeKey = brushstrokeKey; exports.BrushstrokeCache = BrushstrokeCache; exports.MIXING_MODELS = MIXING_MODELS; exports.EMPTY_MIXER_LOAD = EMPTY_MIXER_LOAD; exports.MIXER_PICKUP_RATE = MIXER_PICKUP_RATE; exports.MIXER_DRAIN = MIXER_DRAIN; exports.exchangeRates = exchangeRates; exports.PaintExchange = PaintExchange; exports.put255 = put255; exports.TileMedium = TileMedium; exports.DEFAULT_BLENDER = DEFAULT_BLENDER; exports.DEFAULT_SMUDGE = DEFAULT_SMUDGE; exports.normalizeBlender = normalizeBlender; exports.normalizeSmudge = normalizeSmudge; exports.blendRadius = blendRadius; exports.createBlenderScratch = createBlenderScratch; exports.blenderDab = blenderDab; exports.SmudgeTip = SmudgeTip; exports.DEFAULT_MIXER = DEFAULT_MIXER; exports.normalizeMixer = normalizeMixer; exports.mixerRates = mixerRates; exports.loadMixer = loadMixer; exports.cleanMixer = cleanMixer; exports.MixerStroke = MixerStroke;
+//# sourceMappingURL=chunk-QBWEH3IM.cjs.map