@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/embroidery/compile.js

@@ -0,0 +1,85 @@
+import { dist as h, evenly as m, inset as l, area as u, inside as d } from "./geom.js";
+import { tatami as a } from "./fill.js";
+import { satinUnderlay as y, satin as w } from "./satin.js";
+import { DEFAULTS as x } from "./types.js";
+class p {
+  constructor(t) {
+    this.p = t;
+  }
+  p;
+  out = [];
+  at;
+  before;
+  get pos() {
+    return this.at;
+  }
+  /** Sews to `to`, in pieces no longer than the stitch cap. */
+  stitchTo(t) {
+    const o = this.at;
+    if (!o) throw new Error("stitchTo before moveTo");
+    const i = Math.ceil(h(o, t) / this.p.maxStitch);
+    for (let s = 1; s <= i; s++) this.out.push({ x: o[0] + (t[0] - o[0]) * s / i, y: o[1] + (t[1] - o[1]) * s / i, cmd: "stitch" });
+    this.before = o, this.at = t;
+  }
+  /** Gets to `to`: a plain stitch when it is within `join` mm (and `ok`), else a trim and a jump, with lock stitches around the cut. */
+  moveTo(t, o, i = () => !0) {
+    const s = this.at;
+    return s && h(s, t) <= o && i(s, t) ? (this.stitchTo(t), !1) : (s && (this.lock(), this.out.push({ x: s[0], y: s[1], cmd: "trim" })), this.out.push({ x: t[0], y: t[1], cmd: "jump" }), this.at = t, this.before = void 0, !0);
+  }
+  /** Tie-off: two tiny stitches back along the stitching just sewn and out again (not out across the design). */
+  lock() {
+    this.at && this.before && this.tie(this.at, this.before);
+  }
+  /** Two short out-and-back stitches from `a` toward `b`, which lie along stitching already there or about to be. */
+  tie(t, o) {
+    const i = Math.min(0.6, h(t, o) / 2);
+    if (i < 0.1) return;
+    const s = [t[0] + (o[0] - t[0]) / h(t, o) * i, t[1] + (o[1] - t[1]) / h(t, o) * i];
+    for (const c of [s, t, s, t]) this.out.push({ x: c[0], y: c[1], cmd: "stitch" });
+  }
+  colorChange() {
+    const t = this.at;
+    t && (this.lock(), this.out.push({ x: t[0], y: t[1], cmd: "trim" }, { x: t[0], y: t[1], cmd: "color" })), this.at = void 0;
+  }
+  end() {
+    const t = this.at;
+    t && (this.lock(), this.out.push({ x: t[0], y: t[1], cmd: "trim" }, { x: t[0], y: t[1], cmd: "end" }));
+  }
+  /** Sews the points in order, starting by getting to the first. */
+  sew(t, o, i) {
+    if (t.length) {
+      this.moveTo(t[0], o, i) && t.length > 1 && this.tie(t[0], t[1]);
+      for (let s = 1; s < t.length; s++) this.stitchTo(t[s]);
+    }
+  }
+}
+const f = 3;
+function g(n, t, o) {
+  const i = o.fillGrow ? t.polys.map((e) => l(e, -o.fillGrow)) : t.polys, s = i.reduce((e, r) => e + Math.abs(u(r)), 0), c = (e, r) => d(i, [(e[0] + r[0]) / 2, (e[1] + r[1]) / 2]);
+  for (const e of i) {
+    const r = m(l(e, 0.7), o.underlayRun, !0);
+    n.sew(r, f);
+  }
+  if (s > 60) {
+    const e = i.map((r) => l(r, 0.9));
+    for (const r of a(e, t.angle + 90, 2.2, o.fillLength)) n.sew(r, o.maxStitch, c);
+  }
+  for (const e of a(i, t.angle, o.fillSpacing, o.fillLength)) n.sew(e, o.maxStitch, c);
+}
+function k(n, t, o) {
+  if (t.kind === "fill") return g(n, t, o);
+  if (t.kind === "run") return n.sew(m(t.path, o.underlayRun, t.closed), f);
+  const i = t.width + o.pullComp;
+  for (const s of y(t.path, i, o.underlayRun, !!t.closed)) n.sew(s, f);
+  for (const s of w(t.path, i, o.satinDensity, !!t.closed, o.maxSatin)) n.sew(s, f);
+}
+function E(n, t = {}) {
+  const o = { ...x, ...t }, i = new p(o);
+  return n.blocks.forEach((s, c) => {
+    c && i.colorChange();
+    for (const e of s.items) k(i, e, o);
+  }), i.end(), { name: n.name, threads: n.blocks.map((s) => s.thread), stitches: i.out };
+}
+export {
+  E as compile
+};

