@pixerate/editor 0.137.0 → 0.138.0

package/dist/{chunk-QBWEH3IM.cjs → chunk-3T5O225T.cjs}

@@ -1,4 +1,4 @@
-"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;
+"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 _class9; var _class10;
 
 
 var _chunkSYPFUL5Bcjs = require('./chunk-SYPFUL5B.cjs');
@@ -40,6 +40,73 @@ function hash2(x, y, salt) {
 function rand01(seed, index, stream) {
   return hash2(index, stream, seed);
 }
+function randSigned(seed, index, stream) {
+  return rand01(seed, index, stream) * 2 - 1;
+}
+function seedFromString(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return mix32(h >>> 0);
+}
+var smooth = (t) => t * t * (3 - 2 * t);
+var Lattice = class {
+  constructor(px, py, salt) {
+    this.px = px;
+    this.py = py;
+    this.values = new Float32Array(px * py);
+    for (let j = 0; j < py; j++) for (let i = 0; i < px; i++) this.values[j * px + i] = hash2(i, j, salt);
+  }
+  
+  
+  
+  /** Value noise at (x, y) in lattice cells; wraps every `px` / `py` cells. */
+  at(x, y) {
+    const { px, py } = this;
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const tx = smooth(x - x0);
+    const ty = smooth(y - y0);
+    const i0 = (x0 % px + px) % px;
+    const j0 = (y0 % py + py) % py;
+    const i1 = (i0 + 1) % px;
+    const j1 = (j0 + 1) % py;
+    const v = this.values;
+    const a = v[j0 * px + i0] + (v[j0 * px + i1] - v[j0 * px + i0]) * tx;
+    const b = v[j1 * px + i0] + (v[j1 * px + i1] - v[j1 * px + i0]) * tx;
+    return a + (b - a) * ty;
+  }
+};
+var TileableNoise = (_class = class {
+  constructor(size, cellsX, cellsY, octaves, salt) {;_class.prototype.__init.call(this);
+    this.size = size;
+    let cx = Math.max(1, Math.round(cellsX));
+    let cy = Math.max(1, Math.round(cellsY));
+    for (let o = 0; o < octaves; o++) {
+      this.octaves.push(new Lattice(cx, cy, salt + o * 7919 | 0));
+      cx *= 2;
+      cy *= 2;
+    }
+  }
+  
+  __init() {this.octaves = []}
+  /** Fractal noise at pixel (x, y). */
+  at(x, y) {
+    let sum = 0;
+    let amp = 1;
+    let norm = 0;
+    const u = x / this.size;
+    const v = y / this.size;
+    for (const l of this.octaves) {
+      sum += l.at(u * l.px, v * l.py) * amp;
+      norm += amp;
+      amp *= 0.5;
+    }
+    return norm > 0 ? sum / norm : 0.5;
+  }
+}, _class);
 
 // src/paint/gradient-paint.ts
 var PAINT_GRADIENT_SPACES = ["pigment", "oklab", "srgb"];
@@ -587,21 +654,21 @@ function smoothPoints(points, amount) {
   return out;
 }
 var pressureOf = (p) => typeof p.pressure === "number" && Number.isFinite(p.pressure) ? Math.min(1, Math.max(0, p.pressure)) : 1;
-var DabWalker = (_class = class {
-  constructor(brush) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);
+var DabWalker = (_class2 = class {
+  constructor(brush) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);
     this.brush = brush;
   }
   
-  __init() {this.last = null}
-  __init2() {this.nextAt = 0}
-  __init3() {this.pendingFirst = null}
-  __init4() {this.index = 0}
-  __init5() {this.travelled = 0}
-  __init6() {this.dir = 0}
-  __init7() {this.firstT = null}
-  __init8() {this.lastSpeedT = null}
-  __init9() {this.lastSpeedAt = null}
-  __init10() {this.speed = null}
+  __init2() {this.last = null}
+  __init3() {this.nextAt = 0}
+  __init4() {this.pendingFirst = null}
+  __init5() {this.index = 0}
+  __init6() {this.travelled = 0}
+  __init7() {this.dir = 0}
+  __init8() {this.firstT = null}
+  __init9() {this.lastSpeedT = null}
+  __init10() {this.lastSpeedAt = null}
+  __init11() {this.speed = null}
   diameter(p) {
     return this.brush.pressureSize ? this.brush.size * pressureOf(p) : this.brush.size;
   }
@@ -674,7 +741,7 @@ var DabWalker = (_class = class {
       this.pendingFirst = null;
     }
   }
-}, _class);
+}, _class2);
 function walkDabs(points, brush) {
   const w = new DabWalker(brush);
   const out = [];
@@ -732,16 +799,16 @@ function rasterizeDab(d, hardness, rect, out) {
   }
 }
 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()}
