danceflow-geometry 1.0.0

package/dist/index.js

@@ -0,0 +1,985 @@
+function M(t) {
+  if (t.length === 0)
+    return { x: 0, y: 0 };
+  const n = t.reduce(
+    (r, e) => ({
+      x: r.x + e.x,
+      y: r.y + e.y
+    }),
+    { x: 0, y: 0 }
+  );
+  return {
+    x: n.x / t.length,
+    y: n.y / t.length
+  };
+}
+function rt(t, n, r) {
+  const e = r || M(t);
+  return t.map((c) => ({
+    x: e.x + (c.x - e.x) * n,
+    y: e.y + (c.y - e.y) * n,
+    facing: c.facing
+    // Facing doesn't change
+  }));
+}
+function ct(t, n) {
+  let r = !1;
+  for (let e = 0, c = n.length - 1; e < n.length; c = e++) {
+    const a = n[e].x, i = n[e].y, s = n[c].x, o = n[c].y;
+    i > t.y != o > t.y && t.x < (s - a) * (t.y - i) / (o - i) + a && (r = !r);
+  }
+  return r;
+}
+function at(t, n) {
+  const r = n.x - t.x, e = n.y - t.y;
+  return Math.sqrt(r * r + e * e);
+}
+function $(t, n, r, e, c = 0) {
+  if (t.length === 0) return [];
+  const a = e || M(t), i = c * Math.PI / 180, s = Math.cos(i), o = Math.sin(i);
+  return t.map((l) => {
+    let u = l.x - a.x, x = l.y - a.y;
+    if (c !== 0) {
+      const h = u * s - x * o, f = u * o + x * s;
+      u = h, x = f;
+    }
+    if (u *= n, x *= r, c !== 0) {
+      const h = u * s + x * o, f = -u * o + x * s;
+      u = h, x = f;
+    }
+    return {
+      x: u + a.x,
+      y: x + a.y,
+      facing: l.facing
+    };
+  });
+}
+function it(t, n) {
+  const { direction: r, scaleFactor: e, center: c, aspectRatio: a = 1, angle: i = 0 } = n;
+  let s, o, l;
+  switch (r) {
+    case "radial":
+      s = e, o = e, l = 0;
+      break;
+    case "horizontal":
+      s = e, o = 1, l = 0;
+      break;
+    case "vertical":
+      s = 1, o = e, l = 0;
+      break;
+    case "diagonal":
+      s = e, o = e, l = i || 45;
+      break;
+    default:
+      throw new Error(`Unknown spread direction: ${r}`);
+  }
+  return a !== 1 && (s *= a), $(t, s, o, c, l);
+}
+function st(t, n, r) {
+  if (t.length === 0) return 1;
+  const e = r || M(t), a = t.reduce((i, s) => {
+    const o = s.x - e.x, l = s.y - e.y;
+    return i + Math.sqrt(o * o + l * l);
+  }, 0) / t.length;
+  return a === 0 ? 1 : n / a;
+}
+function ot(t) {
+  if (t.length === 0)
+    return { minX: 0, maxX: 0, minY: 0, maxY: 0, width: 0, height: 0 };
+  let n = 1 / 0, r = -1 / 0, e = 1 / 0, c = -1 / 0;
+  return t.forEach((a) => {
+    n = Math.min(n, a.x), r = Math.max(r, a.x), e = Math.min(e, a.y), c = Math.max(c, a.y);
+  }), {
+    minX: n,
+    maxX: r,
+    minY: e,
+    maxY: c,
+    width: r - n,
+    height: c - e
+  };
+}
+function lt(t, n, r, e, c) {
+  if (t.length === 0) return !0;
+  const a = c || M(t);
+  return t.every((i) => {
+    const s = i.x - a.x, o = i.y - a.y, l = a.x + s * n, u = a.y + o * n, x = 20;
+    return l >= x && l <= r - x && u >= x && u <= e - x;
+  });
+}
+function E(t, n, r) {
+  if (t.length === 0)
+    throw new Error("Cannot arrange line with 0 dancers");
+  const e = M(t), a = (r || Math.max(400, t.length * 50)) / 2;
+  switch (n) {
+    case "horizontal":
+      return {
+        start: { x: e.x - a, y: e.y },
+        end: { x: e.x + a, y: e.y }
+      };
+    case "vertical":
+      return {
+        start: { x: e.x, y: e.y - a },
+        end: { x: e.x, y: e.y + a }
+      };
+    case "diagonal-45":
+      return {
+        start: {
+          x: e.x - a * Math.cos(Math.PI / 4),
+          y: e.y - a * Math.sin(Math.PI / 4)
+        },
+        end: {
+          x: e.x + a * Math.cos(Math.PI / 4),
+          y: e.y + a * Math.sin(Math.PI / 4)
+        }
+      };
+    case "diagonal-135":
+      return {
+        start: {
+          x: e.x - a * Math.cos(3 * Math.PI / 4),
+          y: e.y - a * Math.sin(3 * Math.PI / 4)
+        },
+        end: {
+          x: e.x + a * Math.cos(3 * Math.PI / 4),
+          y: e.y + a * Math.sin(3 * Math.PI / 4)
+        }
+      };
+    default:
+      throw new Error(`Unknown line orientation: ${n}`);
+  }
+}
+function T(t, n, r, e) {
+  if (typeof e == "number")
+    return e;
+  const c = Math.atan2(r.y, r.x) * (180 / Math.PI);
+  switch (e) {
+    case "auto":
+    case "forward":
+      return (c + 90) % 360;
+    case "backward":
+      return (c + 270) % 360;
+    case "center":
+      return t < n / 2 ? (c + 90) % 360 : (c + 270) % 360;
+    default:
+      return 0;
+  }
+}
+function N(t, n) {
+  const r = t.length;
+  if (r === 0)
+    return [];
+  const { orientation: e, spacing: c, startPoint: a, endPoint: i, faceDirection: s = "auto", lineLength: o } = n;
+  let l, u;
+  if (a && i)
+    l = a, u = i;
+  else if (c && r > 1) {
+    const h = c * (r - 1), f = M(t), g = h / 2, d = E(t, e, h), y = d.end.x - d.start.x, A = d.end.y - d.start.y, m = Math.sqrt(y * y + A * A);
+    if (m === 0)
+      throw new Error("Invalid line orientation");
+    const I = y / m * g, S = A / m * g;
+    l = { x: f.x - I, y: f.y - S }, u = { x: f.x + I, y: f.y + S };
+  } else {
+    const h = E(t, e, o);
+    l = h.start, u = h.end;
+  }
+  const x = {
+    x: u.x - l.x,
+    y: u.y - l.y
+  };
+  return r === 1 ? [
+    {
+      x: (l.x + u.x) / 2,
+      y: (l.y + u.y) / 2,
+      facing: T(0, 1, x, s)
+    }
+  ] : t.map((h, f) => {
+    const g = f / (r - 1), d = l.x + g * (u.x - l.x), y = l.y + g * (u.y - l.y);
+    return {
+      x: d,
+      y,
+      facing: T(f, r, x, s)
+    };
+  });
+}
+function ut(t, n, r = !1) {
+  const e = n.x - t.x, c = n.y - t.y, i = (Math.atan2(c, e) * (180 / Math.PI) % 360 + 360) % 360;
+  let s, o = t, l = n;
+  if (r)
+    if (i >= 337.5 || i < 22.5) {
+      s = "horizontal";
+      const u = (t.y + n.y) / 2;
+      o = { x: t.x, y: u }, l = { x: n.x, y: u };
+    } else if (i >= 22.5 && i < 67.5)
+      s = "diagonal-45";
+    else if (i >= 67.5 && i < 112.5) {
+      s = "vertical";
+      const u = (t.x + n.x) / 2;
+      o = { x: u, y: t.y }, l = { x: u, y: n.y };
+    } else if (i >= 112.5 && i < 157.5)
+      s = "diagonal-135";
+    else if (i >= 157.5 && i < 202.5) {
+      s = "horizontal";
+      const u = (t.y + n.y) / 2;
+      o = { x: t.x, y: u }, l = { x: n.x, y: u };
+    } else if (i >= 202.5 && i < 247.5)
+      s = "diagonal-45";
+    else if (i >= 247.5 && i < 292.5) {
+      s = "vertical";
+      const u = (t.x + n.x) / 2;
+      o = { x: u, y: t.y }, l = { x: u, y: n.y };
+    } else
+      s = "diagonal-135";
+  else
+    Math.abs(e) > Math.abs(c) * 2 ? s = "horizontal" : Math.abs(c) > Math.abs(e) * 2 ? s = "vertical" : e * c > 0 ? s = "diagonal-45" : s = "diagonal-135";
+  return {
+    orientation: s,
+    start: o,
+    end: l
+  };
+}
+function xt(t, n, r = 1e3, e = 1e3, c = 20) {
+  return t.length === 0 ? !0 : N(t, n).every(
+    (i) => i.x >= c && i.x <= r - c && i.y >= c && i.y <= e - c
+  );
+}
+function C(t) {
+  return t * Math.PI / 180;
+}
+function w(t) {
+  return t * 180 / Math.PI;
+}
+function _(t) {
+  switch (t) {
+    case "full":
+      return 360;
+    case "half":
+      return 180;
+    case "quarter":
+      return 90;
+    case "three-quarter":
+      return 270;
+    case "custom":
+      return 180;
+    // Default for custom
+    default:
+      return 360;
+  }
+}
+function O(t, n, r, e) {
+  if (typeof e == "number")
+    return e;
+  switch (e) {
+    case "center": {
+      const c = n.x - t.x, a = n.y - t.y, i = Math.atan2(-a, c);
+      return ((w(i) + 90) % 360 + 360) % 360;
+    }
+    case "outward": {
+      const c = t.x - n.x, a = t.y - n.y, i = Math.atan2(-a, c);
+      return ((w(i) + 90) % 360 + 360) % 360;
+    }
+    case "tangent": {
+      const c = r + Math.PI / 2;
+      return ((w(c) + 90) % 360 + 360) % 360;
+    }
+    case "counter-tangent": {
+      const c = r - Math.PI / 2;
+      return ((w(c) + 90) % 360 + 360) % 360;
+    }
+    default:
+      return 0;
+  }
+}
+function U(t, n, r = 1e3, e = 1e3, c = 50) {
+  const a = Math.min(t.x - c, r - t.x - c), i = Math.min(t.y - c, e - t.y - c), s = Math.min(a, i), l = n * 40 / (2 * Math.PI);
+  return Math.min(s, l, 400);
+}
+function P(t, n = {}) {
+  const r = t.length;
+  if (r === 0)
+    return [];
+  const {
+    preset: e = "full",
+    arcAngle: c,
+    startAngle: a = 0,
+    radius: i,
+    center: s,
+    faceDirection: o = "center",
+    distributeEvenly: l = !0
+  } = n, u = s || M(t), x = c !== void 0 ? c : _(e), h = i !== void 0 ? i : U(u, r);
+  if (h <= 0)
+    throw new Error("Circle radius must be positive");
+  const f = C(a - 90), g = Math.abs(x % 360) < 1e-3;
+  let d;
+  if (r === 1)
+    d = [f];
+  else if (g) {
+    const y = 2 * Math.PI / r;
+    d = Array.from({ length: r }, (A, m) => f + m * y);
+  } else if (l) {
+    const y = C(x);
+    d = Array.from({ length: r }, (A, m) => {
+      const I = m / (r - 1);
+      return f + I * y;
+    });
+  } else {
+    const A = C(x) / r;
+    d = Array.from({ length: r }, (m, I) => f + I * A);
+  }
+  return d.map((y) => {
+    const A = u.x + h * Math.cos(y), m = u.y + h * Math.sin(y);
+    return {
+      x: A,
+      y: m,
+      facing: O({ x: A, y: m }, u, y, o)
+    };
+  });
+}
+function ht(t, n) {
+  const r = t.length;
+  if (r === 0)
+    return [];
+  const {
+    rings: e,
+    radiusStep: c = 100,
+    innerRadius: a = 150,
+    center: i,
+    faceDirection: s = "center"
+  } = n;
+  if (e < 1)
+    throw new Error("Must have at least 1 ring");
+  const o = i || M(t), l = Math.ceil(r / e), u = [];
+  let x = 0;
+  for (let h = 0; h < e && x < r; h++) {
+    const f = a + h * c, g = Math.min(l, r - x), d = Array.from({ length: g }, () => ({
+      x: 0,
+      y: 0,
+      facing: 0
+    })), y = P(d, {
+      preset: "full",
+      radius: f,
+      center: o,
+      faceDirection: s
+    });
+    u.push(...y), x += g;
+  }
+  return u;
+}
+function ft(t, n, r = 1e3, e = 1e3, c = 20) {
+  return t.length === 0 ? !0 : P(t, n).every(
+    (i) => i.x >= c && i.x <= r - c && i.y >= c && i.y <= e - c
+  );
+}
+function yt(t, n, r) {
+  const e = t.x, c = t.y, a = n.x, i = n.y, s = r.x, o = r.y, l = 2 * (e * (i - o) + a * (o - c) + s * (c - i));
+  if (Math.abs(l) < 1e-3)
+    return null;
+  const u = ((e * e + c * c) * (i - o) + (a * a + i * i) * (o - c) + (s * s + o * o) * (c - i)) / l, x = ((e * e + c * c) * (s - a) + (a * a + i * i) * (e - s) + (s * s + o * o) * (a - e)) / l, h = { x: u, y: x }, f = t.x - h.x, g = t.y - h.y, d = Math.sqrt(f * f + g * g), y = Math.atan2(-(t.y - h.y), t.x - h.x);
+  let m = Math.atan2(-(r.y - h.y), r.x - h.x) - y;
+  m < 0 && (m += 2 * Math.PI);
+  const I = (w(y) + 90 + 360) % 360, S = w(m);
+  return {
+    center: h,
+    radius: d,
+    startAngle: I,
+    arcAngle: S
+  };
+}
+function H(t) {
+  return (360 - t) % 360;
+}
+function K(t) {
+  return (180 - t + 360) % 360;
+}
+function b(t, n) {
+  if (t.length === 0)
+    return [];
+  const { axis: e, axisPosition: c, center: a, mirrorFacing: i = !0 } = n;
+  let s;
+  if (c !== void 0)
+    s = c;
+  else if (a)
+    s = e === "horizontal" ? a.x : a.y;
+  else {
+    const o = M(t);
+    s = e === "horizontal" ? o.x : o.y;
+  }
+  return t.map((o) => {
+    let l = o.x, u = o.y, x = o.facing;
+    return e === "horizontal" ? (l = 2 * s - o.x, i && (x = H(o.facing))) : (u = 2 * s - o.y, i && (x = K(o.facing))), {
+      x: l,
+      y: u,
+      facing: x
+    };
+  });
+}
+function dt(t, n) {
+  const r = b(t, n);
+  return [...t, ...r];
+}
+function V(t, n, r = !0) {
+  if (t.length === 0)
+    return [];
+  const c = n || M(t);
+  return t.map((a) => {
+    const i = 2 * c.x - a.x, s = 2 * c.y - a.y, o = r ? (a.facing + 180) % 360 : a.facing;
+    return {
+      x: i,
+      y: s,
+      facing: o
+    };
+  });
+}
+function gt(t, n) {
+  const r = n || M(t), e = t, c = b(t, {
+    axis: "horizontal",
+    center: r
+  }), a = b(t, {
+    axis: "vertical",
+    center: r
+  }), i = V(t, r);
+  return [...e, ...c, ...a, ...i];
+}
+function mt(t, n, r = 1e3, e = 1e3, c = 20) {
+  return t.length === 0 ? !0 : b(t, n).every(
+    (i) => i.x >= c && i.x <= r - c && i.y >= c && i.y <= e - c
+  );
+}
+function Mt(t, n) {
+  const r = Math.abs(n.x - t.x), e = Math.abs(n.y - t.y);
+  return r < e ? {
+    axis: "horizontal",
+    axisPosition: (t.x + n.x) / 2
+  } : {
+    axis: "vertical",
+    axisPosition: (t.y + n.y) / 2
+  };
+}
+function At(t, n, r = 10) {
+  const e = [], c = /* @__PURE__ */ new Set();
+  for (let a = 0; a < t.length; a++) {
+    if (c.has(a)) continue;
+    const i = b([t[a]], n)[0];
+    for (let s = a + 1; s < t.length; s++) {
+      if (c.has(s)) continue;
+      const o = t[s].x - i.x, l = t[s].y - i.y;
+      if (Math.sqrt(o * o + l * l) < r) {
+        e.push([a, s]), c.add(a), c.add(s);
+        break;
+      }
+    }
+  }
+  return e;
+}
+function G(t) {
+  return t * Math.PI / 180;
+}
+function J(t) {
+  return (t % 360 + 360) % 360;
+}
+function Q(t, n, r) {
+  const e = Math.cos(r), c = Math.sin(r), a = t.x - n.x, i = t.y - n.y;
+  return {
+    x: n.x + a * e - i * c,
+    // Negate the Y rotation to account for Y-down coordinate system
+    y: n.y - (a * c - i * e)
+  };
+}
+function Y(t, n) {
+  if (t.length === 0)
+    return [];
+  const { angle: e, center: c, rotateFacing: a = !0 } = n, i = c || M(t), s = G(e);
+  return t.map((o) => {
+    const l = Q({ x: o.x, y: o.y }, i, s);
+    return {
+      x: l.x,
+      y: l.y,
+      facing: a ? J(o.facing + e) : o.facing
+    };
+  });
+}
+function It(t, n, r) {
+  return Y(t, {
+    angle: n,
+    center: r
+  });
+}
+function wt(t, n, r) {
+  if (n < 1)
+    throw new Error("Number of copies must be at least 1");
+  if (t.length === 0)
+    return [];
+  const e = r || M(t), c = 360 / n, a = [];
+  for (let i = 0; i < n; i++) {
+    const s = i * c, o = Y(t, {
+      angle: s,
+      center: e
+    });
+    a.push(...o);
+  }
+  return a;
+}
+function Rt(t, n, r, e, c) {
+  if (e < 2)
+    throw new Error("Animation requires at least 2 steps");
+  const a = c || M(t), i = [];
+  for (let s = 0; s < e; s++) {
+    const o = s / (e - 1), l = n + o * (r - n), u = Y(t, {
+      angle: l,
+      center: a
+    });
+    i.push(u);
+  }
+  return i;
+}
+function bt(t, n, r) {
+  const e = Math.atan2(-(n.y - t.y), n.x - t.x);
+  let a = Math.atan2(-(r.y - t.y), r.x - t.x) - e;
+  return a > Math.PI ? a -= 2 * Math.PI : a < -Math.PI && (a += 2 * Math.PI), a * 180 / Math.PI;
+}
+function St(t, n = 45) {
+  return Math.round(t / n) * n;
+}
+function Xt(t, n, r = 1e3, e = 1e3, c = 20) {
+  return t.length === 0 ? !0 : Y(t, n).every(
+    (i) => i.x >= c && i.x <= r - c && i.y >= c && i.y <= e - c
+  );
+}
+function Yt(t) {
+  if (t.length === 0) return 0;
+  let n = 1 / 0, r = -1 / 0, e = 1 / 0, c = -1 / 0;
+  t.forEach((s) => {
+    n = Math.min(n, s.x), r = Math.max(r, s.x), e = Math.min(e, s.y), c = Math.max(c, s.y);
+  });
+  const a = r - n, i = c - e;
+  return Math.sqrt(a * a + i * i);
+}
+function Ct(t, n = 1e3, r = 1e3, e = 20) {
+  const c = t.x - e, a = n - t.x - e, i = t.y - e, s = r - t.y - e;
+  return Math.min(c, a, i, s);
+}
+function j(t) {
+  if (t.length < 2)
+    return { minX: 0, maxX: 0, minY: 0, maxY: 0 };
+  let n = 1 / 0, r = -1 / 0, e = 1 / 0, c = -1 / 0;
+  for (let a = 0; a < t.length; a += 2) {
+    const i = t[a], s = t[a + 1];
+    n = Math.min(n, i), r = Math.max(r, i), e = Math.min(e, s), c = Math.max(c, s);
+  }
+  return { minX: n, maxX: r, minY: e, maxY: c };
+}
+function vt(t, n) {
+  if (n.length < 6) return !1;
+  let r = !1;
+  const e = n.length / 2;
+  for (let c = 0, a = e - 1; c < e; a = c++) {
+    const i = n[c * 2], s = n[c * 2 + 1], o = n[a * 2], l = n[a * 2 + 1];
+    s > t.y != l > t.y && t.x < (o - i) * (t.y - s) / (l - s) + i && (r = !r);
+  }
+  return r;
+}
+function W(t, n, r) {
+  if (n.length < 6) return !1;
+  const e = r || j(n);
+  if (t.x < e.minX || t.x > e.maxX || t.y < e.minY || t.y > e.maxY)
+    return !1;
+  let c = !1;
+  const a = n.length / 2;
+  for (let i = 0, s = a - 1; i < a; s = i++) {
+    const o = n[i * 2], l = n[i * 2 + 1], u = n[s * 2], x = n[s * 2 + 1];
+    if (l === x) continue;
+    l > t.y != x > t.y && t.x < (u - o) * (t.y - l) / (x - l) + o && (c = !c);
+  }
+  return c;
+}
+function zt(t, n) {
+  if (n.length < 6)
+    return t.map(() => !1);
+  const r = j(n);
+  return t.map((e) => W(e, n, r));
+}
+function Et(t) {
+  if (t.length < 6) return 0;
+  let n = 0;
+  const r = t.length / 2;
+  for (let e = 0; e < r; e++) {
+    const c = (e + 1) % r, a = t[e * 2], i = t[e * 2 + 1], s = t[c * 2], o = t[c * 2 + 1];
+    n += a * o - s * i;
+  }
+  return n / 2;
+}
+function Tt(t) {
+  if (t.length < 6)
+    return { x: 0, y: 0 };
+  let n = 0, r = 0, e = 0;
+  const c = t.length / 2;
+  for (let a = 0; a < c; a++) {
+    const i = (a + 1) % c, s = t[a * 2], o = t[a * 2 + 1], l = t[i * 2], u = t[i * 2 + 1], x = s * u - l * o;
+    n += (s + l) * x, r += (o + u) * x, e += x;
+  }
+  if (e /= 2, Math.abs(e) < 1e-4) {
+    let a = 0, i = 0;
+    for (let s = 0; s < t.length; s += 2)
+      a += t[s], i += t[s + 1];
+    return { x: a / c, y: i / c };
+  }
+  return {
+    x: n / (6 * e),
+    y: r / (6 * e)
+  };
+}
+function Pt(t, n) {
+  if (t.length < 6) return [...t];
+  const r = [];
+  r.push(t[0], t[1]);
+  for (let e = 2; e < t.length; e += 2) {
+    const c = r[r.length - 2], a = r[r.length - 1], i = t[e], s = t[e + 1], o = i - c, l = s - a;
+    Math.sqrt(o * o + l * l) >= n && r.push(i, s);
+  }
+  return r;
+}
+const v = 80, F = 20;
+function L(t, n, r, e, c) {
+  const a = t * t, i = a * t, s = 1 - t, o = s * s, u = o * s, x = 3 * o * t, h = 3 * s * a, f = i;
+  return {
+    x: u * n.x + x * r.x + h * e.x + f * c.x,
+    y: u * n.y + x * r.y + h * e.y + f * c.y
+  };
+}
+function D(t, n, r) {
+  const e = (t.x + n.x) / 2, c = (t.y + n.y) / 2, a = n.x - t.x, s = -(n.y - t.y), o = a, l = Math.sqrt(s * s + o * o);
+  if (l < 1e-4) {
+    const y = { x: e, y: c };
+    return [y, y];
+  }
+  const u = s / l, x = o / l, h = -u * r, f = -x * r, g = {
+    x: e + h,
+    y: c + f
+  }, d = {
+    x: e + h,
+    y: c + f
+  };
+  return [g, d];
+}
+function Z(t, n, r = v, e = F) {
+  if (e < 2)
+    throw new Error("Number of interpolation points must be at least 2");
+  const [c, a] = D(t, n, r), i = [];
+  for (let s = 0; s < e; s++) {
+    const o = s / (e - 1), l = L(
+      o,
+      { x: t.x, y: t.y },
+      // P0 - start
+      c,
+      // P1 - first control point
+      a,
+      // P2 - second control point
+      { x: n.x, y: n.y }
+      // P3 - end
+    );
+    i.push(l);
+  }
+  return i;
+}
+function jt(t, n, r = 150) {
+  const e = n.x - t.x, c = n.y - t.y, i = Math.sqrt(e * e + c * c) * 0.15;
+  return Math.min(i, r);
+}
+function Ft(t, n, r = v, e = F) {
+  const c = Z(t, n, r, e);
+  let a = 0;
+  for (let i = 1; i < c.length; i++) {
+    const s = c[i].x - c[i - 1].x, o = c[i].y - c[i - 1].y;
+    a += Math.sqrt(s * s + o * o);
+  }
+  return a;
+}
+function Lt(t, n, r, e = v) {
+  const c = Math.max(0, Math.min(1, r)), [a, i] = D(t, n, e);
+  return L(
+    c,
+    { x: t.x, y: t.y },
+    a,
+    i,
+    { x: n.x, y: n.y }
+  );
+}
+function z(t, n, r, e, c) {
+  const a = c * c, i = a * c, s = 0.5 * (2 * n.x + (-t.x + r.x) * c + (2 * t.x - 5 * n.x + 4 * r.x - e.x) * a + (-t.x + 3 * n.x - 3 * r.x + e.x) * i), o = 0.5 * (2 * n.y + (-t.y + r.y) * c + (2 * t.y - 5 * n.y + 4 * r.y - e.y) * a + (-t.y + 3 * n.y - 3 * r.y + e.y) * i);
+  return { x: s, y: o };
+}
+function Dt(t, n = 20) {
+  if (t.length < 2)
+    return [...t];
+  if (t.length === 2)
+    return [t[0], t[1]];
+  const r = [];
+  for (let e = 0; e < t.length - 1; e++) {
+    const c = e === 0 ? t[0] : t[e - 1], a = t[e], i = t[e + 1], s = e === t.length - 2 ? t[e + 1] : t[e + 2];
+    for (let o = 0; o < n; o++) {
+      const l = o / n, u = z(c, a, i, s, l);
+      r.push(u);
+    }
+  }
+  return r.push(t[t.length - 1]), r;
+}
+function p(t, n, r, e) {
+  const c = {
+    x: n.x + (r.x - t.x) / 6,
+    y: n.y + (r.y - t.y) / 6
+  }, a = {
+    x: r.x - (e.x - n.x) / 6,
+    y: r.y - (e.y - n.y) / 6
+  };
+  return {
+    start: n,
+    control1: c,
+    control2: a,
+    end: r
+  };
+}
+function qt(t) {
+  if (t.length < 2)
+    return [];
+  const n = [];
+  for (let r = 0; r < t.length - 1; r++) {
+    const e = r === 0 ? t[0] : t[r - 1], c = t[r], a = t[r + 1], i = r === t.length - 2 ? t[r + 1] : t[r + 2];
+    n.push(p(e, c, a, i));
+  }
+  return n;
+}
+function tt(t, n, r, e, c) {
+  const a = c * c, i = 0.5 * (-t.x + r.x + 2 * (2 * t.x - 5 * n.x + 4 * r.x - e.x) * c + 3 * (-t.x + 3 * n.x - 3 * r.x + e.x) * a), s = 0.5 * (-t.y + r.y + 2 * (2 * t.y - 5 * n.y + 4 * r.y - e.y) * c + 3 * (-t.y + 3 * n.y - 3 * r.y + e.y) * a);
+  return { x: i, y: s };
+}
+function Bt(t, n, r, e, c) {
+  const a = tt(t, n, r, e, c);
+  return Math.atan2(a.y, a.x) * 180 / Math.PI;
+}
+function kt(t, n, r, e, c = 100) {
+  let a = 0, i = n;
+  for (let s = 1; s <= c; s++) {
+    const o = s / c, l = z(t, n, r, e, o), u = l.x - i.x, x = l.y - i.y;
+    a += Math.sqrt(u * u + x * x), i = l;
+  }
+  return a;
+}
+function $t(t, n) {
+  if (t.length < 2)
+    return [...t];
+  const r = [t[0]];
+  let e = 0, c = n;
+  for (let a = 0; a < t.length - 1; a++) {
+    const i = a === 0 ? t[0] : t[a - 1], s = t[a], o = t[a + 1], l = a === t.length - 2 ? t[a + 1] : t[a + 2];
+    let u = s;
+    const x = 100;
+    for (let h = 1; h <= x; h++) {
+      const f = h / x, g = z(i, s, o, l, f), d = g.x - u.x, y = g.y - u.y, A = Math.sqrt(d * d + y * y);
+      e += A, e >= c && (r.push(g), c += n), u = g;
+    }
+  }
+  return r;
+}
+const R = 20;
+function X(t, n = R) {
+  return {
+    minX: t.x - n,
+    maxX: t.x + n,
+    minY: t.y - n,
+    maxY: t.y + n
+  };
+}
+function q(t, n) {
+  return t.maxX >= n.minX && t.minX <= n.maxX && t.maxY >= n.minY && t.minY <= n.maxY;
+}
+function B(t, n, r = R, e = R) {
+  const c = n.x - t.x, a = n.y - t.y, i = c * c + a * a, s = r + e;
+  return i < s * s;
+}
+function k(t, n) {
+  const r = n.x - t.x, e = n.y - t.y;
+  return Math.sqrt(r * r + e * e);
+}
+function nt(t, n = R) {
+  const r = [];
+  for (let e = 0; e < t.length; e++)
+    for (let c = e + 1; c < t.length; c++) {
+      const a = t[e], i = t[c], s = X(a.position, n), o = X(i.position, n);
+      if (q(s, o) && B(a.position, i.position, n, n)) {
+        const l = k(a.position, i.position), u = n * 2 - l;
+        r.push({
+          id1: a.id,
+          id2: i.id,
+          distance: l,
+          penetration: u
+        });
+      }
+    }
+  return r;
+}
+class et {
+  /**
+   * Create a new spatial hash grid
+   *
+   * @param radius - Dancer radius (default: 20)
+   * @param cellSize - Grid cell size (default: 2 * radius = 40)
+   */
+  constructor(n = R, r) {
+    this.radius = n, this.cellSize = r || n * 2, this.grid = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Compute hash key for a position
+   *
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @returns Grid cell key
+   */
+  hashKey(n, r) {
+    const e = Math.floor(n / this.cellSize), c = Math.floor(r / this.cellSize);
+    return `${e},${c}`;
+  }
+  /**
+   * Insert a dancer into the spatial grid
+   *
+   * @param id - Dancer ID
+   * @param position - Dancer position
+   */
+  insert(n, r) {
+    const e = this.hashKey(r.x, r.y);
+    this.grid.has(e) || this.grid.set(e, []), this.grid.get(e).push({ id: n, position: r });
+  }
+  /**
+   * Get all dancers in the same or adjacent cells
+   *
+   * @param position - Query position
+   * @returns Array of nearby dancers
+   */
+  getNearby(n) {
+    const r = [], e = Math.floor(n.x / this.cellSize), c = Math.floor(n.y / this.cellSize);
+    for (let a = -1; a <= 1; a++)
+      for (let i = -1; i <= 1; i++) {
+        const s = `${e + a},${c + i}`, o = this.grid.get(s);
+        o && r.push(...o);
+      }
+    return r;
+  }
+  /**
+   * Clear all entries from the grid
+   */
+  clear() {
+    this.grid.clear();
+  }
+  /**
+   * Detect all collisions using spatial hashing
+   *
+   * @param dancers - Array of dancer IDs and positions
+   * @returns Array of collision pairs
+   */
+  detectCollisions(n) {
+    this.clear(), n.forEach((c) => this.insert(c.id, c.position));
+    const r = [], e = /* @__PURE__ */ new Set();
+    return n.forEach((c) => {
+      this.getNearby(c.position).forEach((i) => {
+        if (c.id === i.id) return;
+        const s = c.id < i.id ? `${c.id}:${i.id}` : `${i.id}:${c.id}`;
+        if (e.has(s)) return;
+        e.add(s);
+        const o = X(c.position, this.radius), l = X(i.position, this.radius);
+        if (q(o, l) && B(c.position, i.position, this.radius, this.radius)) {
+          const u = k(c.position, i.position), x = this.radius * 2 - u;
+          r.push({
+            id1: c.id,
+            id2: i.id,
+            distance: u,
+            penetration: x
+          });
+        }
+      });
+    }), r;
+  }
+  /**
+   * Get statistics about the grid (for debugging/optimization)
+   *
+   * @returns Grid statistics
+   */
+  getStats() {
+    const n = this.grid.size;
+    let r = 0, e = 0;
+    return this.grid.forEach((c) => {
+      r += c.length, e = Math.max(e, c.length);
+    }), {
+      totalCells: this.grid.size * 9,
+      // Account for neighbor checks
+      occupiedCells: n,
+      totalDancers: r,
+      avgDancersPerCell: n > 0 ? r / n : 0,
+      maxDancersInCell: e
+    };
+  }
+}
+function Nt(t, n = R) {
+  return t.length < 50 ? nt(t, n) : new et(n).detectCollisions(t);
+}
+const _t = "1.0.0";
+export {
+  R as DANCER_RADIUS,
+  et as SpatialHashGrid,
+  _t as VERSION,
+  Rt as animateRotation,
+  P as arrangeInCircle,
+  ht as arrangeInConcentricCircles,
+  N as arrangeInLine,
+  zt as batchPointInPolygon,
+  D as calculateArcControlPoints,
+  yt as calculateArcFromThreePoints,
+  Ft as calculateArcLength,
+  M as calculateCentroid,
+  k as calculateDistance,
+  ut as calculateLineFromDrag,
+  Mt as calculateMirrorAxisFromDrag,
+  jt as calculateOptimalArcHeight,
+  bt as calculateRotationFromDrag,
+  st as calculateSpreadFactorForDistance,
+  Z as calculateSwapArcPath,
+  Bt as catmullRomAngle,
+  kt as catmullRomArcLength,
+  z as catmullRomPoint,
+  Dt as catmullRomSpline,
+  qt as catmullRomSplineToBezier,
+  tt as catmullRomTangent,
+  p as catmullRomToBezier,
+  $t as catmullRomUniformSample,
+  q as checkAABBOverlap,
+  B as checkCircleCollision,
+  j as computeBoundingBox,
+  X as createAABB,
+  gt as createKaleidoscope,
+  wt as createRotationalCopies,
+  L as cubicBezier,
+  nt as detectCollisions,
+  Nt as detectCollisionsAuto,
+  it as directionalSpread,
+  at as distance,
+  $ as ellipticalScale,
+  At as findSymmetricPairs,
+  Lt as getArcPositionAtTime,
+  ot as getBoundingBox,
+  Yt as getBoundingBoxDiagonal,
+  Ct as getMaxRotationRadius,
+  ft as isCircleArrangementSafe,
+  xt as isLineArrangementSafe,
+  mt as isMirrorSafe,
+  vt as isPointInPolygon,
+  W as isPointInPolygonOptimized,
+  Xt as isRotationSafe,
+  lt as isSpreadSafe,
+  dt as mirrorAndDuplicate,
+  V as mirrorBothAxes,
+  b as mirrorFormation,
+  ct as pointInPolygon,
+  Et as polygonArea,
+  Tt as polygonCentroid,
+  Y as rotateFormation,
+  It as rotateFormationPreset,
+  rt as scaleAroundCenter,
+  Pt as simplifyPolygon,
+  St as snapRotationAngle
+};