@pixerate/editor 0.108.0 → 0.110.0

package/dist/chunk-HUFQD4CB.cjs

@@ -1,734 +0,0 @@
-"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 _chunkSZ6KMZNMcjs = require('./chunk-SZ6KMZNM.cjs');
-
-// src/paint/brush.ts
-var DEFAULT_BRUSH = {
-  size: 20,
-  hardness: 1,
-  spacing: 0.1,
-  angle: 0,
-  roundness: 1,
-  opacity: 1,
-  flow: 1,
-  smoothing: 0,
-  pressureSize: true,
-  pressureOpacity: false,
-  blend: "normal"
-};
-var MAX_BRUSH_SIZE = 2500;
-function normalizeBrush(raw = {}) {
-  const num = (v, lo, hi, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d;
-  return {
-    size: num(raw.size, 1, MAX_BRUSH_SIZE, DEFAULT_BRUSH.size),
-    hardness: num(raw.hardness, 0, 1, DEFAULT_BRUSH.hardness),
-    spacing: num(raw.spacing, 0.01, 10, DEFAULT_BRUSH.spacing),
-    angle: num(raw.angle, -360, 360, DEFAULT_BRUSH.angle),
-    roundness: num(raw.roundness, 0.01, 1, DEFAULT_BRUSH.roundness),
-    opacity: num(raw.opacity, 0, 1, DEFAULT_BRUSH.opacity),
-    flow: num(raw.flow, 0, 1, DEFAULT_BRUSH.flow),
-    smoothing: num(raw.smoothing, 0, 0.95, DEFAULT_BRUSH.smoothing),
-    pressureSize: typeof raw.pressureSize === "boolean" ? raw.pressureSize : DEFAULT_BRUSH.pressureSize,
-    pressureOpacity: typeof raw.pressureOpacity === "boolean" ? raw.pressureOpacity : DEFAULT_BRUSH.pressureOpacity,
-    blend: _nullishCoalesce(raw.blend, () => ( "normal"))
-  };
-}
-var TIP_SHAPE = [
-  [0, 0.664],
-  [0.14, 0.58],
-  [0.28, 0.5],
-  [0.4, 0.44],
-  [0.52, 0.36],
-  [0.63, 0.29],
-  [0.7, 0.24],
-  [0.78, 0.19],
-  [0.84, 0.15],
-  [0.89, 0.11],
-  [1, 0]
-];
-var TIP_EDGE_PX = 1.2;
-var SMALL_TIP_RADIUS = 3;
-var SUBPIXEL = [-0.375, -0.125, 0.125, 0.375];
-function tipShape(radius, hardness) {
-  const h = (Number.isNaN(hardness) ? 0 : Math.min(1, Math.max(0, hardness))) * 10;
-  const i = Math.min(9, Math.floor(h));
-  const t = h - i;
-  const a = TIP_SHAPE[i];
-  const b = TIP_SHAPE[i + 1];
-  const r0 = a[0] + (b[0] - a[0]) * t;
-  const s = a[1] + (b[1] - a[1]) * t;
-  const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
-  const edge = Math.max(0.25, Math.min(TIP_EDGE_PX, 0.3 * r));
-  return [Math.max(0, Math.min(r0 * r, r - edge)), Math.max(1e-3, s * r, edge)];
-}
-function softExp(u) {
-  let g = Math.min(1, Math.max(0, 1 - u / 64));
-  for (let k = 0; k < 6; k++) g *= g;
-  return g;
-}
-function tipFalloff(d, radius, hardness) {
-  const [r0, s] = tipShape(radius, hardness);
-  if (d <= r0) return 1;
-  const x = (d - r0) / s;
-  return softExp(x * x);
-}
-function tipReach(radius, hardness) {
-  const [r0, s] = tipShape(radius, hardness);
-  return r0 + 2.6 * s;
-}
-function dabCoverage(d, radius, hardness) {
-  if (Number.isNaN(d) || d >= tipReach(radius, hardness) + 0.5) return 0;
-  return tipFalloff(d, radius, hardness);
-}
-function smoothPoints(points, amount) {
-  const a = 1 - Math.min(0.95, Math.max(0, amount));
-  if (a >= 1 || points.length < 3) return points.slice();
-  const out = [];
-  let cur = null;
-  for (const p of points) {
-    const n = cur ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
-    out.push(n);
-    cur = n;
-  }
-  out[out.length - 1] = points[points.length - 1];
-  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);
-    this.brush = brush;
-  }
-  
-  __init() {this.last = null}
-  __init2() {this.nextAt = 0}
-  __init3() {this.pendingFirst = null}
-  diameter(p) {
-    return this.brush.pressureSize ? this.brush.size * pressureOf(p) : this.brush.size;
-  }
-  stepLen(p) {
-    return Math.max(0.5, Math.max(1, this.diameter(p)) * Math.max(0.01, this.brush.spacing));
-  }
-  dab(p) {
-    const b = this.brush;
-    return {
-      x: p.x,
-      y: p.y,
-      radius: Math.max(0.5, this.diameter(p) / 2),
-      alpha: Math.min(1, Math.max(0, b.flow)),
-      opacity: b.pressureOpacity ? pressureOf(p) : 1,
-      angle: b.angle * Math.PI / 180,
-      roundness: Math.min(1, Math.max(0.01, b.roundness))
-    };
-  }
-  push(p, out) {
-    const a = this.last;
-    if (!a) {
-      this.last = p;
-      this.pendingFirst = p;
-      this.nextAt = this.stepLen(p);
-      return;
-    }
-    if (this.pendingFirst) {
-      out.push(this.dab(this.pendingFirst));
-      this.pendingFirst = null;
-    }
-    const dx = p.x - a.x;
-    const dy = p.y - a.y;
-    const len = Math.hypot(dx, dy);
-    if (len > 1e-9) {
-      while (this.nextAt <= len + 1e-9) {
-        const f = Math.min(1, this.nextAt / len);
-        const q = {
-          x: a.x + dx * f,
-          y: a.y + dy * f,
-          pressure: pressureOf(a) + (pressureOf(p) - pressureOf(a)) * f
-        };
-        out.push(this.dab(q));
-        this.nextAt += this.stepLen(q);
-      }
-      this.nextAt -= len;
-    }
-    this.last = p;
-  }
-  finish(out) {
-    if (this.pendingFirst) {
-      out.push(this.dab(this.pendingFirst));
-      this.pendingFirst = null;
-    }
-  }
-}, _class);
-function walkDabs(points, brush) {
-  const w = new DabWalker(brush);
-  const out = [];
-  for (const p of smoothPoints(points, brush.smoothing)) w.push(p, out);
-  w.finish(out);
-  return out;
-}
-function dabRect(d, hardness) {
-  const ro = Math.min(1, Math.max(0.5 / d.radius, d.roundness));
-  const rm = Math.max(0.5, d.radius * ro);
-  const r = Math.max(rm, tipReach(rm, hardness)) / ro + 1.5;
-  const x0 = Math.floor(d.x - r);
-  const y0 = Math.floor(d.y - r);
-  return { x: x0, y: y0, width: Math.ceil(d.x + r) - x0, height: Math.ceil(d.y + r) - y0 };
-}
-function rasterizeDab(d, hardness, rect, out) {
-  const w = rect.width;
-  const h = rect.height;
-  out.fill(0, 0, w * h);
-  const r = d.radius;
-  const ro = Math.min(1, Math.max(0.5 / r, d.roundness));
-  const rm = Math.max(0.5, r * ro);
-  const reach = Math.max(rm, tipReach(rm, hardness));
-  const sn = Math.sin(d.angle);
-  const cs = Math.cos(d.angle);
-  const toTip = (dx, dy) => {
-    const ux = dx;
-    const uy = -dy;
-    return [ux * cs + uy * sn, -ux * sn + uy * cs];
-  };
-  const small = rm < SMALL_TIP_RADIUS;
-  const reach2 = (reach + (small ? 0.75 : 0.5)) ** 2;
-  for (let yy = 0; yy < h; yy++) {
-    const dy = rect.y + yy + 0.5 - d.y;
-    for (let xx = 0; xx < w; xx++) {
-      const dx = rect.x + xx + 0.5 - d.x;
-      const [u, v] = toTip(dx, dy);
-      const d2 = (u * ro) ** 2 + v * v;
-      if (d2 >= reach2) continue;
-      let val;
-      if (small) {
-        let sum = 0;
-        for (const sy of SUBPIXEL) {
-          for (const sx of SUBPIXEL) {
-            const [su, sv] = toTip(dx + sx, dy + sy);
-            sum += tipFalloff(Math.sqrt((su * ro) ** 2 + sv * sv), rm, hardness);
-          }
-        }
-        val = sum / 16;
-      } else {
-        val = dabCoverage(Math.sqrt(d2), rm, hardness);
-      }
-      if (val > 0) out[yy * w + xx] = val * d.alpha;
-    }
-  }
-}
-var TILE_PIXELS = _chunkSZ6KMZNMcjs.TILE * _chunkSZ6KMZNMcjs.TILE;
-var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this); }
-  __init4() {this.tiles = /* @__PURE__ */ new Map()}
-  __init5() {this.bounds = null}
-  __init6() {this.dirty = /* @__PURE__ */ new Set()}
-  get(x, y) {
-    const tx = Math.floor(x / _chunkSZ6KMZNMcjs.TILE);
-    const ty = Math.floor(y / _chunkSZ6KMZNMcjs.TILE);
-    const t = this.tiles.get(_chunkSZ6KMZNMcjs.tileKey.call(void 0, tx, ty));
-    return t ? t[(y - ty * _chunkSZ6KMZNMcjs.TILE) * _chunkSZ6KMZNMcjs.TILE + (x - tx * _chunkSZ6KMZNMcjs.TILE)] : 0;
-  }
-  /** Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. */
-  accumulate(rect, vals, ceil) {
-    if (rect.width <= 0 || rect.height <= 0) return;
-    const w = rect.width;
-    const tx0 = Math.floor(rect.x / _chunkSZ6KMZNMcjs.TILE);
-    const ty0 = Math.floor(rect.y / _chunkSZ6KMZNMcjs.TILE);
-    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunkSZ6KMZNMcjs.TILE);
-    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunkSZ6KMZNMcjs.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 * _chunkSZ6KMZNMcjs.TILE);
-        const y0 = Math.max(rect.y, ty * _chunkSZ6KMZNMcjs.TILE);
-        const x1 = Math.min(rect.x + rect.width, tx * _chunkSZ6KMZNMcjs.TILE + _chunkSZ6KMZNMcjs.TILE);
-        const y1 = Math.min(rect.y + rect.height, ty * _chunkSZ6KMZNMcjs.TILE + _chunkSZ6KMZNMcjs.TILE);
-        let tile;
-        for (let y = y0; y < y1; y++) {
-          const row = (y - rect.y) * w;
-          const trow = (y - ty * _chunkSZ6KMZNMcjs.TILE) * _chunkSZ6KMZNMcjs.TILE;
-          for (let x = x0; x < x1; x++) {
-            const v = vals[row + (x - rect.x)];
-            if (v <= 0) continue;
-            if (!tile) {
-              const key = _chunkSZ6KMZNMcjs.tileKey.call(void 0, tx, ty);
-              tile = this.tiles.get(key);
-              if (!tile) {
-                tile = new Float32Array(TILE_PIXELS);
-                this.tiles.set(key, tile);
-              }
-              this.dirty.add(key);
-              touched = true;
-            }
-            const ti = trow + (x - tx * _chunkSZ6KMZNMcjs.TILE);
-            const c = tile[ti];
-            if (ceil > c) tile[ti] = c + v * (ceil - c);
-          }
-        }
-      }
-    }
-    if (touched) this.bounds = unionRect(this.bounds, rect);
-  }
-  /** Tiles changed since the last call. */
-  takeDirty() {
-    const out = [...this.dirty];
-    this.dirty.clear();
-    return out;
-  }
-}, _class2);
-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 {
-  constructor(brush) {;_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
-    this.brush = brush;
-    this.walker = new DabWalker(brush);
-    this.smoothing = brush.smoothing;
-  }
-  
-  __init7() {this.coverage = new CoverageMap()}
-  
-  
-  __init8() {this.smoothPos = null}
-  __init9() {this.buf = new Float32Array(0)}
-  __init10() {this.dabCount = 0}
-  /** Feeds input points; returns the document rectangles the new dabs touched. */
-  push(points) {
-    const dabs = [];
-    for (const p of points) this.walker.push(this.smooth(p), dabs);
-    return this.paint(dabs);
-  }
-  /** Ends the stroke (a single click still paints one dab). */
-  finish(last) {
-    const dabs = [];
-    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);
-    this.walker.finish(dabs);
-    return this.paint(dabs);
-  }
-  smooth(p) {
-    const a = 1 - Math.min(0.95, Math.max(0, this.smoothing));
-    const cur = this.smoothPos;
-    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
-    this.smoothPos = n;
-    return n;
-  }
-  paint(dabs) {
-    const rects = [];
-    for (const d of dabs) {
-      const rect = dabRect(d, this.brush.hardness);
-      const n = rect.width * rect.height;
-      if (this.buf.length < n) this.buf = new Float32Array(n);
-      const vals = this.buf.subarray(0, n);
-      rasterizeDab(d, this.brush.hardness, rect, vals);
-      this.coverage.accumulate(rect, vals, d.opacity);
-      rects.push(rect);
-      this.dabCount++;
-    }
-    return rects;
-  }
-}, _class3);
-function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}) {
-  const out = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);
-  const ox = tx * _chunkSZ6KMZNMcjs.TILE + s.offset.x;
-  const oy = ty * _chunkSZ6KMZNMcjs.TILE + s.offset.y;
-  let x0 = 0;
-  let y0 = 0;
-  let x1 = _chunkSZ6KMZNMcjs.TILE;
-  let y1 = _chunkSZ6KMZNMcjs.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(_chunkSZ6KMZNMcjs.TILE, Math.ceil(r.x + r.width) - ox);
-    y1 = Math.min(_chunkSZ6KMZNMcjs.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 * _chunkSZ6KMZNMcjs.TILE + x0) * channels, (y * _chunkSZ6KMZNMcjs.TILE + x1) * channels), (y * _chunkSZ6KMZNMcjs.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 % _chunkSZ6KMZNMcjs.TILE === 0 && s.offset.y % _chunkSZ6KMZNMcjs.TILE === 0;
-  const covTile = aligned ? coverage.tiles.get(_chunkSZ6KMZNMcjs.tileKey.call(void 0, Math.floor(ox / _chunkSZ6KMZNMcjs.TILE), Math.floor(oy / _chunkSZ6KMZNMcjs.TILE))) : void 0;
-  if (aligned && !covTile) return out;
-  for (let y = y0; y < y1; y++) {
-    const dy = oy + y;
-    for (let x = x0; x < x1; x++) {
-      const dx = ox + x;
-      const c = covTile ? covTile[y * _chunkSZ6KMZNMcjs.TILE + x] : coverage.get(dx, dy);
-      if (c <= 0) continue;
-      let k = c * s.opacity;
-      if (sel) {
-        if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
-        k *= sel.data[dy * sel.width + dx] / 255;
-      }
-      if (k > 1) k = 1;
-      if (k <= 0) continue;
-      const p = y * _chunkSZ6KMZNMcjs.TILE + x;
-      if (channels === 1) {
-        const target = s.mode === "erase" ? s.background[0] : s.color[0];
-        out[p] = Math.round(out[p] + (target - out[p]) * k);
-        continue;
-      }
-      const i = p * 4;
-      if (s.mode === "erase" && !s.lockTransparency) {
-        out[i + 3] = Math.round(out[i + 3] * (1 - k));
-        continue;
-      }
-      if (s.lockTransparency && out[i + 3] === 0) continue;
-      const src = s.mode === "erase" ? bg : cs;
-      if (s.blend === "pigment") {
-        const bytes = s.mode === "erase" ? s.background : s.color;
-        const as = src[3] * k;
-        if (!(as > 0)) continue;
-        const ao = as + out[i + 3] / 255 * (1 - as);
-        _chunkSZ6KMZNMcjs.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);
-        if (!s.lockTransparency) out[i + 3] = Math.round(ao * 255);
-        continue;
-      }
-      for (let ch = 0; ch < 4; ch++) cb[ch] = out[i + ch] / 255;
-      const o = _chunkSZ6KMZNMcjs.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);
-      if (!s.lockTransparency) out[i + 3] = Math.round(o[3] * 255);
-    }
-  }
-  return out;
-}
-function coverageTileCoord(key) {
-  return _chunkSZ6KMZNMcjs.tileCoord.call(void 0, key);
-}
-
-// src/paint/mixer.ts
-var MIXING_MODELS = ["rgb", "pigment"];
-var DEFAULT_MIXER = {
-  wet: 0.5,
-  load: 0.5,
-  mix: 0.5,
-  loadEachStroke: true,
-  cleanEachStroke: true,
-  mixing: "rgb"
-};
-var MIXER_PICKUP_RATE = 0.25;
-var MIXER_DRAIN = 0.08;
-function normalizeMixer(raw = {}) {
-  const unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
-  const bool = (v, d) => typeof v === "boolean" ? v : d;
-  return {
-    wet: unit(raw.wet, DEFAULT_MIXER.wet),
-    load: unit(raw.load, DEFAULT_MIXER.load),
-    mix: unit(raw.mix, DEFAULT_MIXER.mix),
-    loadEachStroke: bool(raw.loadEachStroke, DEFAULT_MIXER.loadEachStroke),
-    cleanEachStroke: bool(raw.cleanEachStroke, DEFAULT_MIXER.cleanEachStroke),
-    mixing: raw.mixing === "pigment" ? "pigment" : "rgb"
-  };
-}
-var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
-function loadMixer(load, color) {
-  const c = (v) => Math.min(1, Math.max(0, Number.isFinite(v) ? v : 0));
-  return { reservoir: [c(color[0]), c(color[1]), c(color[2])], amount: 1, pickup: load.pickup };
-}
-function cleanMixer(load) {
-  return { reservoir: load.reservoir, amount: load.amount, pickup: null };
-}
-var MixerStroke = (_class4 = class {
-  constructor(brush, settings, load, target) {;_class4.prototype.__init11.call(this);_class4.prototype.__init12.call(this);_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);_class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);
-    this.brush = brush;
-    this.target = target;
-    this.settings = normalizeMixer(settings);
-    this.walker = new DabWalker(brush);
-    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.pickup = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;
-    this.pig = this.settings.mixing === "pigment" ? { res: _chunkSZ6KMZNMcjs.createPigment.call(void 0, _nullishCoalesce(this.reservoir, () => ( [0, 0, 0]))), pick: _chunkSZ6KMZNMcjs.createPigment.call(void 0, _nullishCoalesce(this.pickup, () => ( [0, 0, 0]))), paint: _chunkSZ6KMZNMcjs.createPigment.call(void 0, [0, 0, 0]), canvas: _chunkSZ6KMZNMcjs.createPigment.call(void 0, [0, 0, 0]) } : null;
-  }
-  
-  
-  __init11() {this.dabCount = 0}
-  __init12() {this.bounds = null}
-  
-  __init13() {this.smoothPos = null}
-  __init14() {this.buf = new Float32Array(0)}
-  
-  
-  
-  
-  
-  __init15() {this.out = [0, 0, 0]}
-  /** The brush load after the dabs so far. */
-  get load() {
-    return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.pickup ? [...this.pickup] : null };
-  }
-  push(points) {
-    const dabs = [];
-    for (const p of points) this.walker.push(this.smooth(p), dabs);
-    return this.paint(dabs);
-  }
-  finish(last) {
-    const dabs = [];
-    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);
-    this.walker.finish(dabs);
-    return this.paint(dabs);
-  }
-  smooth(p) {
-    const a = 1 - Math.min(0.95, Math.max(0, this.brush.smoothing));
-    const cur = this.smoothPos;
-    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
-    this.smoothPos = n;
-    return n;
-  }
-  /** `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) _chunkSZ6KMZNMcjs.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;
-  }
-  paint(dabs) {
-    const rects = [];
-    for (const d of dabs) {
-      const rect = dabRect(d, this.brush.hardness);
-      const n = rect.width * rect.height;
-      if (this.buf.length < n) this.buf = new Float32Array(n);
-      const cov = this.buf.subarray(0, n);
-      rasterizeDab({ ...d, alpha: 1 }, this.brush.hardness, rect, cov);
-      this.dab(d, rect, cov);
-      rects.push(rect);
-      this.bounds = union(this.bounds, rect);
-      this.dabCount++;
-    }
-    return rects;
-  }
-  // The tile last looked up by `locate` (and whether it came from `writeTile`).
-  __init16() {this.tx = NaN}
-  __init17() {this.ty = NaN}
-  __init18() {this.tile = null}
-  __init19() {this.writable = false}
-  /** Index of document pixel (dx, dy) in `this.tile`, or -1 when reading an empty tile. */
-  locate(dx, dy, write) {
-    const t = this.target;
-    const lx = dx - t.offset.x;
-    const ly = dy - t.offset.y;
-    const tx = Math.floor(lx / _chunkSZ6KMZNMcjs.TILE);
-    const ty = Math.floor(ly / _chunkSZ6KMZNMcjs.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 * _chunkSZ6KMZNMcjs.TILE) * _chunkSZ6KMZNMcjs.TILE + (lx - tx * _chunkSZ6KMZNMcjs.TILE)) * 4 : -1;
-  }
-  dab(d, rect, cov) {
-    const { wet, mix, load } = this.settings;
-    const pig = this.pig;
-    const w = rect.width;
-    this.tx = NaN;
-    let ar = 0;
-    let ag = 0;
-    let ab = 0;
-    let wsum = 0;
-    let asum = 0;
-    for (let yy = 0; yy < rect.height; yy++) {
-      for (let xx = 0; xx < w; xx++) {
-        const k = cov[yy * w + xx];
-        if (k <= 0) continue;
-        wsum += k;
-        const i = this.locate(rect.x + xx, rect.y + yy, false);
-        if (i < 0) continue;
-        const px = this.tile;
-        const al = px[i + 3] / 255;
-        if (al <= 0) continue;
-        const ka = k * al;
-        ar += px[i] / 255 * ka;
-        ag += px[i + 1] / 255 * ka;
-        ab += px[i + 2] / 255 * ka;
-        asum += ka;
-      }
-    }
-    if (asum > 1e-6 && wet > 0) {
-      const canvas = [ar / asum, ag / asum, ab / asum];
-      if (!this.pickup) this.pickup = canvas;
-      else {
-        if (pig) _chunkSZ6KMZNMcjs.setPigmentColor.call(void 0, pig.canvas, canvas[0], canvas[1], canvas[2]);
-        const o = this.mix(this.pickup, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _ => _.pick]), () => ( null)), canvas, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _2 => _2.canvas]), () => ( null)), MIXER_PICKUP_RATE * wet * (asum / Math.max(1e-6, wsum)));
-        this.pickup = [o[0], o[1], o[2]];
-      }
-      if (pig) _chunkSZ6KMZNMcjs.setPigmentColor.call(void 0, pig.pick, this.pickup[0], this.pickup[1], this.pickup[2]);
-    }
-    const res = this.reservoir;
-    const wr = res ? this.amount * (1 - mix * wet) : 0;
-    const wp = this.pickup ? mix * wet : 0;
-    const total = wr + wp;
-    if (total > 1e-6) {
-      const paint = res && this.pickup ? [...this.mix(res, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _3 => _3.res]), () => ( null)), this.pickup, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _4 => _4.pick]), () => ( null)), wp / total)] : [..._nullishCoalesce(res, () => ( this.pickup))];
-      if (pig) _chunkSZ6KMZNMcjs.setPigmentColor.call(void 0, pig.paint, paint[0], paint[1], paint[2]);
-      const dep = Math.min(1, total) * this.brush.flow * this.brush.opacity * d.opacity;
-      if (dep > 0) this.deposit(rect, cov, paint, dep);
-    }
-    this.amount *= 1 - MIXER_DRAIN * (1 - load);
-  }
-  /** Lays `paint` over the pixels under the dab at `dep` × coverage (× selection). */
-  deposit(rect, cov, paint, dep) {
-    const t = this.target;
-    const sel = t.selection;
-    const pig = this.pig;
-    const w = rect.width;
-    const o = this.out;
-    let lastKey = -1;
-    for (let yy = 0; yy < rect.height; yy++) {
-      const dy = rect.y + yy;
-      for (let xx = 0; xx < w; xx++) {
-        let k = cov[yy * w + xx] * dep;
-        if (k <= 0) continue;
-        const dx = rect.x + xx;
-        if (sel) {
-          if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
-          k *= sel.data[dy * sel.width + dx] / 255;
-          if (k <= 0) continue;
-        }
-        if (k > 1) k = 1;
-        if (t.lockTransparency) {
-          const ri = this.locate(dx, dy, false);
-          if (ri < 0 || this.tile[ri + 3] === 0) continue;
-        }
-        const i = this.locate(dx, dy, true);
-        const px = this.tile;
-        const a = px[i + 3] / 255;
-        const na = t.lockTransparency ? a : a + (1 - a) * k;
-        const share = t.lockTransparency ? k : na > 0 ? k / na : 1;
-        if (a <= 0 || share >= 1) {
-          o[0] = paint[0];
-          o[1] = paint[1];
-          o[2] = paint[2];
-        } else if (pig) {
-          const key = px[i] << 16 | px[i + 1] << 8 | px[i + 2];
-          if (key !== lastKey) {
-            _chunkSZ6KMZNMcjs.setPigmentColor.call(void 0, pig.canvas, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
-            lastKey = key;
-          }
-          _chunkSZ6KMZNMcjs.lerpPigmentInto.call(void 0, pig.canvas, pig.paint, share, o, 0);
-        } else {
-          for (let c = 0; c < 3; c++) o[c] = px[i + c] / 255 + (paint[c] - px[i + c] / 255) * share;
-        }
-        px[i] = Math.round(o[0] * 255);
-        px[i + 1] = Math.round(o[1] * 255);
-        px[i + 2] = Math.round(o[2] * 255);
-        px[i + 3] = Math.round(na * 255);
-      }
-    }
-  }
-}, _class4);
-function union(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 };
-}
-
-// src/paint/pigment-tools.ts
-var HEX = /^#?([0-9a-f]{6})$/i;
-function parseHex(value, index) {
-  const m = typeof value === "string" ? HEX.exec(value.trim()) : null;
-  if (!m) throw new Error(`colors[${index}].color is ${JSON.stringify(value)}; use #rrggbb, e.g. "#1e40af".`);
-  const n = parseInt(m[1], 16);
-  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
-}
-function toHex(rgb) {
-  return "#" + rgb.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("");
-}
-function createPigmentTools() {
-  const mixColors = {
-    name: "mix_colors",
-    title: "Mix colours like paint",
-    description: "Mixes colours as paint would (Kubelka-Munk pigment mixing over reflectance spectra), so blue and yellow make green and white lightens a colour into a tint instead of greying it. Changes nothing. Returns the mixed colour as #rrggbb, the plain RGB average (rgbLerp) for comparison, and the normalised weights.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        colors: {
-          type: "array",
-          minItems: 1,
-          maxItems: 16,
-          description: "The paints to mix (1 to 16).",
-          items: {
-            type: "object",
-            properties: {
-              color: { type: "string", description: "Paint colour #rrggbb." },
-              weight: { type: "number", minimum: 0, description: "Parts of this paint, any scale (e.g. 1 and 3 for a 1:3 mix). At least one weight must be above 0." },
-              strength: {
-                type: "number",
-                exclusiveMinimum: 0,
-                maximum: 100,
-                description: "Tinting strength (default 1): each part counts as this many, so a strong dark paint (e.g. 4) tints a lot of white."
-              }
-            },
-            required: ["color", "weight"],
-            additionalProperties: false
-          }
-        }
-      },
-      required: ["colors"],
-      additionalProperties: false
-    },
-    annotations: { title: "Mix colours like paint", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    handler: (args) => {
-      const items = args.colors;
-      const rgbs = items.map((item, i) => parseHex(item.color, i));
-      const total = items.reduce((sum, item) => sum + item.weight, 0);
-      if (!(total > 0)) throw new Error("Every weight is 0; give at least one colour a weight above 0.");
-      const pigments = rgbs.map((rgb, i) => _chunkSZ6KMZNMcjs.createPigment.call(void 0, rgb, { strength: items[i].strength }));
-      const mixed = _chunkSZ6KMZNMcjs.mixPigments.call(void 0, pigments, items.map((item) => item.weight));
-      const lerp = [0, 1, 2].map((c) => rgbs.reduce((sum, rgb, i) => sum + rgb[c] * items[i].weight, 0) / total);
-      return {
-        mixed: toHex(mixed),
-        rgbLerp: toHex(lerp),
-        weights: items.map((item) => item.weight / total),
-        model: "kubelka-munk"
-      };
-    }
-  };
-  return [mixColors];
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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.applyStrokeToTile = applyStrokeToTile; exports.coverageTileCoord = coverageTileCoord; exports.MIXING_MODELS = MIXING_MODELS; exports.DEFAULT_MIXER = DEFAULT_MIXER; exports.MIXER_PICKUP_RATE = MIXER_PICKUP_RATE; exports.MIXER_DRAIN = MIXER_DRAIN; exports.normalizeMixer = normalizeMixer; exports.EMPTY_MIXER_LOAD = EMPTY_MIXER_LOAD; exports.loadMixer = loadMixer; exports.cleanMixer = cleanMixer; exports.MixerStroke = MixerStroke; exports.createPigmentTools = createPigmentTools;
-//# sourceMappingURL=chunk-HUFQD4CB.cjs.map