+var CoverageMap = (_class3 = class {constructor() { _class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this); }
+  __init12() {this.tiles = /* @__PURE__ */ new Map()}
   /**
    * Gradient paint: the colour laid at each pixel (sRGB 0..1, 3 per pixel), when dabs carry their
    * own colours. Each dab blends its colour in by the share of coverage it adds. Missing: the
    * stroke's one colour (`StrokeApply.color`).
    */
-  __init12() {this.colors = /* @__PURE__ */ new Map()}
-  __init13() {this.bounds = null}
-  __init14() {this.dirty = /* @__PURE__ */ new Set()}
+  __init13() {this.colors = /* @__PURE__ */ new Map()}
+  __init14() {this.bounds = null}
+  __init15() {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 / _chunkO7LUD7MHcjs.TILE);
@@ -829,16 +896,16 @@ var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init11.c
     this.dirty.clear();
     return out;
   }
-}, _class2);
+}, _class3);
 function unionRect(a, b) {
   if (!a) return { ...b };
   const x = Math.min(a.x, b.x);
   const y = Math.min(a.y, b.y);
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
-var StrokeCoverage = (_class3 = class {
+var StrokeCoverage = (_class4 = class {
   /** `paint`: a gradient source (resolved: no `paint` / `secondary` stops) for gradient paint; `seed` for its `random` mapping. */
-  constructor(brush, paint = null, seed = 0) {;_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);
+  constructor(brush, paint = null, seed = 0) {;_class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);
     this.brush = brush;
     this.walker = new DabWalker(brush);
     this.smoothing = brush.smoothing;
@@ -846,16 +913,16 @@ var StrokeCoverage = (_class3 = class {
     this.tipTable = _optionalChain([this, 'access', _3 => _3.sampler, 'optionalAccess', _4 => _4.acrossTip]) ? this.sampler.tipTable(TIP_GRADIENT_STEPS) : null;
   }
   
-  __init15() {this.coverage = new CoverageMap()}
+  __init16() {this.coverage = new CoverageMap()}
   
   
-  __init16() {this.smoothPos = null}
-  __init17() {this.buf = new Float32Array(0)}
-  __init18() {this.field = new Float32Array(0)}
+  __init17() {this.smoothPos = null}
+  __init18() {this.buf = new Float32Array(0)}
+  __init19() {this.field = new Float32Array(0)}
   
   
-  __init19() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
-  __init20() {this.dabCount = 0}
+  __init20() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
+  __init21() {this.dabCount = 0}
   /** Feeds input points; returns the document rectangles the new dabs touched. */
   push(points) {
     const dabs = [];
@@ -897,7 +964,7 @@ var StrokeCoverage = (_class3 = class {
     this.field = scratch.field;
     this.coverage.accumulate(rect, vals, d.opacity, color, field);
   }
-}, _class3);
+}, _class4);
 var TIP_GRADIENT_STEPS = 32;
 function gradientDabColor(sampler, tipTable, d, params, rect, vals, scratch) {
   if (!tipTable) {
@@ -1100,7 +1167,181 @@ function coverageTileCoord(key) {
   return _chunkO7LUD7MHcjs.tileCoord.call(void 0, key);
 }
 
+// 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 = (_class5 = class {
+  __init22() {this.size = GRAIN_TILE}
+  
+  
+  
+  
+  constructor(paper, media = "dry") {;_class5.prototype.__init22.call(this);
+    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";
+  }
+  /** 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.scale - 0.5;
+    const v = y / 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;
+  }
+}, _class5);
+function grainCatch(h, depth, pressure) {
+  if (depth <= 0) return 1;
+  const t = depth * (0.75 - 0.65 * Math.min(1, Math.max(0, pressure)));
+  const u = clamp01((h - t + 0.18) / 0.36);
+  return 1 - depth + depth * u * u * (3 - 2 * u);
+}
+function strokeGrainCatch(h, depth, pressure) {
+  if (depth <= 0) return 1;
+  const p = Math.min(1, Math.max(0, pressure));
+  const amount = Math.min(1, depth * (1.4 - 0.6 * p));
+  const u = clamp01((h - 0.2 - 0.25 * (1 - p)) / 0.5);
+  return 1 - amount + amount * u * u * (3 - 2 * u);
+}
+
 // src/paint/path-stroke.ts
+var JITTER_SIZE = 1;
+var JITTER_ANGLE = 2;
+var JITTER_OPACITY = 3;
+var JITTER_SCATTER = 4;
 function lean(s) {
   if (typeof s.altitude === "number" && Number.isFinite(s.altitude)) {
     return { amount: 1 - Math.min(1, Math.max(0, s.altitude / (Math.PI / 2))), azimuth: _nullishCoalesce(s.azimuth, () => ( 0)) };
@@ -1132,8 +1373,22 @@ function pathStrokeDabs(samples, options) {
     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 i = index++;
+    const params = { travel, index: i, pressure: pr, lean: lean0, speed, direction: dir, time: time === null || t0 === null ? null : time - t0 };
+    let diameter = size;
+    let opacity = brush.opacity * op;
+    const j = options.jitter;
+    if (j) {
+      if (j.size) diameter *= Math.max(0.05, 1 + j.size * randSigned(j.seed, i, JITTER_SIZE));
+      if (j.angle) angle += j.angle * Math.PI * randSigned(j.seed, i, JITTER_ANGLE);
+      if (j.opacity) opacity *= 1 - j.opacity * (randSigned(j.seed, i, JITTER_OPACITY) * 0.5 + 0.5);
+      if (j.scatter) {
+        const off = j.scatter * diameter * randSigned(j.seed, i, JITTER_SCATTER);
+        x += Math.sin(dir) * off;
+        y += Math.cos(dir) * off;
+      }
+    }
+    return { x, y, radius: Math.max(0.5, diameter / 2), alpha: brush.flow, opacity, angle, roundness, params };
   };
   const out = [];
   const pressure = (s) => typeof s.pressure === "number" && Number.isFinite(s.pressure) ? s.pressure : 1;
@@ -1202,6 +1457,17 @@ function pathStrokeCoverage(samples, options) {
       bounds = { x, y, width: Math.max(bounds.x + bounds.width, rect.x + rect.width) - x, height: Math.max(bounds.y + bounds.height, rect.y + rect.height) - y };
     }
   }
+  const grain = options.grain;
+  if (grain && grain.depth > 0 && dabs.length) {
+    const pressure = dabs.reduce((sum, d) => sum + (_nullishCoalesce(_optionalChain([d, 'access', _13 => _13.params, 'optionalAccess', _14 => _14.pressure]), () => ( 1))), 0) / dabs.length;
+    for (const [key, t] of coverage.tiles) {
+      const { tx, ty } = _chunkO7LUD7MHcjs.tileCoord.call(void 0, key);
+      for (let y = 0, k = 0; y < _chunkO7LUD7MHcjs.TILE; y++) {
+        const gy = ty * _chunkO7LUD7MHcjs.TILE + y + 0.5;
+        for (let x = 0; x < _chunkO7LUD7MHcjs.TILE; x++, k++) if (t[k] > 0) t[k] *= strokeGrainCatch(grain.at(tx * _chunkO7LUD7MHcjs.TILE + x + 0.5, gy), grain.depth, pressure);
+      }
+    }
+  }
   return { coverage, bounds, dabs: dabs.length };
 }
 function paintPathStroke(surface, samples, options) {
@@ -1209,11 +1475,11 @@ function paintPathStroke(surface, samples, options) {
   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") {
+  if (_optionalChain([options, 'access', _15 => _15.paint, 'optionalAccess', _16 => _16.paint, 'access', _17 => _17.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 gradient = _optionalChain([options, 'access', _18 => _18.paint, 'optionalAccess', _19 => _19.paint, 'access', _20 => _20.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 }));
@@ -1230,7 +1496,7 @@ function paintPathStroke(surface, samples, options) {
   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 src = _optionalChain([surface, 'access', _21 => _21.tiles, 'access', _22 => _22.get, 'call', _23 => _23(key), 'optionalAccess', _24 => _24.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);
@@ -1296,6 +1562,26 @@ function isBrushstrokeBrush(brush) {
   return !("tip" in brush) || !brush.tip || (_nullishCoalesce(brush.engine, () => ( "dab"))) === "dab";
 }
 var finite2 = (v) => typeof v === "number" && Number.isFinite(v);
+function brushCharacterOf(brush) {
+  if (!("tip" in brush) || !brush.tip) return { grain: 0, size: 0, angle: 0, opacity: 0, scatter: 0 };
+  const d = _nullishCoalesce(brush.dynamics, () => ( {}));
+  const u = (v, hi = 1) => finite2(v) ? Math.min(hi, Math.max(0, v)) : 0;
+  return { grain: u(brush.grain), size: u(d.sizeJitter), angle: u(d.angleJitter), opacity: u(d.opacityJitter), scatter: u(d.scatter, 4) };
+}
+var papers = /* @__PURE__ */ new Map();
+function paperGrain(paper) {
+  const pattern = _nullishCoalesce(paper.pattern, () => ( "sanded"));
+  const seed = finite2(paper.seed) ? Math.round(Math.abs(paper.seed)) : 1;
+  const scale = finite2(paper.scale) && paper.scale > 0 ? Math.min(8, Math.max(0.25, paper.scale)) : 1;
+  const key = `${pattern}:${seed}:${scale}`;
+  let g = papers.get(key);
+  if (!g) {
+    g = new PaperGrain({ pattern, seed, scale, tiling: "mirror", dry: { contrast: 1, invert: false }, wet: { contrast: 1, invert: false } });
+    if (papers.size > 16) papers.delete(papers.keys().next().value);
+    papers.set(key, g);
+  }
+  return g;
+}
 function renderBrushstroke(input, brush, options = {}) {
   const strokeOptions = brushstrokeStrokeOptions(brush);
   const samples = brushstrokeSamples(input);
@@ -1306,7 +1592,7 @@ function renderBrushstroke(input, brush, options = {}) {
   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;
+  const reach = tip.size * (1 + 1.5 * (_nullishCoalesce(_optionalChain([strokeOptions, 'access', _25 => _25.tilt, 'optionalAccess', _26 => _26.size]), () => ( 0)))) + 4;
   let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
   for (const s of samples) {
     x0 = Math.min(x0, s.x);
@@ -1318,8 +1604,27 @@ function renderBrushstroke(input, brush, options = {}) {
   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 }));
+  let character = {};
+  if (options.character) {
+    const c = brushCharacterOf(brush);
+    const ch = options.character;
+    const seed = finite2(ch.seed) ? ch.seed | 0 : hashString(JSON.stringify(input));
+    const jitter = c.size || c.angle || c.opacity || c.scatter ? { seed, size: c.size, angle: c.angle, opacity: c.opacity, scatter: c.scatter } : void 0;
+    const paper = ch.paper === null ? null : _nullishCoalesce(ch.paper, () => ( {}));
+    const depth = paper ? Math.min(1, Math.max(0, (finite2(paper.depth) ? paper.depth : 0.5) * c.grain)) : 0;
+    let grain;
+    if (paper && depth > 0) {
+      const g = paperGrain(paper);
+      const ox = _nullishCoalesce(_optionalChain([ch, 'access', _27 => _27.origin, 'optionalAccess', _28 => _28.x]), () => ( 0));
+      const oy = _nullishCoalesce(_optionalChain([ch, 'access', _29 => _29.origin, 'optionalAccess', _30 => _30.y]), () => ( 0));
+      const k = (finite2(ch.unit) && ch.unit > 0 ? ch.unit : 1) / scale;
+      grain = { depth, at: (x, y) => g.at(ox + x * k, oy + y * k) };
+    }
+    character = { ...jitter ? { jitter } : {}, ...grain ? { grain } : {} };
+  }
   const { surface, bounds, dabs } = paintPathStroke(_chunkO7LUD7MHcjs.emptySurface.call(void 0, 4), scaled, {
     ...strokeOptions,
+    ...character,
     brush: { ...tip, size: tip.size * scale },
     closed: _nullishCoalesce(options.closed, () => ( strokeOptions.closed)),
     color,
@@ -1361,18 +1666,19 @@ function hashString(s, h = 2166136261) {
 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 character = options.character ? [options.character, brushCharacterOf(brush)] : null;
+  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)), ...character ? [character] : []]);
   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);
+var BrushstrokeCache = (_class6 = class {
+  constructor(capacity = 64) {;_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);
     this.capacity = capacity;
   }
   
-  __init21() {this.entries = /* @__PURE__ */ new Map()}
+  __init23() {this.entries = /* @__PURE__ */ new Map()}
   /** Renders that missed the cache (for tests and stats). */
-  __init22() {this.misses = 0}
+  __init24() {this.misses = 0}
   get size() {
     return this.entries.size;
   }
@@ -1394,7 +1700,7 @@ var BrushstrokeCache = (_class4 = class {
   clear() {
     this.entries.clear();
   }
-}, _class4);
+}, _class6);
 
 // src/paint/exchange.ts
 var MIXING_MODELS = ["rgb", "pigment"];
@@ -1404,8 +1710,8 @@ 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 = (_class5 = class {
-  constructor(rates, load) {;_class5.prototype.__init23.call(this);
+var PaintExchange = (_class7 = class {
+  constructor(rates, load) {;_class7.prototype.__init25.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;
@@ -1417,7 +1723,7 @@ var PaintExchange = (_class5 = class {
   
   
   
-  __init23() {this.out = [0, 0, 0]}
+  __init25() {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 };
@@ -1428,7 +1734,7 @@ var PaintExchange = (_class5 = class {
   }
   /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
   get paintPigment() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _25 => _25.pig, 'optionalAccess', _26 => _26.paint]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _31 => _31.pig, 'optionalAccess', _32 => _32.paint]), () => ( null));
   }
   /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */
   setReservoirColor(r, g, b) {
@@ -1465,7 +1771,7 @@ var PaintExchange = (_class5 = class {
     if (!this.well) this.well = [sample.rgb[0], sample.rgb[1], sample.rgb[2]];
     else {
       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);
+      const o = this.mix(this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _33 => _33.well]), () => ( null)), sample.rgb, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _34 => _34.canvas]), () => ( null)), this.rates.pickup * sample.contact);
       this.well = [o[0], o[1], o[2]];
     }
     if (pig) _chunkO7LUD7MHcjs.setPigmentColor.call(void 0, pig.well, this.well[0], this.well[1], this.well[2]);
@@ -1483,7 +1789,7 @@ var PaintExchange = (_class5 = class {
     if (!(total > 1e-6)) return 0;
     const pig = this.pig;
     if (res && this.well) {
-      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);
+      const m = this.mix(res, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _35 => _35.res]), () => ( null)), this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _36 => _36.well]), () => ( null)), wp / total);
       out[0] = m[0];
       out[1] = m[1];
       out[2] = m[2];