package/dist/embroidery/dst.js

@@ -0,0 +1,79 @@
+import { toRecords as g } from "./units.js";
+const p = [
+  // [byte, plus bit, minus bit, weight] for x, then y
+  [
+    [0, 1, 2, 1],
+    [1, 1, 2, 3],
+    [0, 4, 8, 9],
+    [1, 4, 8, 27],
+    [2, 4, 8, 81]
+  ],
+  [
+    [0, 128, 64, 1],
+    [1, 128, 64, 3],
+    [0, 32, 16, 9],
+    [1, 32, 16, 27],
+    [2, 32, 16, 81]
+  ]
+];
+function x(a, e, f) {
+  const r = [0, 0, 3 | f];
+  return [a, e].forEach((c, d) => {
+    let n = c;
+    for (const [o, i, l, s] of [...p[d]].reverse())
+      n > s / 2 ? (r[o] |= i, n -= s) : n < -s / 2 && (r[o] |= l, n += s);
+    if (n !== 0) throw new Error(`move ${c} does not fit a DST record`);
+  }), r;
+}
+const $ = (a, e) => a.slice(0, e).padEnd(e, " ");
+function M(a) {
+  const e = [];
+  let f = 0, r = 0, c = 0, d = 0, n = 0, o = 0, i = 0;
+  const l = (t, m) => {
+    e.push(x(t.dx, t.dy, m)), r += t.dx, c += t.dy, d = Math.min(d, r), n = Math.max(n, r), o = Math.min(o, c), i = Math.max(i, c);
+  };
+  for (const t of g(a))
+    t.cmd === "stitch" ? l(t, 0) : t.cmd === "jump" ? l(t, 128) : t.cmd === "trim" ? (l({ dx: 1, dy: 1 }, 128), l({ dx: -1, dy: -1 }, 128)) : t.cmd === "color" && (e.push([0, 0, 195]), f++);
+  e.push([0, 0, 243]);
+  const s = [
+    `LA:${$(a.name.toUpperCase(), 16)}`,
+    `ST:${String(e.length).padStart(7, " ")}`,
+    `CO:${String(f).padStart(3, " ")}`,
+    `+X:${String(n).padStart(5, " ")}`,
+    `-X:${String(-d).padStart(5, " ")}`,
+    `+Y:${String(i).padStart(5, " ")}`,
+    `-Y:${String(-o).padStart(5, " ")}`,
+    `AX:${(r >= 0 ? "+" : "-").concat(String(Math.abs(r)).padStart(5, " "))}`,
+    `AY:${(c >= 0 ? "+" : "-").concat(String(Math.abs(c)).padStart(5, " "))}`,
+    `MX:+${String(0).padStart(5, " ")}`,
+    `MY:+${String(0).padStart(5, " ")}`,
+    "PD:******"
+  ].join("\r"), h = new Uint8Array(512 + e.length * 3);
+  h.fill(32, 0, 512);
+  for (let t = 0; t < s.length; t++) h[t] = s.charCodeAt(t);
+  return h[s.length] = 13, h[s.length + 1] = 26, e.forEach((t, m) => h.set(t, 512 + m * 3)), h;
+}
+function w(a) {
+  const e = String.fromCharCode(...a.subarray(0, 512)), f = (o) => Number(new RegExp(`${o}:\\s*(\\d+)`).exec(e)?.[1] ?? NaN), r = [];
+  let c = 0, d = 0, n = 0;
+  for (let o = 512; o + 2 < a.length; o += 3) {
+    const i = [a[o], a[o + 1], a[o + 2]];
+    if (i[2] === 243) {
+      r.push({ x: d / 10, y: n / 10, cmd: "end" });
+      break;
+    }
+    if (i[2] === 195) {
+      c++, r.push({ x: d / 10, y: n / 10, cmd: "color" });
+      continue;
+    }
+    const l = [0, 0];
+    p.forEach((s, h) => {
+      for (const [t, m, u, S] of s) l[h] += (i[t] & m ? S : 0) - (i[t] & u ? S : 0);
+    }), d += l[0], n += l[1], r.push({ x: d / 10, y: n / 10, cmd: i[2] & 128 ? "jump" : "stitch" });
+  }
+  return { stitches: r, colorChanges: c, label: e.slice(3, 19).trim(), declared: { stitches: f("ST"), colors: f("CO") } };
+}
+export {
+  w as readDst,
+  M as writeDst
+};

