@pixerate/editor 0.155.0 → 0.157.0

package/dist/{chunk-LRRCMRSL.cjs → chunk-EBDCRTZI.cjs}

@@ -1281,6 +1281,8 @@ var PaperGrain = (_class5 = class {
   
   
   
+  
+  
   constructor(paper, media = "dry") {;_class5.prototype.__init22.call(this);
     const raw = grainHeights(paper.pattern, paper.seed);
     const t = paper[media];
@@ -1296,6 +1298,8 @@ var PaperGrain = (_class5 = class {
     }
     this.scale = paper.scale;
     this.mirror = paper.tiling === "mirror";
+    this.ox = _nullishCoalesce(_optionalChain([paper, 'access', _5 => _5.offset, 'optionalAccess', _6 => _6.x]), () => ( 0));
+    this.oy = _nullishCoalesce(_optionalChain([paper, 'access', _7 => _7.offset, 'optionalAccess', _8 => _8.y]), () => ( 0));
   }
   /** Tile cell index for a coordinate in grain pixels (mirrored on odd tiles when mirroring). */
   wrap(v) {
@@ -1306,8 +1310,8 @@ var PaperGrain = (_class5 = class {
   }
   /** 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 u = (x - this.ox) / this.scale - 0.5;
+    const v = (y - this.oy) / this.scale - 0.5;
     const x0 = Math.floor(u);
     const y0 = Math.floor(v);
     const fx = u - x0;
@@ -1363,10 +1367,10 @@ function pathStrokeDabs(samples, options) {
   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 t0 = _nullishCoalesce(_optionalChain([pts, 'access', _9 => _9.find, 'call', _10 => _10((s) => typeof s.t === "number" && Number.isFinite(s.t)), 'optionalAccess', _11 => _11.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 lean0 = _nullishCoalesce(_optionalChain([l, 'optionalAccess', _12 => _12.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;
@@ -1433,9 +1437,9 @@ 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 g = _optionalChain([options, 'access', _13 => _13.gradient, 'optionalAccess', _14 => _14.paint, 'access', _15 => _15.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 tipTable = _optionalChain([sampler, 'optionalAccess', _16 => _16.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;
@@ -1459,7 +1463,7 @@ function pathStrokeCoverage(samples, options) {
   }
   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;
+    const pressure = dabs.reduce((sum, d) => sum + (_nullishCoalesce(_optionalChain([d, 'access', _17 => _17.params, 'optionalAccess', _18 => _18.pressure]), () => ( 1))), 0) / dabs.length;
     for (const [key, t] of coverage.tiles) {
       const { tx, ty } = _chunkCWM3CUUXcjs.tileCoord.call(void 0, key);
       for (let y = 0, k = 0; y < _chunkCWM3CUUXcjs.TILE; y++) {
@@ -1475,11 +1479,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', _15 => _15.paint, 'optionalAccess', _16 => _16.paint, 'access', _17 => _17.type]) === "color") {
+  if (_optionalChain([options, 'access', _19 => _19.paint, 'optionalAccess', _20 => _20.paint, 'access', _21 => _21.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', _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 gradient = _optionalChain([options, 'access', _22 => _22.paint, 'optionalAccess', _23 => _23.paint, 'access', _24 => _24.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 }));
@@ -1496,7 +1500,7 @@ function paintPathStroke(surface, samples, options) {
   const tiles = new Map(surface.tiles);
   for (const { tx, ty } of _chunkCWM3CUUXcjs.tilesInRect.call(void 0, { x: bounds.x - offset.x, y: bounds.y - offset.y, width: bounds.width, height: bounds.height })) {
     const key = _chunkCWM3CUUXcjs.tileKey.call(void 0, tx, ty);
-    const src = _optionalChain([surface, 'access', _21 => _21.tiles, 'access', _22 => _22.get, 'call', _23 => _23(key), 'optionalAccess', _24 => _24.data]);
+    const src = _optionalChain([surface, 'access', _25 => _25.tiles, 'access', _26 => _26.get, 'call', _27 => _27(key), 'optionalAccess', _28 => _28.data]);
     const base = src && src.length === _chunkCWM3CUUXcjs.TILE * _chunkCWM3CUUXcjs.TILE * 4 ? src : new Uint8ClampedArray(_chunkCWM3CUUXcjs.TILE * _chunkCWM3CUUXcjs.TILE * 4);
     const t = _chunkCWM3CUUXcjs.finishTile.call(void 0, applyStrokeToTile(coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
     if (t) tiles.set(key, t);
@@ -1592,7 +1596,7 @@ function renderBrushstroke(input, brush, options = {}) {
   let scale = finite2(options.scale) && options.scale > 0 ? Math.min(_chunkYQGCPL5Xcjs.BRUSHSTROKE_MAX_SCALE, Math.max(_chunkYQGCPL5Xcjs.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', _25 => _25.tilt, 'optionalAccess', _26 => _26.size]), () => ( 0)))) + 4;
+  const reach = tip.size * (1 + 1.5 * (_nullishCoalesce(_optionalChain([strokeOptions, 'access', _29 => _29.tilt, 'optionalAccess', _30 => _30.size]), () => ( 0)))) + 4;
   let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
   for (const s of samples) {
     x0 = Math.min(x0, s.x);
@@ -1615,8 +1619,8 @@ function renderBrushstroke(input, brush, options = {}) {
     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 ox = _nullishCoalesce(_optionalChain([ch, 'access', _31 => _31.origin, 'optionalAccess', _32 => _32.x]), () => ( 0));
+      const oy = _nullishCoalesce(_optionalChain([ch, 'access', _33 => _33.origin, 'optionalAccess', _34 => _34.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) };
     }
@@ -1734,7 +1738,7 @@ var PaintExchange = (_class7 = class {
   }
   /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
   get paintPigment() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _31 => _31.pig, 'optionalAccess', _32 => _32.paint]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _35 => _35.pig, 'optionalAccess', _36 => _36.paint]), () => ( null));
   }
   /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */
   setReservoirColor(r, g, b) {
@@ -1771,7 +1775,7 @@ var PaintExchange = (_class7 = class {
     if (!this.well) this.well = [sample.rgb[0], sample.rgb[1], sample.rgb[2]];
     else {
       if (pig) _chunkCWM3CUUXcjs.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', _33 => _33.well]), () => ( null)), sample.rgb, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _34 => _34.canvas]), () => ( null)), this.rates.pickup * sample.contact);
+      const o = this.mix(this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _37 => _37.well]), () => ( null)), sample.rgb, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _38 => _38.canvas]), () => ( null)), this.rates.pickup * sample.contact);
       this.well = [o[0], o[1], o[2]];
     }
     if (pig) _chunkCWM3CUUXcjs.setPigmentColor.call(void 0, pig.well, this.well[0], this.well[1], this.well[2]);
@@ -1789,7 +1793,7 @@ var PaintExchange = (_class7 = class {
     if (!(total > 1e-6)) return 0;
     const pig = this.pig;
     if (res && this.well) {
-      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);
+      const m = this.mix(res, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _39 => _39.res]), () => ( null)), this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _40 => _40.well]), () => ( null)), wp / total);
       out[0] = m[0];
       out[1] = m[1];
       out[2] = m[2];

