@pixerate/editor 0.267.0 → 0.268.1

package/dist/{chunk-G7NHE2VD.cjs → chunk-NPWWSCWT.cjs}

@@ -18,7 +18,7 @@
 
 
 
-var _chunkOKHKA43Lcjs = require('./chunk-OKHKA43L.cjs');
+var _chunkJBB3GDBBcjs = require('./chunk-JBB3GDBB.cjs');
 
 
 
@@ -37,7 +37,7 @@ var lerpP = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 var toP = (v) => [v.x, v.y];
 var mapP = (m, p) => [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
 var curvesOf = (c) => Math.max(0, (c.pts.length - 1) / 3) | 0;
-function subpathToMorphContour(sp, m = _chunkOKHKA43Lcjs.IDENTITY_MATRIX) {
+function subpathToMorphContour(sp, m = _chunkJBB3GDBBcjs.IDENTITY_MATRIX) {
   const n = sp.anchors.length;
   if (!n) return null;
   const first = mapP(m, toP(sp.anchors[0]));
@@ -67,8 +67,8 @@ function isStraight(p0, p1, p2, p3) {
   const u2 = along(p2);
   return off(p1) < tol && off(p2) < tol && u1 >= -1e-9 && u1 <= 1 + 1e-9 && u2 >= -1e-9 && u2 <= 1 + 1e-9;
 }
-function morphContourToSubpath(c, m = _chunkOKHKA43Lcjs.IDENTITY_MATRIX, closed = c.closed) {
-  const pts = _chunkOKHKA43Lcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
+function morphContourToSubpath(c, m = _chunkJBB3GDBBcjs.IDENTITY_MATRIX, closed = c.closed) {
+  const pts = _chunkJBB3GDBBcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
   const curves = curvesOf(c);
   const dropLast = closed && c.closed && curves > 0;
   const count = dropLast ? curves : curves + 1;
@@ -84,7 +84,7 @@ function morphContourToSubpath(c, m = _chunkOKHKA43Lcjs.IDENTITY_MATRIX, closed
     anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
   }
   for (const a of anchors) {
-    const type = _chunkOKHKA43Lcjs.inferAnchorType.call(void 0, a);
+    const type = _chunkJBB3GDBBcjs.inferAnchorType.call(void 0, a);
     if (type !== "corner") a.type = type;
   }
   const isClosed = closed && curves > 0;
@@ -267,7 +267,7 @@ function bestStart(fixed, free, useShapeContext) {
   return best;
 }
 function placeIn(c, from, to) {
-  const b = _chunkOKHKA43Lcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
+  const b = _chunkJBB3GDBBcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
   const p = b ? [b.x + b.width / 2, b.y + b.height / 2] : c.pts[0];
   if (!from || !to) return p;
   const fx = from.width > 0 ? (p[0] - from.x) / from.width : 0.5;
@@ -456,7 +456,7 @@ function interpolateVectorColor(a, b, t) {
 }
 function resampleGradientStops(g, offsets) {
   return offsets.map((offset) => {
-    const s = _chunkOKHKA43Lcjs.sampleVectorGradient.call(void 0, g, offset);
+    const s = _chunkJBB3GDBBcjs.sampleVectorGradient.call(void 0, g, offset);
     return s.opacity < 1 ? { offset, color: s.color, opacity: Math.round(s.opacity * 1e4) / 1e4 } : { offset, color: s.color };
   });
 }
@@ -467,11 +467,11 @@ function lerpAngle(a, b, t) {
 var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
 var sameColourModel = (a, b) => (_nullishCoalesce(a.interpolation, () => ( "srgb"))) === (_nullishCoalesce(b.interpolation, () => ( "srgb"))) && (_nullishCoalesce(a.smoothness, () => ( 0))) === (_nullishCoalesce(b.smoothness, () => ( 0)));
 function lerpStops(a, b, t) {
-  let stopsA = _chunkOKHKA43Lcjs.sortedVectorGradientStops.call(void 0, a);
-  let stopsB = _chunkOKHKA43Lcjs.sortedVectorGradientStops.call(void 0, b);
+  let stopsA = _chunkJBB3GDBBcjs.sortedVectorGradientStops.call(void 0, a);
+  let stopsB = _chunkJBB3GDBBcjs.sortedVectorGradientStops.call(void 0, b);
   const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
   if (resampled) {
-    const offs = [..._chunkOKHKA43Lcjs.expandVectorGradientStops.call(void 0, a), ..._chunkOKHKA43Lcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const offs = [..._chunkJBB3GDBBcjs.expandVectorGradientStops.call(void 0, a), ..._chunkJBB3GDBBcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
     const common = offs.filter((o, i) => i === 0 || o - offs[i - 1] > 1e-4);
     stopsA = resampleGradientStops(a, common);
     stopsB = resampleGradientStops(b, common);
@@ -498,8 +498,8 @@ function lerpGradient(a, b, t) {
   }
   if (near.spread && near.spread !== "pad") out.spread = near.spread;
   if (near.strokeMode && near.strokeMode !== "within") out.strokeMode = near.strokeMode;
-  const ea = _chunkOKHKA43Lcjs.hasExplicitGradientGeometry.call(void 0, a);
-  const eb = _chunkOKHKA43Lcjs.hasExplicitGradientGeometry.call(void 0, b);
+  const ea = _chunkJBB3GDBBcjs.hasExplicitGradientGeometry.call(void 0, a);
+  const eb = _chunkJBB3GDBBcjs.hasExplicitGradientGeometry.call(void 0, b);
   if (!ea && !eb) {
     if (a.angle !== void 0 || b.angle !== void 0 || a.type === "linear" || a.type === "reflected") {
       const fallback = a.type === "linear" || a.type === "reflected" ? 180 : 90;
@@ -512,10 +512,10 @@ function lerpGradient(a, b, t) {
     }
     return out;
   }
-  const pa = _chunkOKHKA43Lcjs.vectorGradientPoints.call(void 0, a);
-  const pb = _chunkOKHKA43Lcjs.vectorGradientPoints.call(void 0, b);
+  const pa = _chunkJBB3GDBBcjs.vectorGradientPoints.call(void 0, a);
+  const pb = _chunkJBB3GDBBcjs.vectorGradientPoints.call(void 0, b);
   if (pa.units !== pb.units) {
-    const src = _chunkOKHKA43Lcjs.explicitVectorGradient.call(void 0, near);
+    const src = _chunkJBB3GDBBcjs.explicitVectorGradient.call(void 0, near);
     return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
   }
   out.start = lerpPoint(pa.start, pb.start, t);
@@ -535,14 +535,14 @@ function solidLike(color, like) {
 function interpolateVectorPaint(a, b, t) {
   if (t <= 0) return a;
   if (t >= 1) return b;
-  const pa = _chunkOKHKA43Lcjs.hasPaint.call(void 0, a);
-  const pb = _chunkOKHKA43Lcjs.hasPaint.call(void 0, b);
+  const pa = _chunkJBB3GDBBcjs.hasPaint.call(void 0, a);
+  const pb = _chunkJBB3GDBBcjs.hasPaint.call(void 0, b);
   if (!pa && !pb) return t < 0.5 ? a : b;
   if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
   if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
   if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
-  const ga = pa && _chunkOKHKA43Lcjs.isVectorGradient.call(void 0, a) ? a : null;
-  const gb = pb && _chunkOKHKA43Lcjs.isVectorGradient.call(void 0, b) ? b : null;
+  const ga = pa && _chunkJBB3GDBBcjs.isVectorGradient.call(void 0, a) ? a : null;
+  const gb = pb && _chunkJBB3GDBBcjs.isVectorGradient.call(void 0, b) ? b : null;
   if (ga && gb) return _nullishCoalesce(lerpGradient(ga, gb, t), () => ( (t < 0.5 ? a : b)));
   if (gb) return _nullishCoalesce(lerpGradient(solidLike(pa ? a : null, gb), gb, t), () => ( b));
   if (ga) return _nullishCoalesce(lerpGradient(ga, solidLike(pb ? b : null, ga), t), () => ( a));
@@ -553,8 +553,8 @@ function interpolateWidthProfiles(a, b, t) {
   const at = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at.filter((v, i) => i === 0 || v - at[i - 1] > 1e-6);
   return ts.map((pos) => {
-    const x = _chunkOKHKA43Lcjs.widthProfileAt.call(void 0, a, pos);
-    const y = _chunkOKHKA43Lcjs.widthProfileAt.call(void 0, b, pos);
+    const x = _chunkJBB3GDBBcjs.widthProfileAt.call(void 0, a, pos);
+    const y = _chunkJBB3GDBBcjs.widthProfileAt.call(void 0, b, pos);
     return { t: pos, left: lerpN(x.left, y.left, t), right: lerpN(x.right, y.right, t) };
   });
 }
@@ -597,7 +597,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkOKHKA43Lcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkJBB3GDBBcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -623,19 +623,19 @@ function styleOf(n) {
   return out;
 }
 function contoursOf(node, m) {
-  return _chunkOKHKA43Lcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+  return _chunkJBB3GDBBcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
 }
-function preparePathMorph(a, b, options, ma = _chunkOKHKA43Lcjs.nodeMatrix.call(void 0, a), mb = _chunkOKHKA43Lcjs.nodeMatrix.call(void 0, b)) {
+function preparePathMorph(a, b, options, ma = _chunkJBB3GDBBcjs.nodeMatrix.call(void 0, a), mb = _chunkJBB3GDBBcjs.nodeMatrix.call(void 0, b)) {
   const corr = correspondMorphContours(contoursOf(a, ma), contoursOf(b, mb), options);
   const sim = procrustes(corr.a, corr.b);
   const styleA = styleOf(a);
   const styleB = corr.reversed ? reversedStyle(styleOf(b)) : styleOf(b);
-  const rigid = !_chunkOKHKA43Lcjs.isIdentityMatrix.call(void 0, ma) || !_chunkOKHKA43Lcjs.isIdentityMatrix.call(void 0, mb);
+  const rigid = !_chunkJBB3GDBBcjs.isIdentityMatrix.call(void 0, ma) || !_chunkJBB3GDBBcjs.isIdentityMatrix.call(void 0, mb);
   const id = _nullishCoalesce(options.id, () => ( a.id));
   return (t) => {
     const contours = interpolateMorphContours(corr.a, corr.b, t, { linear: options.linear, rigidity: options.rigidity, similarity: sim });
-    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkOKHKA43Lcjs.IDENTITY_MATRIX;
-    const back = rigid ? _chunkOKHKA43Lcjs.invertMatrix.call(void 0, m) : _chunkOKHKA43Lcjs.IDENTITY_MATRIX;
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkJBB3GDBBcjs.IDENTITY_MATRIX;
+    const back = rigid ? _chunkJBB3GDBBcjs.invertMatrix.call(void 0, m) : _chunkJBB3GDBBcjs.IDENTITY_MATRIX;
     const subpaths = contours.map((c, k) => {
       const closed = t <= 0 ? corr.a[k].closed : t >= 1 ? corr.b[k].closed : corr.a[k].closed && corr.b[k].closed;
       return morphContourToSubpath({ closed: corr.a[k].closed && corr.b[k].closed, pts: c.pts }, back, closed);
@@ -643,14 +643,14 @@ function preparePathMorph(a, b, options, ma = _chunkOKHKA43Lcjs.nodeMatrix.call(
     const node = { id, type: "path", subpaths, ...interpolateVectorStyle(styleA, styleB, t) };
     const opacity = lerpN(_nullishCoalesce(a.opacity, () => ( 1)), _nullishCoalesce(b.opacity, () => ( 1)), t);
     if (opacity < 1) node.opacity = opacity;
-    if (rigid && !_chunkOKHKA43Lcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
+    if (rigid && !_chunkJBB3GDBBcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
     return node;
   };
 }
-function flattenPaths(node, parent = _chunkOKHKA43Lcjs.IDENTITY_MATRIX) {
-  const m = _chunkOKHKA43Lcjs.multiplyMatrices.call(void 0, _chunkOKHKA43Lcjs.nodeMatrix.call(void 0, node), parent);
+function flattenPaths(node, parent = _chunkJBB3GDBBcjs.IDENTITY_MATRIX) {
+  const m = _chunkJBB3GDBBcjs.multiplyMatrices.call(void 0, _chunkJBB3GDBBcjs.nodeMatrix.call(void 0, node), parent);
   if (node.type === "path") return [{ path: node, m, opacity: 1 }];
-  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkOKHKA43Lcjs.expandVectorAppearance.call(void 0, node), parent);
+  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkJBB3GDBBcjs.expandVectorAppearance.call(void 0, node), parent);
   const o = _nullishCoalesce(node.opacity, () => ( 1));
   return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
 }
@@ -672,8 +672,8 @@ function createVectorMorph(a, b, options = {}) {
   }
   const pa = flattenPaths(a);
   const pb = flattenPaths(b);
-  const ba = _chunkOKHKA43Lcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = _chunkOKHKA43Lcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
+  const ba = _chunkJBB3GDBBcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = _chunkJBB3GDBBcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
   const id = _nullishCoalesce(options.id, () => ( a.id));
   const parts = [];
   const opacities = [];
@@ -685,10 +685,10 @@ function createVectorMorph(a, b, options = {}) {
       parts.push(preparePathMorph(x.path, y.path, sub, x.m, y.m));
       opacities.push([x.opacity, y.opacity]);
     } else if (x) {
-      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkOKHKA43Lcjs.IDENTITY_MATRIX));
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkJBB3GDBBcjs.IDENTITY_MATRIX));
       opacities.push([x.opacity, x.opacity]);
     } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkOKHKA43Lcjs.IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkJBB3GDBBcjs.IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }

package/dist/{chunk-OSEXT7JL.js → chunk-QNY7BDFP.js}

@@ -18,7 +18,7 @@ import {
   unionBounds,
   vectorGradientPoints,
   widthProfileAt
-} from "./chunk-4IDUYB45.js";
+} from "./chunk-UVTO3D4E.js";
 import {
   segmentLength,
   segmentParamAtLength,

package/dist/{chunk-PXDIAYB6.cjs → chunk-STLTOISW.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;
+"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;
 
 
 
@@ -10,9 +10,9 @@
 
 
 
-var _chunkFQPUF2W2cjs = require('./chunk-FQPUF2W2.cjs');
 
 
+var _chunkNIBFKXMDcjs = require('./chunk-NIBFKXMD.cjs');
 
 
 var _chunk3K6HWEXZcjs = require('./chunk-3K6HWEXZ.cjs');
@@ -34,180 +34,6 @@ var _chunkW5M3J7PVcjs = require('./chunk-W5M3J7PV.cjs');
 
 var _chunk474IQG74cjs = require('./chunk-474IQG74.cjs');
 
-// 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 (0, _chunk3K6HWEXZcjs.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 + (_chunk3K6HWEXZcjs.hash2.call(void 0, 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 + (_chunk3K6HWEXZcjs.hash2.call(void 0, 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 + (_chunk3K6HWEXZcjs.hash2.call(void 0, 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 + (_chunk3K6HWEXZcjs.hash2.call(void 0, 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 = _chunk3K6HWEXZcjs.hash2.call(void 0, 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 = _chunk3K6HWEXZcjs.hash2.call(void 0, 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 + (_chunk3K6HWEXZcjs.hash2.call(void 0, x, y, salt) - 0.5) * 0.15);
-        }
-      break;
-    }
-    case "gesso": {
-      const streaks = noise(2 * k, 28 * k, 3);
-      const tooth = noise(64 * k, 64 * k, 2, 13);
-      for (let y = 0; y < n; y++)
-        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((streaks.at(x, y) - 0.5) * 1.8 + (tooth.at(x, y) - 0.5) * 0.9 + 0.55);
-      break;
-    }
-  }
-  return out;
-}
-var rawCache = /* @__PURE__ */ new Map();
-function grainHeights(pattern, seed, size = GRAIN_TILE) {
-  const key = `${pattern}:${seed}:${size}`;
-  let h = rawCache.get(key);
-  if (!h) {
-    h = patternHeights(pattern, size, seed);
-    if (rawCache.size > 32) rawCache.delete(rawCache.keys().next().value);
-    rawCache.set(key, h);
-  }
-  return h;
-}
-var PaperGrain = (_class = class {
-  __init() {this.size = GRAIN_TILE}
-  
-  
-  
-  
-  
-  
-  constructor(paper, media = "dry") {;_class.prototype.__init.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";
-    this.ox = _nullishCoalesce(_optionalChain([paper, 'access', _ => _.offset, 'optionalAccess', _2 => _2.x]), () => ( 0));
-    this.oy = _nullishCoalesce(_optionalChain([paper, 'access', _3 => _3.offset, 'optionalAccess', _4 => _4.y]), () => ( 0));
-  }
-  /** Tile cell index for a coordinate in grain pixels (mirrored on odd tiles when mirroring). */
-  wrap(v) {
-    const n = this.size;
-    if (!this.mirror) return (v % n + n) % n;
-    const p = (v % (2 * n) + 2 * n) % (2 * n);
-    return p < n ? p : 2 * n - 1 - p;
-  }
-  /** Height 0..1 at document position (x, y). */
-  at(x, y) {
-    const u = (x - this.ox) / this.scale - 0.5;
-    const v = (y - this.oy) / this.scale - 0.5;
-    const x0 = Math.floor(u);
-    const y0 = Math.floor(v);
-    const fx = u - x0;
-    const fy = v - y0;
-    const n = this.size;
-    const h = this.heights;
-    const a = this.wrap(x0);
-    const b = this.wrap(x0 + 1);
-    const c = this.wrap(y0) * n;
-    const d = this.wrap(y0 + 1) * n;
-    const top = h[c + a] + (h[c + b] - h[c + a]) * fx;
-    const bot = h[d + a] + (h[d + b] - h[d + a]) * fx;
-    return top + (bot - top) * fy;
-  }
-}, _class);
-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;
@@ -228,16 +54,16 @@ function lean(s) {
   return null;
 }
 function pathStrokeDabs(samples, options) {
-  const brush = _chunkFQPUF2W2cjs.normalizeBrush.call(void 0, options.brush);
+  const brush = _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, options.brush);
   const pts = options.closed && samples.length > 2 ? [...samples, samples[0]] : [...samples];
   if (!pts.length) return [];
   const tilt = _nullishCoalesce(options.tilt, () => ( {}));
   const minSize = Math.min(1, Math.max(0, _nullishCoalesce(options.minSize, () => ( 0))));
   let index = 0;
-  const t0 = _nullishCoalesce(_optionalChain([pts, 'access', _5 => _5.find, 'call', _6 => _6((s) => typeof s.t === "number" && Number.isFinite(s.t)), 'optionalAccess', _7 => _7.t]), () => ( null));
+  const t0 = _nullishCoalesce(_optionalChain([pts, 'access', _ => _.find, 'call', _2 => _2((s) => typeof s.t === "number" && Number.isFinite(s.t)), 'optionalAccess', _3 => _3.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', _4 => _4.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;
@@ -301,24 +127,24 @@ function pathStrokeDabs(samples, options) {
   return out;
 }
 function pathStrokeCoverage(samples, options) {
-  const brush = _chunkFQPUF2W2cjs.normalizeBrush.call(void 0, options.brush);
-  const coverage = new (0, _chunkFQPUF2W2cjs.CoverageMap)();
+  const brush = _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, options.brush);
+  const coverage = new (0, _chunkNIBFKXMDcjs.CoverageMap)();
   const dabs = pathStrokeDabs(samples, options);
-  const g = _optionalChain([options, 'access', _9 => _9.gradient, 'optionalAccess', _10 => _10.paint, 'access', _11 => _11.type]) === "gradient" ? options.gradient : null;
-  const sampler = g ? new (0, _chunkFQPUF2W2cjs.PaintGradientSampler)(_chunkFQPUF2W2cjs.resolvePaintGradient.call(void 0, g.paint, _nullishCoalesce(g.colors, () => ( { paint: "#000000", secondary: "#ffffff" }))), _nullishCoalesce(g.seed, () => ( 0))) : null;
-  const tipTable = _optionalChain([sampler, 'optionalAccess', _12 => _12.acrossTip]) ? sampler.tipTable(_chunkFQPUF2W2cjs.TIP_GRADIENT_STEPS) : null;
+  const g = _optionalChain([options, 'access', _5 => _5.gradient, 'optionalAccess', _6 => _6.paint, 'access', _7 => _7.type]) === "gradient" ? options.gradient : null;
+  const sampler = g ? new (0, _chunkNIBFKXMDcjs.PaintGradientSampler)(_chunkNIBFKXMDcjs.resolvePaintGradient.call(void 0, g.paint, _nullishCoalesce(g.colors, () => ( { paint: "#000000", secondary: "#ffffff" }))), _nullishCoalesce(g.seed, () => ( 0))) : null;
+  const tipTable = _optionalChain([sampler, 'optionalAccess', _8 => _8.acrossTip]) ? sampler.tipTable(_chunkNIBFKXMDcjs.TIP_GRADIENT_STEPS) : null;
   const scratch = { field: new Float32Array(0), sample: { rgb: [0, 0, 0], alpha: 1 } };
   let buf = new Float32Array(0);
   let bounds = null;
   for (const d of dabs) {
-    const rect = _chunkFQPUF2W2cjs.dabRect.call(void 0, d, brush.hardness);
+    const rect = _chunkNIBFKXMDcjs.dabRect.call(void 0, d, brush.hardness);
     const n = rect.width * rect.height;
     if (n <= 0) continue;
     if (buf.length < n) buf = new Float32Array(n);
     const vals = buf.subarray(0, n);
-    _chunkFQPUF2W2cjs.rasterizeDab.call(void 0, d, brush.hardness, rect, vals);
+    _chunkNIBFKXMDcjs.rasterizeDab.call(void 0, d, brush.hardness, rect, vals);
     if (sampler) {
-      const { color, field } = _chunkFQPUF2W2cjs.gradientDabColor.call(void 0, sampler, tipTable, d, d.params, rect, vals, scratch);
+      const { color, field } = _chunkNIBFKXMDcjs.gradientDabColor.call(void 0, sampler, tipTable, d, d.params, rect, vals, scratch);
       coverage.accumulate(rect, vals, d.opacity, color, field);
     } else coverage.accumulate(rect, vals, d.opacity);
     if (!bounds) bounds = { ...rect };
@@ -330,12 +156,12 @@ 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', _9 => _9.params, 'optionalAccess', _10 => _10.pressure]), () => ( 1))), 0) / dabs.length;
     for (const [key, t] of coverage.tiles) {
       const { tx, ty } = _chunk474IQG74cjs.tileCoord.call(void 0, key);
       for (let y = 0, k = 0; y < _chunk474IQG74cjs.TILE; y++) {
         const gy = ty * _chunk474IQG74cjs.TILE + y + 0.5;
-        for (let x = 0; x < _chunk474IQG74cjs.TILE; x++, k++) if (t[k] > 0) t[k] *= strokeGrainCatch(grain.at(tx * _chunk474IQG74cjs.TILE + x + 0.5, gy), grain.depth, pressure);
+        for (let x = 0; x < _chunk474IQG74cjs.TILE; x++, k++) if (t[k] > 0) t[k] *= _chunkNIBFKXMDcjs.strokeGrainCatch.call(void 0, grain.at(tx * _chunk474IQG74cjs.TILE + x + 0.5, gy), grain.depth, pressure);
       }
     }
   }
@@ -343,14 +169,14 @@ function pathStrokeCoverage(samples, options) {
 }
 function paintPathStroke(surface, samples, options) {
   if (surface.channels !== 4) throw new Error("paintPathStroke paints RGBA surfaces (4 channels).");
-  const brush = _chunkFQPUF2W2cjs.normalizeBrush.call(void 0, options.brush);
+  const brush = _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, 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") {
-    const rgb = _chunkFQPUF2W2cjs.hexToPaintRgb.call(void 0, options.paint.paint.color).map((v) => Math.round(v * 255));
+  if (_optionalChain([options, 'access', _11 => _11.paint, 'optionalAccess', _12 => _12.paint, 'access', _13 => _13.type]) === "color") {
+    const rgb = _chunkNIBFKXMDcjs.hexToPaintRgb.call(void 0, 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', _14 => _14.paint, 'optionalAccess', _15 => _15.paint, 'access', _16 => _16.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 }));
@@ -367,9 +193,9 @@ function paintPathStroke(surface, samples, options) {
   const tiles = new Map(surface.tiles);
   for (const { tx, ty } of _chunk474IQG74cjs.tilesInRect.call(void 0, { x: bounds.x - offset.x, y: bounds.y - offset.y, width: bounds.width, height: bounds.height })) {
     const key = _chunk474IQG74cjs.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', _17 => _17.tiles, 'access', _18 => _18.get, 'call', _19 => _19(key), 'optionalAccess', _20 => _20.data]);
     const base = src && src.length === _chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4 ? src : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
-    const t = _chunk474IQG74cjs.finishTile.call(void 0, _chunkFQPUF2W2cjs.applyStrokeToTile.call(void 0, coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
+    const t = _chunk474IQG74cjs.finishTile.call(void 0, _chunkNIBFKXMDcjs.applyStrokeToTile.call(void 0, coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
     if (t) tiles.set(key, t);
     else tiles.delete(key);
   }
@@ -413,7 +239,7 @@ var REFUSED_ENGINES = {
 };
 function brushstrokeStrokeOptions(brush) {
   if (!brush || typeof brush !== "object") throw new Error("A brushstroke needs a brush: tip settings ({ size, hardness, \u2026 }) or a paint brush preset.");
-  if (!("tip" in brush) || !brush.tip) return { brush: _chunkFQPUF2W2cjs.normalizeBrush.call(void 0, brush) };
+  if (!("tip" in brush) || !brush.tip) return { brush: _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, brush) };
   const engine = _nullishCoalesce(brush.engine, () => ( "dab"));
   if (engine !== "dab") {
     const label = _nullishCoalesce(_nullishCoalesce(brush.name, () => ( brush.id)), () => ( "This brush"));
@@ -423,7 +249,7 @@ function brushstrokeStrokeOptions(brush) {
   const d = _nullishCoalesce(brush.dynamics, () => ( {}));
   const tilt = { size: _nullishCoalesce(d.tiltSize, () => ( 0)), roundness: _nullishCoalesce(d.tiltRoundness, () => ( 0)) };
   return {
-    brush: _chunkFQPUF2W2cjs.normalizeBrush.call(void 0, brush.tip),
+    brush: _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, brush.tip),
     followPath: brush.rotation === "stroke",
     minSize: _nullishCoalesce(d.minSize, () => ( 0)),
     ...tilt.size || tilt.roundness ? { tilt } : {}
@@ -447,7 +273,7 @@ function paperGrain(paper) {
   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 } });
+    g = new (0, _chunkNIBFKXMDcjs.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);
   }
@@ -463,7 +289,7 @@ function renderBrushstroke(input, brush, options = {}) {
   let scale = finite(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', _21 => _21.tilt, 'optionalAccess', _22 => _22.size]), () => ( 0)))) + 4;
   let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
   for (const s of samples) {
     x0 = Math.min(x0, s.x);
@@ -486,8 +312,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', _23 => _23.origin, 'optionalAccess', _24 => _24.x]), () => ( 0));
+      const oy = _nullishCoalesce(_optionalChain([ch, 'access', _25 => _25.origin, 'optionalAccess', _26 => _26.y]), () => ( 0));
       const k = (finite(ch.unit) && ch.unit > 0 ? ch.unit : 1) / scale;
       grain = { depth, at: (x, y) => g.at(ox + x * k, oy + y * k) };
     }
@@ -500,7 +326,7 @@ function renderBrushstroke(input, brush, options = {}) {
     closed: _nullishCoalesce(options.closed, () => ( strokeOptions.closed)),
     color,
     // Gradient lengths are in path units: scale them with the image.
-    ...source ? { paint: { paint: source.type === "gradient" ? _chunkFQPUF2W2cjs.scalePaintGradient.call(void 0, source, scale) : source, seed: _nullishCoalesce(options.seed, () => ( 0)) } } : {}
+    ...source ? { paint: { paint: source.type === "gradient" ? _chunkNIBFKXMDcjs.scalePaintGradient.call(void 0, source, scale) : source, seed: _nullishCoalesce(options.seed, () => ( 0)) } } : {}
   });
   if (!bounds) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs };
   const rect = bounds;
@@ -542,14 +368,14 @@ function brushstrokeKey(input, brush, options = {}) {
   const scale = finite(options.scale) ? options.scale : 1;
   return `${hashString(path).toString(16)}:${path.length}:${hashString(rest2).toString(16)}:${scale}`;
 }
-var BrushstrokeCache = (_class2 = class {
-  constructor(capacity = 64) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+var BrushstrokeCache = (_class = class {
+  constructor(capacity = 64) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
     this.capacity = capacity;
   }
   
-  __init2() {this.entries = /* @__PURE__ */ new Map()}
+  __init() {this.entries = /* @__PURE__ */ new Map()}
   /** Renders that missed the cache (for tests and stats). */
-  __init3() {this.misses = 0}
+  __init2() {this.misses = 0}
   get size() {
     return this.entries.size;
   }
@@ -571,13 +397,7 @@ var BrushstrokeCache = (_class2 = class {
   clear() {
     this.entries.clear();
   }
-}, _class2);
-
-
-
-
-
-
+}, _class);
 
 
 
@@ -591,4 +411,4 @@ var BrushstrokeCache = (_class2 = class {
 
 
 
-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.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;