package/dist/embroidery/exp.js

@@ -0,0 +1,26 @@
+import { toRecords as u } from "./units.js";
+const r = (c) => c & 255;
+function m(c) {
+  const o = [];
+  for (const t of u(c, 127))
+    t.cmd === "stitch" ? o.push(r(t.dx), r(t.dy)) : t.cmd === "jump" ? o.push(128, 4, r(t.dx), r(t.dy)) : t.cmd === "trim" ? o.push(128, 128, 7, 0) : t.cmd === "color" && o.push(128, 1, 0, 0);
+  return Uint8Array.from(o);
+}
+const s = (c) => c > 127 ? c - 256 : c;
+function f(c) {
+  const o = [];
+  let t = 0, i = 0, n = 0;
+  for (let e = 0; e < c.length; ) {
+    if (c[e] === 128 && e + 1 < c.length) {
+      const d = c[e + 1];
+      d === 1 ? (t++, o.push({ x: i / 10, y: n / 10, cmd: "color" })) : d === 4 && e + 3 < c.length ? (i += s(c[e + 2]), n += s(c[e + 3]), o.push({ x: i / 10, y: n / 10, cmd: "jump" })) : d === 128 && o.push({ x: i / 10, y: n / 10, cmd: "trim" }), e += 4;
+      continue;
+    }
+    i += s(c[e]), n += s(c[e + 1]), o.push({ x: i / 10, y: n / 10, cmd: "stitch" }), e += 2;
+  }
+  return o.push({ x: i / 10, y: n / 10, cmd: "end" }), { stitches: o, colorChanges: t };
+}
+export {
+  f as readExp,
+  m as writeExp
+};

package/dist/embroidery/fill.js

@@ -0,0 +1,49 @@
+import { rotate as M } from "./geom.js";
+function b(r, l, c) {
+  const p = -l * Math.PI / 180, s = r.map((o) => o.map((e) => M(e, p))), n = s.flat().map((o) => o[1]), d = Math.min(...n), x = Math.max(...n), m = [];
+  for (let o = d + c / 2; o < x; o += c) {
+    const e = [];
+    for (const t of s)
+      for (let h = 0, u = t.length - 1; h < t.length; u = h++) {
+        const f = t[h], a = t[u];
+        f[1] > o != a[1] > o && e.push(f[0] + (o - f[1]) * (a[0] - f[0]) / (a[1] - f[1]));
+      }
+    e.sort((t, h) => t - h);
+    const i = [];
+    for (let t = 0; t + 1 < e.length; t += 2) e[t + 1] - e[t] > 0.3 && i.push({ x0: e[t], x1: e[t + 1], y: o, done: !1 });
+    m.push(i);
+  }
+  return m;
+}
+function k(r, l, c, p) {
+  const s = [r.x0];
+  for (let n = (Math.floor(r.x0 / c - p) + 1 + p) * c; n < r.x1; n += c) n - r.x0 > 0.7 && r.x1 - n > 0.7 && s.push(n);
+  return s.push(r.x1), l || s.reverse(), s.map((n) => [n, r.y]);
+}
+function I(r, l, c, p) {
+  const s = b(r, l, c), n = l * Math.PI / 180, d = [];
+  for (let x = 0; x < s.length; x++)
+    for (const m of s[x]) {
+      if (m.done) continue;
+      m.done = !0;
+      const o = [];
+      let e = m, i = !0;
+      for (let t = x; ; t++) {
+        o.push(...k(e, i, p, t % 3 / 3));
+        const h = o[o.length - 1][0];
+        let u, f = 8;
+        for (const a of s[t + 1] ?? []) {
+          if (a.done) continue;
+          const g = Math.abs((i ? a.x1 : a.x0) - h);
+          g < f && (f = g, u = a);
+        }
+        if (!u) break;
+        u.done = !0, e = u, i = !i;
+      }
+      d.push(o.map((t) => M(t, n)));
+    }
+  return d;
+}
+export {
+  I as tatami
+};

package/dist/embroidery/geom.js