package/dist/{chunk-OLCYQLFE.js → chunk-EL5PAHNP.js}

@@ -5,7 +5,7 @@ import {
   dabRect,
   put255,
   rasterizeDab
-} from "./chunk-AGZ47XY2.js";
+} from "./chunk-2N2QPO3H.js";
 import {
   TILE,
   blendPixel,

package/dist/{chunk-PUC43JPT.cjs → chunk-EYVVIZJ3.cjs}

@@ -74,7 +74,7 @@ function profileAlongPolyline(points, values, count = 32) {
 var round3 = (v) => Math.round(v * 1e3) / 1e3;
 var loading = null;
 function loadCanvasBrushstrokeRenderer() {
-  loading ??= Promise.resolve().then(() => _interopRequireWildcard(require("./brushstrokeRender-YAZVQUXY.cjs"))).catch((error) => {
+  loading ??= Promise.resolve().then(() => _interopRequireWildcard(require("./brushstrokeRender-5WANQIG4.cjs"))).catch((error) => {
     loading = null;
     throw error;
   });

package/dist/{chunk-SUVZJ2CP.js → chunk-H5XX4KHB.js}

@@ -231,6 +231,7 @@ var CHART_AXIS_SCALES = ["linear", "log"];
 var CHART_SERIES_TYPES = ["bar", "line", "area", "scatter"];
 var CHART_STACKINGS = ["none", "stacked", "percent"];
 var CHART_CURVES = ["linear", "smooth", "step"];
+var CHART_RADAR_GRATICULES = ["polygon", "circle"];
 var CHART_ORIENTATIONS = ["vertical", "horizontal"];
 var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
 var CHART_NUMBER_STYLES = ["number", "percent", "currency", "compact"];
@@ -652,6 +653,12 @@ function normalizeChartSpec(input) {
     if (Number.isInteger(b) && b >= 1 && b <= 500) bins = b;
     else issues.push({ path: "bins", message: "bins must be a whole number from 1 to 500, or null for automatic." });
   }
+  let radarTicks = null;
+  if (value.radarTicks !== void 0 && value.radarTicks !== null) {
+    const t = Number(value.radarTicks);
+    if (Number.isInteger(t) && t >= 1 && t <= 50) radarTicks = t;
+    else issues.push({ path: "radarTicks", message: "radarTicks must be a whole number from 1 to 50, or null for round-number rings." });
+  }
   const spec = {
     version: 1,
     type,
@@ -674,7 +681,9 @@ function normalizeChartSpec(input) {
     gapWidth,
     overlap,
     bins,
-    showTotal: flag(value.showTotal, true, "showTotal", issues)
+    showTotal: flag(value.showTotal, true, "showTotal", issues),
+    radarTicks,
+    radarGraticule: pick(value.radarGraticule, CHART_RADAR_GRATICULES, "polygon", "radarGraticule", issues)
   };
   if (spec.stacking === "percent")
     for (const name of ["yAxis", "yAxis2"]) {
@@ -793,6 +802,7 @@ export {
   CHART_SERIES_TYPES,
   CHART_STACKINGS,
   CHART_CURVES,
+  CHART_RADAR_GRATICULES,
   CHART_ORIENTATIONS,
   CHART_LEGEND_POSITIONS,
   CHART_NUMBER_STYLES,

package/dist/{chunk-BXMIBMVG.cjs → chunk-JGKCC5OF.cjs}

@@ -20,7 +20,7 @@
 
 
 
-var _chunkLRRCMRSLcjs = require('./chunk-LRRCMRSL.cjs');
+var _chunkEBDCRTZIcjs = require('./chunk-EBDCRTZI.cjs');
 
 
 
@@ -73,7 +73,13 @@ function paperPreset(id) {
   return p ? clonePaper(p) : void 0;
 }
 function clonePaper(p) {
-  return { ...p, dry: { ...p.dry }, wet: { ...p.wet } };
+  return { ...p, dry: { ...p.dry }, wet: { ...p.wet }, ...p.offset ? { offset: { ...p.offset } } : {} };
+}
+function readOffset(raw, d) {
+  const o = raw && typeof raw === "object" ? raw : null;
+  const x = o && typeof o.x === "number" && Number.isFinite(o.x) ? Math.round(o.x) : _nullishCoalesce(_optionalChain([d, 'optionalAccess', _3 => _3.x]), () => ( 0));
+  const y = o && typeof o.y === "number" && Number.isFinite(o.y) ? Math.round(o.y) : _nullishCoalesce(_optionalChain([d, 'optionalAccess', _4 => _4.y]), () => ( 0));
+  return x || y ? { offset: { x, y } } : {};
 }
 function readTuning(raw, d) {
   const r = raw && typeof raw === "object" ? raw : {};
@@ -86,7 +92,7 @@ function normalizePaper(raw = {}, base) {
     preset: typeof r.preset === "string" && r.preset ? r.preset : b.preset,
     name: typeof r.name === "string" && r.name.trim() ? r.name.trim() : b.name,
     family: PAPER_FAMILIES.includes(r.family) ? r.family : b.family,
-    pattern: _chunkLRRCMRSLcjs.GRAIN_PATTERNS.includes(r.pattern) ? r.pattern : b.pattern,
+    pattern: _chunkEBDCRTZIcjs.GRAIN_PATTERNS.includes(r.pattern) ? r.pattern : b.pattern,
     seed: typeof r.seed === "number" && Number.isFinite(r.seed) ? Math.round(Math.abs(r.seed)) % 2147483647 : b.seed,
     color: typeof r.color === "string" && HEX.test(r.color) ? r.color.toLowerCase() : b.color,
     scale: clampNum(r.scale, 0.25, 8, b.scale),
@@ -98,14 +104,15 @@ function normalizePaper(raw = {}, base) {
     absorption: unit(r.absorption, b.absorption),
     permeability: unit(r.permeability, b.permeability),
     roughness: unit(r.roughness, b.roughness),
-    ...unit(r.metallic, _nullishCoalesce(b.metallic, () => ( 0))) > 0 ? { metallic: unit(r.metallic, _nullishCoalesce(b.metallic, () => ( 0))) } : {}
+    ...unit(r.metallic, _nullishCoalesce(b.metallic, () => ( 0))) > 0 ? { metallic: unit(r.metallic, _nullishCoalesce(b.metallic, () => ( 0))) } : {},
+    ...readOffset(r.offset, b.offset)
   };
 }
 function hexToRgb8(hex) {
   const n = parseInt(hex.slice(1, 7), 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
 }
-function renderPaper(paper, rect, grain = new (0, _chunkLRRCMRSLcjs.PaperGrain)(paper), light) {
+function renderPaper(paper, rect, grain = new (0, _chunkEBDCRTZIcjs.PaperGrain)(paper), light) {
   const [r, g, b] = hexToRgb8(paper.color);
   const out = new Uint8ClampedArray(rect.width * rect.height * 4);
   const shade = grain.flat ? 0 : paper.shading * 0.16;
@@ -267,22 +274,22 @@ var PenDabWalker = (_class2 = class {
     const i = this.index++;
     const seed = this.seed;
     let diameter = this.diameter(s);
-    if (dyn.sizeJitter) diameter *= Math.max(0.05, 1 + dyn.sizeJitter * _chunkLRRCMRSLcjs.randSigned.call(void 0, seed, i, 1 /* Size */));
+    if (dyn.sizeJitter) diameter *= Math.max(0.05, 1 + dyn.sizeJitter * _chunkEBDCRTZIcjs.randSigned.call(void 0, seed, i, 1 /* Size */));
     const base = tip.angle * Math.PI / 180;
     let angle;
     if (rotation === "stroke") angle = this.dir + base;
     else if (rotation === "barrel" && s.twist !== null) angle = this.mapAngle(base - s.twist * Math.PI / 180);
     else if (dyn.tiltRoundness > 0 && s.lean > 0.02) angle = this.mapAngle(base - s.azimuth);
     else angle = this.mapAngle(base);
-    if (dyn.angleJitter) angle += dyn.angleJitter * Math.PI * _chunkLRRCMRSLcjs.randSigned.call(void 0, seed, i, 2 /* Angle */);
+    if (dyn.angleJitter) angle += dyn.angleJitter * Math.PI * _chunkEBDCRTZIcjs.randSigned.call(void 0, seed, i, 2 /* Angle */);
     let opacity = tip.pressureOpacity ? s.pressure : 1;
     opacity *= 1 - dyn.tiltOpacity * s.lean * 0.8;
     if (s.speed !== null && dyn.velocityOpacity) opacity *= Math.max(0, 1 + dyn.velocityOpacity * (Math.min(1, s.speed / FULL_SPEED) - 0.5));
-    if (dyn.opacityJitter) opacity *= 1 - dyn.opacityJitter * (_chunkLRRCMRSLcjs.randSigned.call(void 0, seed, i, 3 /* Opacity */) * 0.5 + 0.5);
+    if (dyn.opacityJitter) opacity *= 1 - dyn.opacityJitter * (_chunkEBDCRTZIcjs.randSigned.call(void 0, seed, i, 3 /* Opacity */) * 0.5 + 0.5);
     const flow = tip.flow * (1 - dyn.pressureFlow + dyn.pressureFlow * s.pressure);
     let { x, y } = s;
     if (dyn.scatter) {
-      const off = dyn.scatter * diameter * _chunkLRRCMRSLcjs.randSigned.call(void 0, seed, i, 4 /* Scatter */);
+      const off = dyn.scatter * diameter * _chunkEBDCRTZIcjs.randSigned.call(void 0, seed, i, 4 /* Scatter */);
       x += Math.sin(this.dir) * off;
       y += Math.cos(this.dir) * off;
     }
@@ -366,13 +373,13 @@ var DryStroke = (_class3 = class {
     this.brush = brush;
     this.options = options;
     this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
-    this.copies = _optionalChain([options, 'access', _3 => _3.copies, 'optionalAccess', _4 => _4.length]) ? options.copies : [IDENTITY_COPY];
+    this.copies = _optionalChain([options, 'access', _5 => _5.copies, 'optionalAccess', _6 => _6.length]) ? options.copies : [IDENTITY_COPY];
     this.walkers = this.copies.map((c, i) => new PenDabWalker(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear));
     this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
   }
   
   
-  __init12() {this.coverage = new (0, _chunkLRRCMRSLcjs.CoverageMap)()}
+  __init12() {this.coverage = new (0, _chunkEBDCRTZIcjs.CoverageMap)()}
   __init13() {this.dabCount = 0}
   
   
@@ -406,16 +413,16 @@ var DryStroke = (_class3 = class {
     const hardness = this.brush.tip.hardness;
     const grain = this.options.grain;
     for (const d of dabs) {
-      const rect = _chunkLRRCMRSLcjs.dabRect.call(void 0, d, hardness);
+      const rect = _chunkEBDCRTZIcjs.dabRect.call(void 0, d, hardness);
       const n = rect.width * rect.height;
       if (this.buf.length < n) this.buf = new Float32Array(n);
       const vals = this.buf.subarray(0, n);
-      _chunkLRRCMRSLcjs.rasterizeDab.call(void 0, d, hardness, rect, vals);
+      _chunkEBDCRTZIcjs.rasterizeDab.call(void 0, d, hardness, rect, vals);
       if (this.depth > 0 && grain) {
         for (let yy = 0, k = 0; yy < rect.height; yy++) {
           const y = rect.y + yy + 0.5;
           for (let xx = 0; xx < rect.width; xx++, k++) {
-            if (vals[k] > 0) vals[k] *= _chunkLRRCMRSLcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure);
+            if (vals[k] > 0) vals[k] *= _chunkEBDCRTZIcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure);
           }
         }
       }
@@ -488,14 +495,14 @@ function stampCoverage(kind, u, v, t) {
     }
     case "splat": {
       let rr = 0.55;
-      for (let k = 1; k <= 3; k++) rr += 0.08 * Math.sin(a * (k + 2) + _chunkLRRCMRSLcjs.hash2.call(void 0, k, 1, t) * 6.28) / k;
+      for (let k = 1; k <= 3; k++) rr += 0.08 * Math.sin(a * (k + 2) + _chunkEBDCRTZIcjs.hash2.call(void 0, k, 1, t) * 6.28) / k;
       let c = edge(rr - r);
       for (let k = 0; k < 4; k++) {
-        const ang = _chunkLRRCMRSLcjs.hash2.call(void 0, k, 7, t) * Math.PI * 2;
-        const dist = 0.72 + 0.2 * _chunkLRRCMRSLcjs.hash2.call(void 0, k, 9, t);
+        const ang = _chunkEBDCRTZIcjs.hash2.call(void 0, k, 7, t) * Math.PI * 2;
+        const dist = 0.72 + 0.2 * _chunkEBDCRTZIcjs.hash2.call(void 0, k, 9, t);
         const dx = u - Math.cos(ang) * dist;
         const dy = v - Math.sin(ang) * dist;
-        c = Math.max(c, edge(0.08 + 0.06 * _chunkLRRCMRSLcjs.hash2.call(void 0, k, 11, t) - Math.hypot(dx, dy)));
+        c = Math.max(c, edge(0.08 + 0.06 * _chunkEBDCRTZIcjs.hash2.call(void 0, k, 11, t) - Math.hypot(dx, dy)));
       }
       return c;
     }
@@ -533,7 +540,7 @@ function drawSticker(medium, s) {
       c /= 4;
       if (c <= 0) continue;
       cov[p] = c;
-      const shade = 1 + 0.12 * (-(u + v) / 2) + 0.06 * (_chunkLRRCMRSLcjs.hash2.call(void 0, px, rect.y + yy, s.seed) - 0.5);
+      const shade = 1 + 0.12 * (-(u + v) / 2) + 0.06 * (_chunkEBDCRTZIcjs.hash2.call(void 0, px, rect.y + yy, s.seed) - 0.5);
       field[p * 3] = Math.min(1, Math.max(0, r * shade));
       field[p * 3 + 1] = Math.min(1, Math.max(0, g * shade));
       field[p * 3 + 2] = Math.min(1, Math.max(0, b * shade));
@@ -544,8 +551,8 @@ function drawSticker(medium, s) {
 }
 function jitterColor(hex, amount, seed, i) {
   const [r, g, b] = hexRgb(hex);
-  const l = (_chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 61) - 0.5) * amount * 0.6;
-  const h = (_chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 63) - 0.5) * amount;
+  const l = (_chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 61) - 0.5) * amount * 0.6;
+  const h = (_chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 63) - 0.5) * amount;
   const m = (r + g + b) / 3;
   const rot = (c0, c1) => c0 + (c1 - c0) * h;
   const out = [rot(r, g), rot(g, b), rot(b, r)].map((c) => Math.min(1, Math.max(0, c + l + (c - m) * 0)));
@@ -560,7 +567,7 @@ var StickerSpray = (_class4 = class {
     const spacing = Math.max(0.05, 1 / Math.max(0.05, b.sticker.density * 4));
     const walk = { ...b, tip: { ...b.tip, spacing }, dynamics: { ...b.dynamics, scatter: 0, sizeJitter: 0, angleJitter: 0 } };
     this.walkers = this.copies.map((c, i) => new PenDabWalker(walk, init.seed + i * 7919 | 0, c.linear));
-    this.medium = new (0, _chunkLRRCMRSLcjs.TileMedium)(init.target, {});
+    this.medium = new (0, _chunkEBDCRTZIcjs.TileMedium)(init.target, {});
     this.next = init.nextId;
   }
   
@@ -603,21 +610,21 @@ var StickerSpray = (_class4 = class {
     const st = this.init.brush.sticker;
     const i = this.next;
     const seed = this.init.seed;
-    const size = d.radius * 2 * (1 - st.sizeJitter * 0.7 * _chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 51));
+    const size = d.radius * 2 * (1 - st.sizeJitter * 0.7 * _chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 51));
     const off = st.scatter * d.radius * 2;
-    const a = _chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 53) * Math.PI * 2;
-    const dist = _chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 55) * off;
+    const a = _chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 53) * Math.PI * 2;
+    const dist = _chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 55) * off;
     const base = this.colorAt(d, Math.cos(a) * dist, Math.sin(a) * dist);
     const sticker = {
       id: `st${this.next++}`,
-      stamp: _nullishCoalesce(st.stamps[Math.floor(_chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 57) * st.stamps.length)], () => ( "dot")),
+      stamp: _nullishCoalesce(st.stamps[Math.floor(_chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 57) * st.stamps.length)], () => ( "dot")),
       x: Math.round((d.x + Math.cos(a) * dist) * 100) / 100,
       y: Math.round((d.y + Math.sin(a) * dist) * 100) / 100,
       size: Math.max(2, Math.round(size * 10) / 10),
-      rotation: Math.round((-d.angle * 180 / Math.PI + (_chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 59) * 2 - 1) * 180 * st.rotationJitter) * 10) / 10,
+      rotation: Math.round((-d.angle * 180 / Math.PI + (_chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 59) * 2 - 1) * 180 * st.rotationJitter) * 10) / 10,
       color: st.colorJitter > 0 ? jitterColor(base.color, st.colorJitter, seed, i) : base.color,
       opacity: Math.round(Math.min(1, d.opacity * this.init.brush.tip.opacity * base.alpha) * 1e3) / 1e3,
-      seed: Math.floor(_chunkLRRCMRSLcjs.rand01.call(void 0, seed, i, 65) * 1e9)
+      seed: Math.floor(_chunkEBDCRTZIcjs.rand01.call(void 0, seed, i, 65) * 1e9)
     };
     this.stickers.push(sticker);
     rects.push(drawSticker(this.medium, sticker));
@@ -628,13 +635,13 @@ var StickerSpray = (_class4 = class {
   colorAt(d, dx, dy) {
     const g = this.init.paint;
     if (!g) return { color: this.init.color, alpha: 1 };
-    this.sampler ??= new (0, _chunkLRRCMRSLcjs.PaintGradientSampler)(g, this.init.seed);
+    this.sampler ??= new (0, _chunkEBDCRTZIcjs.PaintGradientSampler)(g, this.init.seed);
     const s = g.map.by === "across-tip" ? this.sampler.sample(((dx * Math.sin(d.direction) + dy * Math.cos(d.direction)) / Math.max(0.5, d.radius) + 1) / 2) : this.sampler.dab(d);
     return { color: "#" + s.rgb.map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0")).join(""), alpha: s.alpha };
   }
 }, _class4);
 function renderStickers(stickers, target) {
-  const medium = new (0, _chunkLRRCMRSLcjs.TileMedium)(target, {});
+  const medium = new (0, _chunkEBDCRTZIcjs.TileMedium)(target, {});
   for (const s of stickers) drawSticker(medium, s);
 }
 function normalizeStickerUpdate(u) {
@@ -694,10 +701,10 @@ var MarkStroke = (_class5 = class {
   constructor(brush, options) {;_class5.prototype.__init21.call(this);_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);
     this.brush = brush;
     this.options = options;
-    this.sampler = options.paint ? new (0, _chunkLRRCMRSLcjs.PaintGradientSampler)(options.paint, _nullishCoalesce(options.seed, () => ( 0))) : null;
-    this.tipTable = _optionalChain([this, 'access', _5 => _5.sampler, 'optionalAccess', _6 => _6.acrossTip]) ? this.sampler.tipTable(_chunkLRRCMRSLcjs.TIP_GRADIENT_STEPS) : null;
+    this.sampler = options.paint ? new (0, _chunkEBDCRTZIcjs.PaintGradientSampler)(options.paint, _nullishCoalesce(options.seed, () => ( 0))) : null;
+    this.tipTable = _optionalChain([this, 'access', _7 => _7.sampler, 'optionalAccess', _8 => _8.acrossTip]) ? this.sampler.tipTable(_chunkEBDCRTZIcjs.TIP_GRADIENT_STEPS) : null;
     this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
-    this.copies = _optionalChain([options, 'access', _7 => _7.copies, 'optionalAccess', _8 => _8.length]) ? options.copies : [IDENTITY_COPY];
+    this.copies = _optionalChain([options, 'access', _9 => _9.copies, 'optionalAccess', _10 => _10.length]) ? options.copies : [IDENTITY_COPY];
     this.seed = _nullishCoalesce(options.seed, () => ( 0));
     const fine = { ...brush, tip: { ...brush.tip, spacing: Math.max(0.01, Math.min(0.25, STEP_PX / Math.max(1, brush.tip.size))) } };
     this.walkers = this.copies.map((c, i) => new PenDabWalker(fine, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear));
@@ -705,7 +712,7 @@ var MarkStroke = (_class5 = class {
   }
   
   
-  __init21() {this.coverage = new (0, _chunkLRRCMRSLcjs.CoverageMap)()}
+  __init21() {this.coverage = new (0, _chunkEBDCRTZIcjs.CoverageMap)()}
   __init22() {this.dabCount = 0}
   
   
@@ -767,16 +774,16 @@ var MarkStroke = (_class5 = class {
     if (!(r > 0.05) || !(alpha > 0)) return;
     const dab = { x, y, radius: Math.max(0.5, r), alpha: Math.min(1, alpha), opacity: Math.min(1, opacity), angle: 0, roundness: 1 };
     const hardness = this.brush.tip.hardness;
-    const rect = _chunkLRRCMRSLcjs.dabRect.call(void 0, dab, hardness);
+    const rect = _chunkEBDCRTZIcjs.dabRect.call(void 0, dab, hardness);
     const n = rect.width * rect.height;
     if (n <= 0) return;
     if (this.buf.length < n) this.buf = new Float32Array(n);
     const vals = this.buf.subarray(0, n);
-    _chunkLRRCMRSLcjs.rasterizeDab.call(void 0, dab, hardness, rect, vals);
+    _chunkEBDCRTZIcjs.rasterizeDab.call(void 0, dab, hardness, rect, vals);
     const grain = this.options.grain;
     if (this.depth > 0 && grain) {
       for (let yy = 0, k = 0; yy < rect.height; yy++)
-        for (let xx = 0; xx < rect.width; xx++, k++) if (vals[k] > 0) vals[k] *= _chunkLRRCMRSLcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, rect.y + yy + 0.5), this.depth, pressure);
+        for (let xx = 0; xx < rect.width; xx++, k++) if (vals[k] > 0) vals[k] *= _chunkEBDCRTZIcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, rect.y + yy + 0.5), this.depth, pressure);
     }
     const color = this.markColor(x, y);
     if (color && color.alpha < 1) for (let k = 0; k < n; k++) vals[k] *= color.alpha;
@@ -819,7 +826,7 @@ function curl(x, y, seed) {
     const fy = v - y0;
     const sx = fx * fx * (3 - 2 * fx);
     const sy = fy * fy * (3 - 2 * fy);
-    const h = (a2, b2) => _chunkLRRCMRSLcjs.rand01.call(void 0, seed, a2 * 73856093 + b2 * 19349663, 41);
+    const h = (a2, b2) => _chunkEBDCRTZIcjs.rand01.call(void 0, seed, a2 * 73856093 + b2 * 19349663, 41);
     const a = h(x0, y0);
     const b = h(x0 + 1, y0);
     const c = h(x0, y0 + 1);
@@ -843,11 +850,11 @@ var ParticleStroke = (_class6 = class extends MarkStroke {
     const list = this.sets[copy];
     const size = Math.max(1, d.radius * 2);
     for (let i = 0; i < (s.kind === "flow" ? 0 : s.count); i++) {
-      const r = _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 3 + copy) * s.spread * size * 0.5;
-      const a = _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 5 + copy) * Math.PI * 2;
+      const r = _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 3 + copy) * s.spread * size * 0.5;
+      const a = _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 5 + copy) * Math.PI * 2;
       const ox = Math.cos(a) * r;
       const oy = Math.sin(a) * r;
-      const p = { x: d.x + ox, y: d.y + oy, vx: 0, vy: 0, ox, oy, k: 0.6 + 0.8 * _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 7), phase: a, age: 0, run: 0, bead: 0, alive: true };
+      const p = { x: d.x + ox, y: d.y + oy, vx: 0, vy: 0, ox, oy, k: 0.6 + 0.8 * _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 7), phase: a, age: 0, run: 0, bead: 0, alive: true };
       if (s.kind === "string") p.strand = Array.from({ length: 6 }, () => ({ x: d.x + ox, y: d.y + oy, vx: 0, vy: 0 }));
       if (s.kind === "orbit") {
         p.ox = Math.max(1, r + size * 0.15);
@@ -872,8 +879,8 @@ var ParticleStroke = (_class6 = class extends MarkStroke {
       while (this.spawn >= 1) {
         this.spawn -= 1;
         const i = this.dabCount + list.length * 31 + Math.floor(d.index);
-        const a = _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 11 + copy) * Math.PI * 2;
-        const r = _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 13 + copy) * s.spread * size * 0.5;
+        const a = _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 11 + copy) * Math.PI * 2;
+        const r = _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 13 + copy) * s.spread * size * 0.5;
         list.push({ x: d.x + Math.cos(a) * r, y: d.y + Math.sin(a) * r, vx: 0, vy: 0, ox: 0, oy: 0, k: 1, phase: a, age: 0, run: 0, bead: 0, alive: true });
       }
     }
@@ -908,7 +915,7 @@ var ParticleStroke = (_class6 = class extends MarkStroke {
           break;
         }
         case "orbit": {
-          p.phase += (0.05 + 0.3 * s.speed) * (i % 2 ? -1 : 1) * (0.7 + 0.6 * _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 17));
+          p.phase += (0.05 + 0.3 * s.speed) * (i % 2 ? -1 : 1) * (0.7 + 0.6 * _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 17));
           p.x = d.x + Math.cos(p.phase) * p.ox;
           p.y = d.y + Math.sin(p.phase) * p.ox + g * p.ox;
           break;
@@ -967,16 +974,16 @@ var BristleStroke = class extends MarkStroke {
     const s = this.s;
     this.tufts = this.copies.map(
       (_, c) => Array.from({ length: s.count }, (_2, i) => {
-        const a = _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 21 + c) * Math.PI * 2;
-        const r = Math.sqrt(_chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 23 + c));
+        const a = _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 21 + c) * Math.PI * 2;
+        const r = Math.sqrt(_chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 23 + c));
         return {
           u: Math.cos(a) * r,
           v: Math.sin(a) * r,
           x: 0,
           y: 0,
-          paint: 1 - s.jitter * 0.4 * _chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 25 + c),
-          thirst: 1 + s.jitter * (_chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 27 + c) * 2 - 1),
-          w: 1 + s.jitter * 0.6 * (_chunkLRRCMRSLcjs.rand01.call(void 0, this.seed, i, 29 + c) - 0.5),
+          paint: 1 - s.jitter * 0.4 * _chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 25 + c),
+          thirst: 1 + s.jitter * (_chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 27 + c) * 2 - 1),
+          w: 1 + s.jitter * 0.6 * (_chunkEBDCRTZIcjs.rand01.call(void 0, this.seed, i, 29 + c) - 0.5),
           started: false
         };
       })
