@weasel-js/renderer 0.0.0-stage → 1.9.4

package/dist/mesh.js

@@ -0,0 +1,603 @@
+import { resolveColor, lerpColorArray, srgbFloatToOklab, oklabToOklch, oklchToOklab, oklabToSrgbU8, rgbaToHex } from '@weasel-js/paint';
+import { mat3 } from '@weasel-js/geom';
+
+// src/meshPaint/meshPaint.ts
+
+// src/meshPaint/surface.ts
+function patchCorner(patch, i) {
+  return patch.points[(i & 3) * 3];
+}
+function isTensorPatch(patch) {
+  return patch.points.length >= 16;
+}
+function isValidPatch(patch) {
+  return patch.points.length === 12 || patch.points.length === 16;
+}
+function bezier(p0, p1, p2, p3, t) {
+  const s = 1 - t;
+  const a = s * s * s;
+  const b = 3 * s * s * t;
+  const c = 3 * s * t * t;
+  const d = t * t * t;
+  return {
+    x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,
+    y: a * p0.y + b * p1.y + c * p2.y + d * p3.y
+  };
+}
+function edge(patch, i) {
+  const p = patch.points;
+  const a = (i & 3) * 3;
+  return [p[a], p[a + 1], p[a + 2], p[(i + 1 & 3) * 3]];
+}
+function evalPatch(patch, u, v) {
+  return isTensorPatch(patch) ? evalTensor(patch, u, v) : evalCoons(patch, u, v);
+}
+function evalCoons(patch, u, v) {
+  const [b0, b1, b2, b3] = edge(patch, 0);
+  const [r0, r1, r2, r3] = edge(patch, 1);
+  const [t0, t1, t2, t3] = edge(patch, 2);
+  const [l0, l1, l2, l3] = edge(patch, 3);
+  const bottom = bezier(b0, b1, b2, b3, u);
+  const top = bezier(t0, t1, t2, t3, 1 - u);
+  const right = bezier(r0, r1, r2, r3, v);
+  const left = bezier(l0, l1, l2, l3, 1 - v);
+  const c0 = patchCorner(patch, 0);
+  const c1 = patchCorner(patch, 1);
+  const c2 = patchCorner(patch, 2);
+  const c3 = patchCorner(patch, 3);
+  const ruledU = (a, b) => (1 - v) * a + v * b;
+  const ruledV = (a, b) => (1 - u) * a + u * b;
+  const corner = (k0, k1, k2, k3) => (1 - u) * (1 - v) * k0 + u * (1 - v) * k1 + u * v * k2 + (1 - u) * v * k3;
+  return {
+    x: ruledU(bottom.x, top.x) + ruledV(left.x, right.x) - corner(c0.x, c1.x, c2.x, c3.x),
+    y: ruledU(bottom.y, top.y) + ruledV(left.y, right.y) - corner(c0.y, c1.y, c2.y, c3.y)
+  };
+}
+function tensorNet(patch) {
+  const p = patch.points;
+  return [
+    [p[0], p[11], p[10], p[9]],
+    [p[1], p[12], p[13], p[8]],
+    [p[2], p[15], p[14], p[7]],
+    [p[3], p[4], p[5], p[6]]
+  ];
+}
+var BERNSTEIN = (t) => {
+  const s = 1 - t;
+  return [s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t];
+};
+function evalTensor(patch, u, v) {
+  const net = tensorNet(patch);
+  const bu = BERNSTEIN(u);
+  const bv = BERNSTEIN(v);
+  let x = 0;
+  let y = 0;
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      const w = bu[i] * bv[j];
+      x += w * net[i][j].x;
+      y += w * net[i][j].y;
+    }
+  }
+  return { x, y };
+}
+function cornerWeights(u, v) {
+  return [(1 - u) * (1 - v), u * (1 - v), u * v, (1 - u) * v];
+}
+function patchBounds(patch, steps = 8) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let i = 0; i <= steps; i++) {
+    for (let j = 0; j <= steps; j++) {
+      const p = evalPatch(patch, i / steps, j / steps);
+      if (p.x < minX) minX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y > maxY) maxY = p.y;
+    }
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+
+// src/meshPaint/bake.ts
+var MESH_BAKE_SIZE = 256;
+var TEXELS_PER_CELL = 10;
+function gridFor(size) {
+  return Math.max(24, Math.ceil(size / TEXELS_PER_CELL));
+}
+function meshBounds(patches) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const patch of patches) {
+    if (!isValidPatch(patch)) continue;
+    const b = patchBounds(patch);
+    minX = Math.min(minX, b.x);
+    minY = Math.min(minY, b.y);
+    maxX = Math.max(maxX, b.x + b.width);
+    maxY = Math.max(maxY, b.y + b.height);
+  }
+  if (!Number.isFinite(minX) || maxX <= minX || maxY <= minY) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function colorAt(corners, u, v, space) {
+  const bottom = lerpColorArray(corners[0], corners[1], u, space);
+  const top = lerpColorArray(corners[3], corners[2], u, space);
+  return lerpColorArray(bottom, top, v, space);
+}
+function bakeMesh(patches, space = "rgb", size = MESH_BAKE_SIZE) {
+  const box = meshBounds(patches);
+  if (!box) return null;
+  const pixels = new Uint8ClampedArray(size * size * 4);
+  const grid = gridFor(size);
+  const toTexel = (p) => ({
+    x: (p.x - box.x) / box.width * (size - 1) + 0.5,
+    y: (p.y - box.y) / box.height * (size - 1) + 0.5
+  });
+  for (const patch of patches) {
+    if (!isValidPatch(patch)) continue;
+    const corners = patch.colors.map((c) => resolveColor(c));
+    for (let i = 0; i < grid; i++) {
+      for (let j = 0; j < grid; j++) {
+        const u0 = i / grid;
+        const u1 = (i + 1) / grid;
+        const v0 = j / grid;
+        const v1 = (j + 1) / grid;
+        const quad = [
+          { at: toTexel(evalPatch(patch, u0, v0)), color: colorAt(corners, u0, v0, space) },
+          { at: toTexel(evalPatch(patch, u1, v0)), color: colorAt(corners, u1, v0, space) },
+          { at: toTexel(evalPatch(patch, u1, v1)), color: colorAt(corners, u1, v1, space) },
+          { at: toTexel(evalPatch(patch, u0, v1)), color: colorAt(corners, u0, v1, space) }
+        ];
+        fillTriangle(pixels, size, quad[0], quad[1], quad[2]);
+        fillTriangle(pixels, size, quad[0], quad[2], quad[3]);
+      }
+    }
+  }
+  return { pixels, size, box };
+}
+function fillTriangle(pixels, size, a, b, c) {
+  const minX = Math.max(0, Math.floor(Math.min(a.at.x, b.at.x, c.at.x)));
+  const maxX = Math.min(size - 1, Math.ceil(Math.max(a.at.x, b.at.x, c.at.x)));
+  const minY = Math.max(0, Math.floor(Math.min(a.at.y, b.at.y, c.at.y)));
+  const maxY = Math.min(size - 1, Math.ceil(Math.max(a.at.y, b.at.y, c.at.y)));
+  if (maxX < minX || maxY < minY) return;
+  const area = (b.at.x - a.at.x) * (c.at.y - a.at.y) - (c.at.x - a.at.x) * (b.at.y - a.at.y);
+  if (Math.abs(area) < 1e-9) return;
+  for (let y = minY; y <= maxY; y++) {
+    for (let x = minX; x <= maxX; x++) {
+      const px = x + 0.5;
+      const py = y + 0.5;
+      const w0 = ((b.at.x - px) * (c.at.y - py) - (c.at.x - px) * (b.at.y - py)) / area;
+      const w1 = ((c.at.x - px) * (a.at.y - py) - (a.at.x - px) * (c.at.y - py)) / area;
+      const w2 = 1 - w0 - w1;
+      if (w0 < -1e-6 || w1 < -1e-6 || w2 < -1e-6) continue;
+      const k = (y * size + x) * 4;
+      for (let ch = 0; ch < 4; ch++) {
+        pixels[k + ch] = (w0 * a.color[ch] + w1 * b.color[ch] + w2 * c.color[ch]) * 255;
+      }
+    }
+  }
+}
+
+// src/meshPaint/bakeCache.ts
+var MESH_BAKE_MIN = 32;
+var MESH_BAKE_MAX = 2048;
+var MESH_BAKE_CACHE_BYTES = 64 * 1024 * 1024;
+var MESH_BAKE_CACHE_ENTRIES = 256;
+function meshBakeSize(devicePx, maxTextureSize) {
+  const ceiling = Math.min(MESH_BAKE_MAX, floorPow2(maxTextureSize));
+  if (Number.isNaN(devicePx)) return Math.min(MESH_BAKE_SIZE, ceiling);
+  if (devicePx <= MESH_BAKE_MIN) return Math.min(MESH_BAKE_MIN, ceiling);
+  if (devicePx >= ceiling) return ceiling;
+  return Math.min(ceiling, 2 ** Math.ceil(Math.log2(devicePx)));
+}
+function floorPow2(n) {
+  if (!(n >= 1)) return MESH_BAKE_MIN;
+  if (!Number.isFinite(n)) return MESH_BAKE_MAX;
+  return 2 ** Math.floor(Math.log2(n));
+}
+var MeshBakeCache = class {
+  constructor(free, budgetBytes = MESH_BAKE_CACHE_BYTES, maxEntries = MESH_BAKE_CACHE_ENTRIES) {
+    this.free = free;
+    this.budgetBytes = budgetBytes;
+    this.maxEntries = maxEntries;
+  }
+  free;
+  budgetBytes;
+  maxEntries;
+  byPaint = /* @__PURE__ */ new WeakMap();
+  /** Insertion order is recency: a hit is deleted and re-added. */
+  order = /* @__PURE__ */ new Set();
+  held = 0;
+  /** Bytes the held bakes occupy, as RGBA8. */
+  get bytes() {
+    return this.held;
+  }
+  /** Bakes held. */
+  get size() {
+    return this.order.size;
+  }
+  get(paint, size) {
+    const entry = this.byPaint.get(paint)?.get(size);
+    if (!entry) return void 0;
+    this.order.delete(entry);
+    this.order.add(entry);
+    return entry.value;
+  }
+  set(paint, size, value) {
+    let bySize = this.byPaint.get(paint);
+    if (!bySize) {
+      bySize = /* @__PURE__ */ new Map();
+      this.byPaint.set(paint, bySize);
+    }
+    const old = bySize.get(size);
+    if (old) this.drop(old);
+    const entry = { value, size, bySize };
+    bySize.set(size, entry);
+    this.order.add(entry);
+    this.held += size * size * 4;
+    this.evict(entry);
+  }
+  /** Free every bake. The cache stays usable. */
+  clear() {
+    for (const entry of [...this.order]) this.drop(entry);
+  }
+  /** Oldest first until both bounds hold, never evicting `keep` — the bake
+   *  the caller is about to draw. */
+  evict(keep) {
+    for (const entry of this.order) {
+      if (this.held <= this.budgetBytes && this.order.size <= this.maxEntries) return;
+      if (entry !== keep) this.drop(entry);
+    }
+  }
+  drop(entry) {
+    if (!this.order.delete(entry)) return;
+    entry.bySize.delete(entry.size);
+    this.held -= entry.size * entry.size * 4;
+    this.free(entry.value);
+  }
+};
+
+// src/meshPaint/meshShader.ts
+var MESH_PROGRAM_ID = "kit:mesh-gradient";
+var MESH_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform mat3 u_worldInv;
+out vec2 v_world;
+void main() {
+  vec3 screen = u_model * vec3(a_position, 1.0);
+  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  vec3 world = u_worldInv * vec3(screen.xy, 1.0);
+  v_world = world.xy;
+}
+`
+);
+var MESH_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_world;
+uniform sampler2D u_sampler;
+uniform vec2  u_meshOrigin;
+uniform vec2  u_meshSize;
+uniform float u_opacity;
+uniform float u_alpha;
+out vec4 outColor;
+void main() {
+  vec2 t =(v_world - u_meshOrigin) / max(u_meshSize, vec2(0.0001));
+  if (t.x < 0.0 || t.x > 1.0 || t.y < 0.0 || t.y > 1.0) {
+    outColor = vec4(0.0);
+    return;
+  }
+  vec2 texels = vec2(textureSize(u_sampler, 0));
+  vec2 uv = (t * (texels - 1.0) + 0.5) / texels;
+  vec4 texel = texture(u_sampler, uv);
+  float a = texel.a * u_opacity * u_alpha;
+  outColor = vec4(texel.rgb * a, a);
+}
+`
+);
+
+// src/meshPaint/meshPaint.ts
+var MESH_GRADIENT_KIND = "mesh-gradient";
+function isMeshGradientFill(fill) {
+  return fill != null && fill.fill === MESH_GRADIENT_KIND;
+}
+function asMesh(fill) {
+  return fill;
+}
+function asFill(mesh) {
+  return mesh;
+}
+function shifted(color, dL, cScale, dHueDeg) {
+  const [r, g, b, a] = resolveColor(color);
+  const [L, A, B] = srgbFloatToOklab(r, g, b);
+  const [, C, h] = oklabToOklch(L, A, B);
+  const [nL, nA, nB] = oklchToOklab(
+    Math.min(1, Math.max(0, L + dL)),
+    Math.max(0, C * cScale),
+    h + dHueDeg * Math.PI / 180
+  );
+  const [nr, ng, nb] = oklabToSrgbU8(nL, nA, nB);
+  return rgbaToHex([nr / 255, ng / 255, nb / 255, a]);
+}
+function seedMeshPatch(color) {
+  const corners = [
+    { x: 0, y: 0 },
+    { x: 1, y: 0 },
+    { x: 1, y: 1 },
+    { x: 0, y: 1 }
+  ];
+  const points = [];
+  for (let i = 0; i < 4; i++) {
+    const a = corners[i];
+    const b = corners[(i + 1) % 4];
+    const nx = (b.y - a.y) * 0.125;
+    const ny = -(b.x - a.x) * 0.125;
+    points.push(
+      a,
+      { x: a.x + (b.x - a.x) / 3 + nx, y: a.y + (b.y - a.y) / 3 + ny },
+      { x: a.x + 2 * (b.x - a.x) / 3 + nx, y: a.y + 2 * (b.y - a.y) / 3 + ny }
+    );
+  }
+  return {
+    fill: MESH_GRADIENT_KIND,
+    patches: [{
+      points,
+      colors: [
+        color,
+        shifted(color, 0.14, 0.85, 0),
+        shifted(color, -0.06, 1.1, 38),
+        shifted(color, -0.16, 1, -22)
+      ]
+    }],
+    units: "bounds"
+  };
+}
+function bandPatch(x0, x1, left, right) {
+  const corners = [{ x: x0, y: 0 }, { x: x1, y: 0 }, { x: x1, y: 1 }, { x: x0, y: 1 }];
+  const points = [];
+  for (let i = 0; i < 4; i++) {
+    const a = corners[i];
+    const b = corners[(i + 1) % 4];
+    points.push(a, { x: a.x + (b.x - a.x) / 3, y: a.y + (b.y - a.y) / 3 }, { x: a.x + 2 * (b.x - a.x) / 3, y: a.y + 2 * (b.y - a.y) / 3 });
+  }
+  return { points, colors: [left, right, right, left] };
+}
+function meshFromStops(stops) {
+  const sorted = [...stops].sort((a, b) => a.offset - b.offset);
+  if (sorted.length === 1) sorted.push({ offset: 1, color: sorted[0].color });
+  if (sorted.length === 0) return seedMeshPatch("#000000ff");
+  const patches = [];
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const a = sorted[i];
+    const b = sorted[i + 1];
+    if (b.offset > a.offset) patches.push(bandPatch(a.offset, b.offset, a.color, b.color));
+  }
+  return { fill: MESH_GRADIENT_KIND, patches, units: "bounds" };
+}
+function meshStops(mesh) {
+  const valid = mesh.patches.filter(isValidPatch);
+  if (valid.length === 0) return [];
+  const xs = valid.flatMap((p) => [p.points[0].x, p.points[3].x]);
+  const lo = Math.min(...xs);
+  const span = Math.max(...xs) - lo;
+  const offsetOf = (x) => span > 0 ? (x - lo) / span : 0;
+  const stops = [];
+  for (const patch of valid) {
+    for (const [point, color] of [[patch.points[0], patch.colors[0]], [patch.points[3], patch.colors[1]]]) {
+      const offset = offsetOf(point.x);
+      if (!stops.some((s) => s.offset === offset && s.color === color)) stops.push({ offset, color });
+    }
+  }
+  return stops.sort((a, b) => a.offset - b.offset);
+}
+function mapPatches(mesh, move) {
+  return mesh.patches.map((patch) => ({ ...patch, points: patch.points.map(move) }));
+}
+var BAKE_SOURCE = /* @__PURE__ */ new WeakMap();
+var CACHES = /* @__PURE__ */ new WeakMap();
+function cacheFor(ctx) {
+  let cache = CACHES.get(ctx.resources);
+  if (!cache) {
+    const gl = ctx.gl;
+    const made = new MeshBakeCache((texture) => gl.deleteTexture(texture));
+    ctx.resources.onRelease(() => {
+      made.clear();
+      CACHES.delete(ctx.resources);
+    });
+    CACHES.set(ctx.resources, made);
+    cache = made;
+  }
+  return cache;
+}
+function devicePixelsOf(ctx, mesh, box) {
+  const m = ctx.spaceToDevice(mesh.units);
+  if (!m) return Number.NaN;
+  return Math.max(box.width * Math.hypot(m[0], m[1]), box.height * Math.hypot(m[3], m[4]));
+}
+function bakeFor(ctx, mesh) {
+  const box = meshBounds(mesh.patches);
+  if (!box) return null;
+  const size = meshBakeSize(devicePixelsOf(ctx, mesh, box), ctx.maxTextureSize);
+  const cache = cacheFor(ctx);
+  const key = BAKE_SOURCE.get(mesh) ?? mesh;
+  const hit = cache.get(key, size);
+  if (hit) return { texture: hit, box };
+  const baked = bakeMesh(mesh.patches, mesh.interpolate ?? "rgb", size);
+  if (!baked) return null;
+  const gl = ctx.gl;
+  const texture = gl.createTexture();
+  if (!texture) return null;
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  gl.texImage2D(
+    gl.TEXTURE_2D,
+    0,
+    gl.RGBA,
+    baked.size,
+    baked.size,
+    0,
+    gl.RGBA,
+    gl.UNSIGNED_BYTE,
+    baked.pixels
+  );
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  cache.set(key, size, texture);
+  return { texture, box };
+}
+function bindMesh(ctx, fill) {
+  const mesh = asMesh(fill);
+  if (!mesh.patches.some(isValidPatch)) return null;
+  const inverse = ctx.spaceInverse(mesh.units);
+  if (!inverse) return null;
+  const program = ctx.program(MESH_PROGRAM_ID);
+  if (!program) return null;
+  const entry = bakeFor(ctx, mesh);
+  if (!entry) return null;
+  const gl = ctx.gl;
+  gl.useProgram(program.handle);
+  ctx.setProjAndModel(program);
+  gl.uniformMatrix3fv(program.uniform("u_worldInv"), false, mat3.toUniform(inverse));
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+  gl.uniform1i(program.uniform("u_sampler"), 0);
+  const { box } = entry;
+  gl.uniform2f(program.uniform("u_meshOrigin"), box.x, box.y);
+  gl.uniform2f(program.uniform("u_meshSize"), box.width, box.height);
+  gl.uniform1f(program.uniform("u_opacity"), mesh.opacity ?? 1);
+  gl.uniform1f(program.uniform("u_alpha"), ctx.alpha);
+  return program;
+}
+var meshDrawKind = {
+  id: MESH_GRADIENT_KIND,
+  programs: { [MESH_PROGRAM_ID]: { vert: MESH_VERT_SRC, frag: MESH_FRAG_SRC } },
+  bind: bindMesh,
+  inPoseFrame: (fill, box) => {
+    const mesh = asMesh(fill);
+    if (mesh.units !== "bounds") return fill;
+    const posed = asFill({
+      ...mesh,
+      patches: mapPatches(mesh, (p) => ({
+        x: box.x + p.x * box.width,
+        y: box.y + p.y * box.height
+      })),
+      units: "local"
+    });
+    BAKE_SOURCE.set(posed, fill);
+    return posed;
+  },
+  toBoundsFrame: (fill, box) => {
+    const mesh = asMesh(fill);
+    if (mesh.units === "bounds" || box.width === 0 || box.height === 0) return fill;
+    return asFill({
+      ...mesh,
+      patches: mapPatches(mesh, (p) => ({
+        x: (p.x - box.x) / box.width,
+        y: (p.y - box.y) / box.height
+      })),
+      units: "bounds"
+    });
+  }
+};
+function meshGradientXml(id, mesh) {
+  const P = "wzl";
+  const units = mesh.units === "bounds" ? "objectBoundingBox" : "userSpaceOnUse";
+  const space = mesh.interpolate && mesh.interpolate !== "rgb" ? ` interpolate="${mesh.interpolate}"` : "";
+  const patches = mesh.patches.map((patch) => {
+    const points = patch.points.map((p) => `${trim(p.x)},${trim(p.y)}`).join(" ");
+    const colors = patch.colors.join(" ");
+    return `<${P}:patch points="${points}" colors="${colors}"/>`;
+  }).join("");
+  return `<${P}:meshGradient id="${id}" gradientUnits="${units}"${space}>${patches}</${P}:meshGradient>`;
+}
+function trim(n) {
+  return Number.isInteger(n) ? String(n) : String(Number(n.toFixed(4)));
+}
+
+// src/meshPaint/handles.ts
+var INTERIOR_OF_CORNER = [12, 15, 14, 13];
+function kindOf(index) {
+  if (index >= 12) return "interior";
+  return index % 3 === 0 ? "corner" : "control";
+}
+function near(a, b) {
+  return Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
+}
+function same(a, b) {
+  return near(a.x, b.x) && near(a.y, b.y);
+}
+function meshHandles(mesh) {
+  const handles = [];
+  mesh.patches.forEach((patch, p) => {
+    if (!isValidPatch(patch)) return;
+    patch.points.forEach((at, index) => {
+      const kind = kindOf(index);
+      const twin = handles.find((h) => h.kind === kind && same(h.at, at));
+      if (twin) twin.refs.push({ patch: p, index });
+      else handles.push({ id: `${p}:${index}`, kind, at, refs: [{ patch: p, index }] });
+    });
+  });
+  return handles;
+}
+function carriedBy(patch, corner) {
+  const k = corner / 3;
+  const carried = [corner + 1, (corner + 11) % 12];
+  if (isTensorPatch(patch)) carried.push(INTERIOR_OF_CORNER[k]);
+  return carried;
+}
+function moveMeshHandle(mesh, handle, to) {
+  const dx = to.x - handle.at.x;
+  const dy = to.y - handle.at.y;
+  const placed = /* @__PURE__ */ new Map();
+  for (const { patch, index } of handle.refs) {
+    placed.set(`${patch}:${index}`, to);
+  }
+  if (handle.kind === "corner") {
+    for (const { patch, index } of handle.refs) {
+      for (const carried of carriedBy(mesh.patches[patch], index)) {
+        const key = `${patch}:${carried}`;
+        if (placed.has(key)) continue;
+        const from = mesh.patches[patch].points[carried];
+        placed.set(key, { x: from.x + dx, y: from.y + dy });
+      }
+    }
+  }
+  return {
+    ...mesh,
+    patches: mesh.patches.map((patch, p) => ({
+      ...patch,
+      points: patch.points.map((point, i) => placed.get(`${p}:${i}`) ?? point)
+    }))
+  };
+}
+function meshGuides(mesh) {
+  const edges = [];
+  const arms = [];
+  for (const patch of mesh.patches) {
+    if (!isValidPatch(patch)) continue;
+    const p = patch.points;
+    for (let k = 0; k < 4; k++) {
+      const corner = k * 3;
+      edges.push([p[corner], p[corner + 1], p[corner + 2], p[(corner + 3) % 12]]);
+      for (const carried of carriedBy(patch, corner)) arms.push([p[corner], p[carried]]);
+    }
+  }
+  return { edges, arms };
+}
+
+export { MESH_BAKE_MAX, MESH_BAKE_MIN, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, bakeMesh, cornerWeights, evalPatch, isMeshGradientFill, isTensorPatch, isValidPatch, meshBakeSize, meshBounds, meshDrawKind, meshFromStops, meshGradientXml, meshGuides, meshHandles, meshStops, moveMeshHandle, patchBounds, patchCorner, seedMeshPatch };
+//# sourceMappingURL=mesh.js.map
+//# sourceMappingURL=mesh.js.map