@@ -0,0 +1,82 @@
+const M = (n, o) => Math.hypot(n[0] - o[0], n[1] - o[1]);
+function y(n, o, a, t = 96) {
+  return Array.from({ length: t }, (s, e) => [n + a * Math.cos(e / t * Math.PI * 2), o + a * Math.sin(e / t * Math.PI * 2)]);
+}
+function x(n, o, a, t, s, e = Math.PI / 2) {
+  const c = [];
+  for (let r = 0; r < s * 2; r++) {
+    const h = e + r * Math.PI / s, l = r % 2 ? a : t;
+    c.push([n + l * Math.cos(h), o + l * Math.sin(h)]);
+  }
+  return c;
+}
+function I(n, o, a, t, s, e, c = 16) {
+  return Array.from({ length: c + 1 }, (r, h) => {
+    const l = s + (e - s) * h / c;
+    return [n + a * Math.cos(l), o + t * Math.sin(l)];
+  });
+}
+function m(n) {
+  let o = 0;
+  for (let a = 0; a < n.length; a++) {
+    const t = n[a], s = n[(a + 1) % n.length];
+    o += t[0] * s[1] - s[0] * t[1];
+  }
+  return o / 2;
+}
+function P(n, o) {
+  const a = m(n) >= 0 ? 1 : -1, t = n.length, s = (e, c) => {
+    const r = M(e, c) || 1;
+    return [-(c[1] - e[1]) / r * a, (c[0] - e[0]) / r * a];
+  };
+  return n.map((e, c) => {
+    const r = s(n[(c + t - 1) % t], e), h = s(e, n[(c + 1) % t]), l = 1 + r[0] * h[0] + r[1] * h[1];
+    let u = r[0] + h[0], i = r[1] + h[1];
+    l < 0.2 ? (u = r[0], i = r[1]) : (u /= l, i /= l);
+    const f = Math.hypot(u, i), g = Math.min(1, 2.5 / (f || 1));
+    return [e[0] + u * o * g, e[1] + i * o * g];
+  });
+}
+function k(n, o) {
+  let a = !1;
+  for (const t of n)
+    for (let s = 0, e = t.length - 1; s < t.length; e = s++) {
+      const c = t[s], r = t[e];
+      c[1] > o[1] != r[1] > o[1] && o[0] < (r[0] - c[0]) * (o[1] - c[1]) / (r[1] - c[1]) + c[0] && (a = !a);
+    }
+  return a;
+}
+function d(n, o, a = !1) {
+  const t = a ? [...n, n[0]] : n, s = [t[0]];
+  for (let e = 1; e < t.length; e++) {
+    const c = t[e - 1], r = t[e], h = Math.max(1, Math.ceil(M(c, r) / o));
+    for (let l = 1; l <= h; l++) s.push([c[0] + (r[0] - c[0]) * l / h, c[1] + (r[1] - c[1]) * l / h]);
+  }
+  return s;
+}
+function A(n, o, a = !1) {
+  const t = a ? [...n, n[0]] : n, s = [0];
+  for (let l = 1; l < t.length; l++) s.push(s[l - 1] + M(t[l - 1], t[l]));
+  const e = s[s.length - 1], c = Math.max(1, Math.round(e / o)), r = [];
+  let h = 1;
+  for (let l = 0; l <= c; l++) {
+    const u = e * l / c;
+    for (; h < t.length - 1 && s[h] < u; ) h++;
+    const i = s[h] - s[h - 1] || 1, f = (u - s[h - 1]) / i;
+    r.push([t[h - 1][0] + (t[h][0] - t[h - 1][0]) * f, t[h - 1][1] + (t[h][1] - t[h - 1][1]) * f]);
+  }
+  return r;
+}
+const _ = (n, o) => [n[0] * Math.cos(o) - n[1] * Math.sin(o), n[0] * Math.sin(o) + n[1] * Math.cos(o)];
+export {
+  I as arc,
+  m as area,
+  y as circle,
+  M as dist,
+  A as evenly,
+  P as inset,
+  k as inside,
+  d as resample,
+  _ as rotate,
+  x as star
+};

package/dist/embroidery/pes.js