@@ -1175,12 +1182,12 @@ function normalizePaintBrush(raw = {}, base) {
     if (rb.dirty !== void 0) mixerIn.cleanEachStroke = !rb.dirty;
     if (rb.mixing !== void 0) mixerIn.mixing = rb.mixing;
   }
-  const mixer = _chunkLRRCMRSLcjs.normalizeMixer.call(void 0, mixerIn);
+  const mixer = _chunkEBDCRTZIcjs.normalizeMixer.call(void 0, mixerIn);
   let behavior = normalizeBehavior(rb, b.behavior);
   if (engine === "mixer") behavior = { ...behavior, pickup: mixer.wet, mix: mixer.mix, dirty: !mixer.cleanEachStroke, mixing: mixer.mixing };
   let paint = _nullishCoalesce(b.paint, () => ( null));
   if (raw.paint !== void 0) {
-    const p = _chunkLRRCMRSLcjs.readPaintSource.call(void 0, raw.paint);
+    const p = _chunkEBDCRTZIcjs.readPaintSource.call(void 0, raw.paint);
     paint = p && p.type === "gradient" ? p : null;
   } else if (rb.multicolor !== void 0) {
     const mc = normalizeMultiColor(rb.multicolor, _nullishCoalesce(paintToMultiColor(paint), () => ( DEFAULT_MULTI_COLOR)));
@@ -1192,7 +1199,7 @@ function normalizePaintBrush(raw = {}, base) {
     name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim().slice(0, 80) : b.name,
     category: PAINT_BRUSH_CATEGORIES.includes(raw.category) ? raw.category : b.category,
     engine,
-    tip: _chunkLRRCMRSLcjs.normalizeBrush.call(void 0, { ...b.tip, ..._nullishCoalesce(raw.tip, () => ( {})) }),
+    tip: _chunkEBDCRTZIcjs.normalizeBrush.call(void 0, { ...b.tip, ..._nullishCoalesce(raw.tip, () => ( {})) }),
     grain: unit4(raw.grain, b.grain),
     pressureSmoothing: range(raw.pressureSmoothing, 0, 0.95, b.pressureSmoothing),
     rotation: BRUSH_ROTATIONS.includes(raw.rotation) ? raw.rotation : b.rotation,
@@ -1200,8 +1207,8 @@ function normalizePaintBrush(raw = {}, base) {
     mixer,
     loadsColor: typeof raw.loadsColor === "boolean" ? raw.loadsColor : b.loadsColor,
     behavior,
-    blender: _chunkLRRCMRSLcjs.normalizeBlender.call(void 0, _nullishCoalesce(raw.blender, () => ( {})), b.blender),
-    smudge: _chunkLRRCMRSLcjs.normalizeSmudge.call(void 0, _nullishCoalesce(raw.smudge, () => ( {})), b.smudge),
+    blender: _chunkEBDCRTZIcjs.normalizeBlender.call(void 0, _nullishCoalesce(raw.blender, () => ( {})), b.blender),
+    smudge: _chunkEBDCRTZIcjs.normalizeSmudge.call(void 0, _nullishCoalesce(raw.smudge, () => ( {})), b.smudge),
     wet: normalizeWetBrush(_nullishCoalesce(raw.wet, () => ( {})), _nullishCoalesce(b.wet, () => ( DEFAULT_WET_BRUSH))),
     impasto: normalizeImpasto(_nullishCoalesce(raw.impasto, () => ( {})), _nullishCoalesce(b.impasto, () => ( DEFAULT_IMPASTO))),
     particle: normalizeParticle(_nullishCoalesce(raw.particle, () => ( {})), _nullishCoalesce(b.particle, () => ( DEFAULT_PARTICLE))),
@@ -1216,16 +1223,16 @@ var BASE_BRUSH = {
   name: "Round",
   category: "custom",
   engine: "dab",
-  tip: { ..._chunkLRRCMRSLcjs.DEFAULT_BRUSH },
+  tip: { ..._chunkEBDCRTZIcjs.DEFAULT_BRUSH },
   grain: 0,
   pressureSmoothing: 0,
   rotation: "fixed",
   dynamics: { ...DEFAULT_DYNAMICS },
-  mixer: { ..._chunkLRRCMRSLcjs.DEFAULT_MIXER },
+  mixer: { ..._chunkEBDCRTZIcjs.DEFAULT_MIXER },
   loadsColor: true,
   behavior: { ...DEFAULT_BEHAVIOR, multicolor: { ...DEFAULT_MULTI_COLOR, colors: [] } },
-  blender: { ..._chunkLRRCMRSLcjs.DEFAULT_BLENDER },
-  smudge: { ..._chunkLRRCMRSLcjs.DEFAULT_SMUDGE },
+  blender: { ..._chunkEBDCRTZIcjs.DEFAULT_BLENDER },
+  smudge: { ..._chunkEBDCRTZIcjs.DEFAULT_SMUDGE },
   wet: { ...DEFAULT_WET_BRUSH },
   impasto: { ...DEFAULT_IMPASTO },
   particle: { ...DEFAULT_PARTICLE },