@@ -1500,29 +1806,29 @@ var PaintExchange = (_class5 = class {
   drain() {
     this.amount *= 1 - this.rates.drain;
   }
-}, _class5);
+}, _class7);
 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 = (_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);
+var TileMedium = (_class8 = class {
+  constructor(target, options = {}) {;_class8.prototype.__init26.call(this);_class8.prototype.__init27.call(this);_class8.prototype.__init28.call(this);_class8.prototype.__init29.call(this);_class8.prototype.__init30.call(this);_class8.prototype.__init31.call(this);_class8.prototype.__init32.call(this);_class8.prototype.__init33.call(this);_class8.prototype.__init34.call(this);_class8.prototype.__init35.call(this);
     this.target = target;
     this.options = options;
   }
   
   
   // The tile last looked up by `locate` (and whether it came from `writeTile`).
-  __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]}
+  __init26() {this.tx = NaN}
+  __init27() {this.ty = NaN}
+  __init28() {this.tile = null}
+  __init29() {this.writable = false}
+  __init30() {this.canvasPig = _chunkO7LUD7MHcjs.createPigment.call(void 0, [0, 0, 0])}
+  __init31() {this.paintPig = _chunkO7LUD7MHcjs.createPigment.call(void 0, [0, 0, 0])}
+  __init32() {this.paintKey = -1}
+  __init33() {this.cb = [0, 0, 0, 0]}
+  __init34() {this.src = [0, 0, 0, 1]}
+  __init35() {this.o = [0, 0, 0]}
   /** Forgets the cached tile (call when another writer may have replaced tiles). */
   reset() {
     this.tx = NaN;
@@ -1667,7 +1973,7 @@ var TileMedium = (_class6 = class {
       }
     }
   }