@@ -0,0 +1,79 @@
+import { toRecords as C } from "./units.js";
+const y = 48, M = 38;
+function A(e, w) {
+  const [l, i, x, c] = w, n = Math.min((y - 4) / Math.max(1, x - l), (M - 4) / Math.max(1, c - i)), d = (y - (x - l) * n) / 2 - l * n, o = (M - (c - i) * n) / 2 - i * n, f = new Uint8Array(y * M);
+  for (const [r, h, m, u] of e) {
+    const p = Math.max(1, Math.ceil(Math.hypot(m - r, u - h) * n));
+    for (let t = 0; t <= p; t++) {
+      const a = Math.round(d + (r + (m - r) * t / p) * n), g = Math.round(o + (h + (u - h) * t / p) * n);
+      a >= 0 && a < y && g >= 0 && g < M && (f[g * y + a] = 1);
+    }
+  }
+  const s = [];
+  for (let r = 0; r < M; r++)
+    for (let h = 0; h < y / 8; h++) s.push(Array.from({ length: 8 }, (m, u) => f[r * y + h * 8 + u] << 7 - u).reduce((m, u) => m | u, 0));
+  return s;
+}
+function b(e) {
+  const w = C(e, 2047), l = [], i = [[]];
+  let x = 2, c = 0, n = 0, d = !1;
+  const o = { x0: 0, y0: 0, x1: 0, y1: 0 }, f = (t, a) => l.push(128 | a | t >> 8 & 15, t & 255);
+  for (const t of w)
+    if (t.cmd === "color")
+      l.push(254, 176, x), x = x === 2 ? 1 : 2, i.push([]);
+    else if (t.cmd === "trim")
+      d = !0;
+    else if (t.cmd === "end")
+      l.push(255);
+    else {
+      const a = -t.dy;
+      if (t.cmd === "jump") {
+        const g = d ? 32 : 16;
+        f(t.dx & 4095, g), f(a & 4095, g);
+      } else t.dx >= -64 && t.dx <= 63 && a >= -64 && a <= 63 ? l.push(t.dx & 127, a & 127) : (f(t.dx & 4095, 0), f(a & 4095, 0));
+      t.cmd === "jump" ? d = !1 : i[i.length - 1].push([c, n, c + t.dx, n + a]), c += t.dx, n += a, o.x0 = Math.min(o.x0, c), o.x1 = Math.max(o.x1, c), o.y0 = Math.min(o.y0, n), o.y1 = Math.max(o.y1, n);
+    }
+  const s = [];
+  for (((t) => [...t].forEach((a) => s.push(a.charCodeAt(0))))(`LA:${e.name.slice(0, 16).padEnd(16, " ")}`), s.push(13), s.push(...Array(12).fill(32), 255, 0, 6, M, ...Array(12).fill(32)), s.push(e.threads.length - 1, ...e.threads.map((t) => t.pec ?? 20)); s.length < 464; ) s.push(32);
+  const h = s.length + 2, m = [o.x0, o.y0, o.x1, o.y1];
+  s.push(0, 0, 0, 0, 0), s.push(49, 255, 240);
+  const u = (t) => s.push(t & 255, t >> 8 & 255);
+  u(o.x1 - o.x0), u(o.y1 - o.y0), u(480), u(432), s.push((36864 | -o.x0) >> 8 & 255, (36864 | -o.x0) & 255, (36864 | -o.y0) >> 8 & 255, (36864 | -o.y0) & 255), s.push(...l);
+  const p = s.length - 464;
+  s[h] = p & 255, s[h + 1] = p >> 8 & 255, s[h + 2] = p >> 16 & 255, s.push(...A(i.flat(), m));
+  for (const t of i) s.push(...A(t, m));
+  return Uint8Array.from([..."#PES0001"].map((t) => t.charCodeAt(0)).concat([22, 0, 0, 0, 1, 0, 1, 0, 1, 0, 255, 255, 0, 0], s));
+}
+function v(e) {
+  const w = new DataView(e.buffer, e.byteOffset, e.byteLength);
+  if (String.fromCharCode(...e.subarray(0, 8)) !== "#PES0001") throw new Error("not a PES v1 file");
+  const l = w.getUint32(8, !0), i = String.fromCharCode(...e.subarray(l + 3, l + 19)).trim(), x = e[l + 48] + 1;
+  let c = l + 464 + 20;
+  const n = [];
+  let d = 0, o = 0, f = 0;
+  const s = () => {
+    const r = e[c];
+    if (r & 128) {
+      let h = (r & 15) << 8 | e[c + 1];
+      return h & 2048 && (h -= 4096), c += 2, { v: h, flag: r & 48 };
+    }
+    return c++, { v: r >= 64 ? r - 128 : r, flag: 0 };
+  };
+  for (; c < e.length; ) {
+    if (e[c] === 255) {
+      n.push({ x: o / 10, y: f / 10, cmd: "end" });
+      break;
+    }
+    if (e[c] === 254) {
+      d++, n.push({ x: o / 10, y: f / 10, cmd: "color" }), c += 3;
+      continue;
+    }
+    const r = s(), h = s();
+    o += r.v, f -= h.v, n.push({ x: o / 10, y: f / 10, cmd: r.flag ? "jump" : "stitch" });
+  }
+  return { stitches: n, colorChanges: d, threads: x, label: i };
+}
+export {
+  v as readPes,
+  b as writePes
+};

package/dist/embroidery/satin.js

@@ -0,0 +1,29 @@
+import { evenly as x } from "./geom.js";
+const l = 2;
+function k(a, s, r, c) {
+  const e = x(a, r, c), n = e.length;
+  return e.map((u, o) => {
+    const f = e[c ? (o + n - 1 - l) % (n - 1) : Math.max(0, o - l)], t = e[c ? (o + l) % (n - 1) : Math.min(n - 1, o + l)], h = Math.hypot(t[0] - f[0], t[1] - f[1]) || 1, m = -(t[1] - f[1]) / h * (s / 2), M = (t[0] - f[0]) / h * (s / 2);
+    return [
+      [u[0] + m, u[1] + M],
+      [u[0] - m, u[1] - M]
+    ];
+  });
+}
+function y(a, s, r, c, e, n) {
+  const u = k(a, s, r, c), o = (t, h) => [t[0][0] + (t[1][0] - t[0][0]) * (0.5 - h), t[0][1] + (t[1][1] - t[0][1]) * (0.5 - h)], f = [];
+  return u.forEach((t, h) => f.push(o(t, h % 2 ? n : e))), f;
+}
+function p(a, s, r, c, e) {
+  const n = Math.max(1, Math.ceil(s / e - 1e-9)), u = [];
+  for (let o = 0; o < n; o++) u.push(y(a, s, r, c, -0.5 + o / n, -0.5 + (o + 1) / n));
+  return u;
+}
+function O(a, s, r, c) {
+  const n = [x(a, r, c)];
+  return s > 2 && n.push(y(a, s - 0.8, r * 0.7, c, -0.5, 0.5)), n;
+}
+export {
+  p as satin,
+  O as satinUnderlay
+};

package/dist/embroidery/simulate.js

@@ -0,0 +1,30 @@
+const d = (x) => Math.max(0, Math.min(255, x));
+function E(x, c) {
+  const n = Math.round(c.size * c.pxPerMm), l = new Uint8Array(n * n * 3), p = c.backing ?? [214, 208, 196];
+  for (let t = 0; t < n; t++)
+    for (let o = 0; o < n; o++) {
+      const s = ((o >> 1) + (t >> 1) & 1) * 5 + (o * 7 + t * 13) % 5;
+      l.set([d(p[0] - s), d(p[1] - s), d(p[2] - s)], (t * n + o) * 3);
+    }
+  const h = (c.thread ?? 0.42) * c.pxPerMm / 2, [w, z] = c.center ?? [0, 0], k = (t) => (t - w + c.size / 2) * c.pxPerMm, j = (t) => (c.size / 2 - (t - z)) * c.pxPerMm;
+  let u = 0, a = 0, e = 0;
+  for (const t of x.stitches) {
+    if (t.cmd === "color" && u++, t.cmd !== "stitch" && t.cmd !== "jump") continue;
+    const o = k(t.x), s = j(t.y);
+    if (t.cmd === "stitch") {
+      const v = x.threads[u].rgb, A = Math.max(0, Math.floor(Math.min(a, o) - h - 1)), U = Math.min(n - 1, Math.ceil(Math.max(a, o) + h + 1)), q = Math.max(0, Math.floor(Math.min(e, s) - h - 1)), B = Math.min(n - 1, Math.ceil(Math.max(e, s) + h + 1)), f = o - a, y = s - e, C = f * f + y * y || 1;
+      for (let i = q; i <= B; i++)
+        for (let m = A; m <= U; m++) {
+          const b = Math.max(0, Math.min(1, ((m + 0.5 - a) * f + (i + 0.5 - e) * y) / C)), r = Math.hypot(m + 0.5 - (a + f * b), i + 0.5 - (e + y * b)) / h;
+          if (r > 1) continue;
+          const D = 1.18 - 0.55 * r * r, P = (i * n + m) * 3, g = r > 0.8 ? (1 - r) / 0.2 : 1;
+          for (let M = 0; M < 3; M++) l[P + M] = d(l[P + M] * (1 - g) + v[M] * D * g);
+        }
+    }
+    a = o, e = s;
+  }
+  return { w: n, h: n, rgb: l };
+}
+export {
+  E as simulate
+};