-}, _class6);
+}, _class8);
 
 // src/paint/blending.ts
 var DEFAULT_BLENDER = { strength: 0.5, distance: 0.35, mixing: "pigment" };
@@ -1783,8 +2089,8 @@ function blenderDab(medium, rect, cov, opacity, radius, settings, scratch) {
     }
   }
 }
-var SmudgeTip = (_class7 = class {
-  constructor(settings, diameter) {;_class7.prototype.__init34.call(this);_class7.prototype.__init35.call(this);
+var SmudgeTip = (_class9 = class {
+  constructor(settings, diameter) {;_class9.prototype.__init36.call(this);_class9.prototype.__init37.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);
@@ -1792,8 +2098,8 @@ var SmudgeTip = (_class7 = class {
   
   
   
-  __init34() {this.loaded = false}
-  __init35() {this.out = [0, 0, 0]}
+  __init36() {this.loaded = false}
+  __init37() {this.out = [0, 0, 0]}
   cell(d, px, py) {
     const s = this.size;
     const r = Math.max(0.5, d.radius);
@@ -1904,7 +2210,7 @@ var SmudgeTip = (_class7 = class {
       }
     }
   }
-}, _class7);
+}, _class9);
 
 // src/paint/mixer.ts
 var DEFAULT_MIXER = {
@@ -1937,22 +2243,22 @@ function loadMixer(load, color) {
 function cleanMixer(load) {
   return { reservoir: load.reservoir, amount: load.amount, pickup: null };
 }
-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);
+var MixerStroke = (_class10 = class {
+  constructor(brush, settings, load, target) {;_class10.prototype.__init38.call(this);_class10.prototype.__init39.call(this);_class10.prototype.__init40.call(this);_class10.prototype.__init41.call(this);_class10.prototype.__init42.call(this);
     this.brush = brush;
     this.walker = new DabWalker(brush);
     this.exchange = new PaintExchange(mixerRates(normalizeMixer(settings)), load);
     this.medium = new TileMedium(target);
   }
   
-  __init36() {this.dabCount = 0}
-  __init37() {this.bounds = null}
+  __init38() {this.dabCount = 0}
+  __init39() {this.bounds = null}
   
-  __init38() {this.smoothPos = null}
-  __init39() {this.buf = new Float32Array(0)}
+  __init40() {this.smoothPos = null}
+  __init41() {this.buf = new Float32Array(0)}
   
   
-  __init40() {this.paintColor = [0, 0, 0]}
+  __init42() {this.paintColor = [0, 0, 0]}
   /** The brush load after the dabs so far. */
   get load() {
     return this.exchange.load;
@@ -2000,7 +2306,7 @@ var MixerStroke = (_class8 = class {
     }
     ex.drain();
   }
-}, _class8);
+}, _class10);
 function union(a, b) {
   if (!a) return { ...b };
   const x = Math.min(a.x, b.x);
@@ -2095,5 +2401,14 @@ 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.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
+
+
+
+
+
+
+
+
+
+exports.mix32 = mix32; exports.hash2 = hash2; exports.rand01 = rand01; exports.randSigned = randSigned; exports.seedFromString = seedFromString; exports.TileableNoise = TileableNoise; 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.GRAIN_PATTERNS = GRAIN_PATTERNS; exports.GRAIN_TILE = GRAIN_TILE; exports.grainHeights = grainHeights; exports.PaperGrain = PaperGrain; exports.grainCatch = grainCatch; exports.strokeGrainCatch = strokeGrainCatch; 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-3T5O225T.cjs.map