@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/maths/fn/vector.mjs

@@ -1 +1,707 @@
-function u(r,t){if(typeof r!="number"||!Number.isFinite(r))throw new Error(`${t} must be a finite number, got ${r}`)}function y(r){return Math.abs(r)<1e-9}function m(r,t){return Math.abs(r-t)<1e-6}function n(r,t="Vector2D"){if(!r||typeof r!="object")throw new Error(`${t} must be an object`);u(r.x,`${t}.x`),u(r.y,`${t}.y`)}function x(r,t="Vector3D"){if(!r||typeof r!="object")throw new Error(`${t} must be an object`);u(r.x,`${t}.x`),u(r.y,`${t}.y`),u(r.z,`${t}.z`)}function i(r,t="Vector4D"){if(!r||typeof r!="object")throw new Error(`${t} must be an object`);u(r.x,`${t}.x`),u(r.y,`${t}.y`),u(r.z,`${t}.z`),u(r.w,`${t}.w`)}function $(r,t){return u(r,"x"),u(t,"y"),{x:r,y:t}}function C(r,t,e){return u(r,"x"),u(t,"y"),u(e,"z"),{x:r,y:t,z:e}}function j(r,t,e,o){return u(r,"x"),u(t,"y"),u(e,"z"),u(o,"w"),{x:r,y:t,z:e,w:o}}function d(r){n(r);let t=Math.sqrt(r.x*r.x+r.y*r.y);return y(t)?0:t}function M(r){return n(r),r.x*r.x+r.y*r.y}function p(r){x(r);let t=Math.sqrt(r.x*r.x+r.y*r.y+r.z*r.z);return y(t)?0:t}function B(r){return x(r),r.x*r.x+r.y*r.y+r.z*r.z}function g(r){i(r);let t=Math.sqrt(r.x*r.x+r.y*r.y+r.z*r.z+r.w*r.w);return y(t)?0:t}function N(r){return i(r),r.x*r.x+r.y*r.y+r.z*r.z+r.w*r.w}function P(r){n(r);let t=d(r);if(y(t))throw new Error("Cannot normalize zero or near-zero vector");return{x:r.x/t,y:r.y/t}}function A(r){n(r);let t=d(r);return y(t)?{x:0,y:0}:{x:r.x/t,y:r.y/t}}function E(r){x(r);let t=p(r);if(y(t))throw new Error("Cannot normalize zero or near-zero vector");return{x:r.x/t,y:r.y/t,z:r.z/t}}function R(r){x(r);let t=p(r);return y(t)?{x:0,y:0,z:0}:{x:r.x/t,y:r.y/t,z:r.z/t}}function X(r){i(r);let t=g(r);if(y(t))throw new Error("Cannot normalize zero or near-zero vector");return{x:r.x/t,y:r.y/t,z:r.z/t,w:r.w/t}}function Y(r){i(r);let t=g(r);return y(t)?{x:0,y:0,z:0,w:0}:{x:r.x/t,y:r.y/t,z:r.z/t,w:r.w/t}}function a(r,t){return n(r,"First vector"),n(t,"Second vector"),r.x*t.x+r.y*t.y}function S(r,t){return x(r,"First vector"),x(t,"Second vector"),r.x*t.x+r.y*t.y+r.z*t.z}function Z(r,t){return i(r,"First vector"),i(t,"Second vector"),r.x*t.x+r.y*t.y+r.z*t.z+r.w*t.w}function I(r,t){return x(r,"First vector"),x(t,"Second vector"),{x:r.y*t.z-r.z*t.y,y:r.z*t.x-r.x*t.z,z:r.x*t.y-r.y*t.x}}function L(r,t){return n(r,"First vector"),n(t,"Second vector"),{x:r.x+t.x,y:r.y+t.y}}function F(r,t){return x(r,"First vector"),x(t,"Second vector"),{x:r.x+t.x,y:r.y+t.y,z:r.z+t.z}}function k(r,t){return i(r,"First vector"),i(t,"Second vector"),{x:r.x+t.x,y:r.y+t.y,z:r.z+t.z,w:r.w+t.w}}function G(r,t){return n(r,"First vector"),n(t,"Second vector"),{x:r.x-t.x,y:r.y-t.y}}function H(r,t){return x(r,"First vector"),x(t,"Second vector"),{x:r.x-t.x,y:r.y-t.y,z:r.z-t.z}}function J(r,t){return i(r,"First vector"),i(t,"Second vector"),{x:r.x-t.x,y:r.y-t.y,z:r.z-t.z,w:r.w-t.w}}function K(r,t){return n(r),u(t,"scalar"),{x:r.x*t,y:r.y*t}}function l(r,t){return x(r),u(t,"scalar"),{x:r.x*t,y:r.y*t,z:r.z*t}}function O(r,t){return i(r),u(t,"scalar"),{x:r.x*t,y:r.y*t,z:r.z*t,w:r.w*t}}function b(r,t){n(r,"First vector"),n(t,"Second vector");let e=a(r,t),o=d(r),c=d(t);if(y(o)||y(c))throw new Error("Cannot calculate angle with zero or near-zero vector");let D=Math.max(-1,Math.min(1,e/(o*c)));return Math.acos(D)}function Q(r,t){x(r,"First vector"),x(t,"Second vector");let e=S(r,t),o=p(r),c=p(t);if(y(o)||y(c))throw new Error("Cannot calculate angle with zero or near-zero vector");let D=Math.max(-1,Math.min(1,e/(o*c)));return Math.acos(D)}function U(r,t){n(r,"First vector"),n(t,"Second vector");let e=b(r,t);return r.x*t.y-r.y*t.x>=0?e:-e}function W(r,t){n(r,"First point"),n(t,"Second point");let e=t.x-r.x,o=t.y-r.y,c=Math.sqrt(e*e+o*o);return y(c)?0:c}function _(r,t){n(r,"First point"),n(t,"Second point");let e=t.x-r.x,o=t.y-r.y;return e*e+o*o}function v(r,t){x(r,"First point"),x(t,"Second point");let e=t.x-r.x,o=t.y-r.y,c=t.z-r.z,D=Math.sqrt(e*e+o*o+c*c);return y(D)?0:D}function rr(r,t){x(r,"First point"),x(t,"Second point");let e=t.x-r.x,o=t.y-r.y,c=t.z-r.z;return e*e+o*o+c*c}function tr(r,t){i(r,"First point"),i(t,"Second point");let e=t.x-r.x,o=t.y-r.y,c=t.z-r.z,D=t.w-r.w,V=Math.sqrt(e*e+o*o+c*c+D*D);return y(V)?0:V}function er(r,t){i(r,"First point"),i(t,"Second point");let e=t.x-r.x,o=t.y-r.y,c=t.z-r.z,D=t.w-r.w;return e*e+o*o+c*c+D*D}function or(r,t,e){return n(r,"Start vector"),n(t,"End vector"),u(e,"t"),{x:r.x+(t.x-r.x)*e,y:r.y+(t.y-r.y)*e}}function nr(r,t,e){n(r,"Start vector"),n(t,"End vector"),u(e,"t");let o=Math.max(0,Math.min(1,e));return{x:r.x+(t.x-r.x)*o,y:r.y+(t.y-r.y)*o}}function q(r,t,e){return x(r,"Start vector"),x(t,"End vector"),u(e,"t"),{x:r.x+(t.x-r.x)*e,y:r.y+(t.y-r.y)*e,z:r.z+(t.z-r.z)*e}}function cr(r,t,e){x(r,"Start vector"),x(t,"End vector"),u(e,"t");let o=Math.max(0,Math.min(1,e));return{x:r.x+(t.x-r.x)*o,y:r.y+(t.y-r.y)*o,z:r.z+(t.z-r.z)*o}}function ur(r,t,e){return i(r,"Start vector"),i(t,"End vector"),u(e,"t"),{x:r.x+(t.x-r.x)*e,y:r.y+(t.y-r.y)*e,z:r.z+(t.z-r.z)*e,w:r.w+(t.w-r.w)*e}}function xr(r,t,e){i(r,"Start vector"),i(t,"End vector"),u(e,"t");let o=Math.max(0,Math.min(1,e));return{x:r.x+(t.x-r.x)*o,y:r.y+(t.y-r.y)*o,z:r.z+(t.z-r.z)*o,w:r.w+(t.w-r.w)*o}}function Dr(r,t,e){x(r,"Start vector"),x(t,"End vector"),u(e,"t");let o=p(r),c=p(t);if(Math.abs(o-1)>1e-8||Math.abs(c-1)>1e-8)throw new Error("SLERP requires unit vectors");let D=Math.max(0,Math.min(1,e)),V=S(r,t),z=Math.max(-1,Math.min(1,V));if(z>.9995)return E(q(r,t,D));let s=Math.acos(z),f=Math.sin(s),w=Math.sin((1-D)*s)/f,h=Math.sin(D*s)/f;return F(l(r,w),l(t,h))}function ir(r,t,e){n(r,"Start vector"),n(t,"End vector"),u(e,"t");let o=e*e*(3-2*e);return{x:r.x+(t.x-r.x)*o,y:r.y+(t.y-r.y)*o}}function yr(r,t,e){n(r,"Start vector"),n(t,"End vector"),u(e,"t");let o=Math.max(0,Math.min(1,e)),c=o*o*(3-2*o);return{x:r.x+(t.x-r.x)*c,y:r.y+(t.y-r.y)*c}}function Vr(r,t,e){n(r,"Start vector"),n(t,"End vector"),u(e,"t");let o=e*e*e*(e*(e*6-15)+10);return{x:r.x+(t.x-r.x)*o,y:r.y+(t.y-r.y)*o}}function mr(r,t,e,o){n(r,"Start point"),n(t,"Control point"),n(e,"End point"),u(o,"t");let c=1-o,D=c*c*r.x+2*c*o*t.x+o*o*e.x,V=c*c*r.y+2*c*o*t.y+o*o*e.y;return{x:D,y:V}}function sr(r,t,e,o,c){n(r,"Start point"),n(t,"First control point"),n(e,"Second control point"),n(o,"End point"),u(c,"t");let D=1-c,V=D*D,z=V*D,s=c*c,f=s*c,w=z*r.x+3*V*c*t.x+3*D*s*e.x+f*o.x,h=z*r.y+3*V*c*t.y+3*D*s*e.y+f*o.y;return{x:w,y:h}}function pr(r,t,e,o,c){return u(r,"value"),u(t,"inMin"),u(e,"inMax"),u(o,"outMin"),u(c,"outMax"),m(t,e)?o:o+(c-o)*(r-t)/(e-t)}function zr(r,t,e,o,c){if(u(r,"value"),u(t,"inMin"),u(e,"inMax"),u(o,"outMin"),u(c,"outMax"),m(t,e))return o;let D=(r-t)/(e-t),V=Math.max(0,Math.min(1,D));return o+(c-o)*V}function T(r,t){n(r),u(t,"angle");let e=Math.cos(t),o=Math.sin(t);return{x:r.x*e-r.y*o,y:r.x*o+r.y*e}}function fr(r,t){return T(r,t*(Math.PI/180))}function dr(r,t){n(r,"Vector"),n(t,"Normal");let e=d(t);if(Math.abs(e-1)>1e-10)throw new Error("Normal vector must be unit length for reflection");let o=a(r,t);return{x:r.x-2*o*t.x,y:r.y-2*o*t.y}}function wr(r,t){n(r,"First vector"),n(t,"Second vector");let e=M(t);if(y(e))throw new Error("Cannot project onto zero or near-zero vector");let o=a(r,t)/e;return{x:t.x*o,y:t.y*o}}function hr(r,t){return n(r,"First vector"),n(t,"Second vector"),m(r.x,t.x)&&m(r.y,t.y)}function ar(r,t){return x(r,"First vector"),x(t,"Second vector"),m(r.x,t.x)&&m(r.y,t.y)&&m(r.z,t.z)}function lr(r,t){return i(r,"First vector"),i(t,"Second vector"),m(r.x,t.x)&&m(r.y,t.y)&&m(r.z,t.z)&&m(r.w,t.w)}function gr(r,t){return n(r,"First point"),n(t,"Second point"),{x:(r.x+t.x)/2,y:(r.y+t.y)/2}}function Sr(r){if(!Array.isArray(r)||r.length===0)throw new Error("Points array must not be empty");let t=0,e=0;for(let o=0;o<r.length;o++)n(r[o],`points[${o}]`),t+=r[o].x,e+=r[o].y;return{x:t/r.length,y:e/r.length}}function Mr(r){return n(r),{x:-r.x,y:-r.y}}function Er(r){return x(r),{x:-r.x,y:-r.y,z:-r.z}}function Fr(r){return i(r),{x:-r.x,y:-r.y,z:-r.z,w:-r.w}}function br(r,t=!0){return n(r),t?{x:r.y,y:-r.x}:{x:-r.y,y:r.x}}function qr(){return{x:0,y:0}}function Tr(){return{x:0,y:0,z:0}}function $r(){return{x:0,y:0,z:0,w:0}}function Cr(){return{x:1,y:0}}function jr(){return{x:0,y:1}}function Br(){return{x:1,y:0,z:0}}function Nr(){return{x:0,y:1,z:0}}function Pr(){return{x:0,y:0,z:1}}export{L as addVectors2D,F as addVectors3D,k as addVectors4D,b as angleBetween2D,Q as angleBetween3D,Sr as centroid2D,$ as createVector2D,C as createVector3D,j as createVector4D,I as crossProduct3D,sr as cubicBezier2D,W as distance2D,v as distance3D,tr as distance4D,_ as distanceSquared2D,rr as distanceSquared3D,er as distanceSquared4D,a as dotProduct2D,S as dotProduct3D,Z as dotProduct4D,or as lerp2D,q as lerp3D,ur as lerp4D,nr as lerpClamped2D,cr as lerpClamped3D,xr as lerpClamped4D,d as magnitude2D,p as magnitude3D,g as magnitude4D,M as magnitudeSquared2D,B as magnitudeSquared3D,N as magnitudeSquared4D,pr as mapRange,zr as mapRangeClamped,gr as midpoint2D,Mr as negateVector2D,Er as negateVector3D,Fr as negateVector4D,P as normalize2D,E as normalize3D,X as normalize4D,br as perpendicular2D,wr as project2D,mr as quadraticBezier2D,dr as reflect2D,T as rotate2D,fr as rotate2DDegrees,A as safeNormalize2D,R as safeNormalize3D,Y as safeNormalize4D,K as scaleVector2D,l as scaleVector3D,O as scaleVector4D,U as signedAngleBetween2D,Dr as slerp3D,Vr as smootherstep2D,ir as smoothstep2D,yr as smoothstepClamped2D,G as subtractVectors2D,H as subtractVectors3D,J as subtractVectors4D,Cr as unitX2D,Br as unitX3D,jr as unitY2D,Nr as unitY3D,Pr as unitZ3D,hr as vectorsEqual2D,ar as vectorsEqual3D,lr as vectorsEqual4D,qr as zeroVector2D,Tr as zeroVector3D,$r as zeroVector4D};
+// src/lib/maths/fn/vector.ts
+function validateNumber(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${name} must be a finite number, got ${value}`);
+  }
+}
+function isApproximatelyZero(value) {
+  return Math.abs(value) < 1e-9;
+}
+function approximatelyEqual(a, b) {
+  return Math.abs(a - b) < 1e-6;
+}
+function validateVector2D(vector, name = "Vector2D") {
+  if (!vector || typeof vector !== "object") {
+    throw new Error(`${name} must be an object`);
+  }
+  validateNumber(vector.x, `${name}.x`);
+  validateNumber(vector.y, `${name}.y`);
+}
+function validateVector3D(vector, name = "Vector3D") {
+  if (!vector || typeof vector !== "object") {
+    throw new Error(`${name} must be an object`);
+  }
+  validateNumber(vector.x, `${name}.x`);
+  validateNumber(vector.y, `${name}.y`);
+  validateNumber(vector.z, `${name}.z`);
+}
+function validateVector4D(vector, name = "Vector4D") {
+  if (!vector || typeof vector !== "object") {
+    throw new Error(`${name} must be an object`);
+  }
+  validateNumber(vector.x, `${name}.x`);
+  validateNumber(vector.y, `${name}.y`);
+  validateNumber(vector.z, `${name}.z`);
+  validateNumber(vector.w, `${name}.w`);
+}
+function createVector2D(x, y) {
+  validateNumber(x, "x");
+  validateNumber(y, "y");
+  return { x, y };
+}
+function createVector3D(x, y, z) {
+  validateNumber(x, "x");
+  validateNumber(y, "y");
+  validateNumber(z, "z");
+  return { x, y, z };
+}
+function createVector4D(x, y, z, w) {
+  validateNumber(x, "x");
+  validateNumber(y, "y");
+  validateNumber(z, "z");
+  validateNumber(w, "w");
+  return { x, y, z, w };
+}
+function magnitude2D(vector) {
+  validateVector2D(vector);
+  const magnitude = Math.sqrt(vector.x * vector.x + vector.y * vector.y);
+  return isApproximatelyZero(magnitude) ? 0 : magnitude;
+}
+function magnitudeSquared2D(vector) {
+  validateVector2D(vector);
+  return vector.x * vector.x + vector.y * vector.y;
+}
+function magnitude3D(vector) {
+  validateVector3D(vector);
+  const magnitude = Math.sqrt(
+    vector.x * vector.x + vector.y * vector.y + vector.z * vector.z
+  );
+  return isApproximatelyZero(magnitude) ? 0 : magnitude;
+}
+function magnitudeSquared3D(vector) {
+  validateVector3D(vector);
+  return vector.x * vector.x + vector.y * vector.y + vector.z * vector.z;
+}
+function magnitude4D(vector) {
+  validateVector4D(vector);
+  const magnitude = Math.sqrt(
+    vector.x * vector.x + vector.y * vector.y + vector.z * vector.z + vector.w * vector.w
+  );
+  return isApproximatelyZero(magnitude) ? 0 : magnitude;
+}
+function magnitudeSquared4D(vector) {
+  validateVector4D(vector);
+  return vector.x * vector.x + vector.y * vector.y + vector.z * vector.z + vector.w * vector.w;
+}
+function normalize2D(vector) {
+  validateVector2D(vector);
+  const mag = magnitude2D(vector);
+  if (isApproximatelyZero(mag)) {
+    throw new Error("Cannot normalize zero or near-zero vector");
+  }
+  return {
+    x: vector.x / mag,
+    y: vector.y / mag
+  };
+}
+function safeNormalize2D(vector) {
+  validateVector2D(vector);
+  const mag = magnitude2D(vector);
+  if (isApproximatelyZero(mag)) {
+    return { x: 0, y: 0 };
+  }
+  return {
+    x: vector.x / mag,
+    y: vector.y / mag
+  };
+}
+function normalize3D(vector) {
+  validateVector3D(vector);
+  const mag = magnitude3D(vector);
+  if (isApproximatelyZero(mag)) {
+    throw new Error("Cannot normalize zero or near-zero vector");
+  }
+  return {
+    x: vector.x / mag,
+    y: vector.y / mag,
+    z: vector.z / mag
+  };
+}
+function safeNormalize3D(vector) {
+  validateVector3D(vector);
+  const mag = magnitude3D(vector);
+  if (isApproximatelyZero(mag)) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  return {
+    x: vector.x / mag,
+    y: vector.y / mag,
+    z: vector.z / mag
+  };
+}
+function normalize4D(vector) {
+  validateVector4D(vector);
+  const mag = magnitude4D(vector);
+  if (isApproximatelyZero(mag)) {
+    throw new Error("Cannot normalize zero or near-zero vector");
+  }
+  return {
+    x: vector.x / mag,
+    y: vector.y / mag,
+    z: vector.z / mag,
+    w: vector.w / mag
+  };
+}
+function safeNormalize4D(vector) {
+  validateVector4D(vector);
+  const mag = magnitude4D(vector);
+  if (isApproximatelyZero(mag)) {
+    return { x: 0, y: 0, z: 0, w: 0 };
+  }
+  return {
+    x: vector.x / mag,
+    y: vector.y / mag,
+    z: vector.z / mag,
+    w: vector.w / mag
+  };
+}
+function dotProduct2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  return a.x * b.x + a.y * b.y;
+}
+function dotProduct3D(a, b) {
+  validateVector3D(a, "First vector");
+  validateVector3D(b, "Second vector");
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function dotProduct4D(a, b) {
+  validateVector4D(a, "First vector");
+  validateVector4D(b, "Second vector");
+  return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+}
+function crossProduct3D(a, b) {
+  validateVector3D(a, "First vector");
+  validateVector3D(b, "Second vector");
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function addVectors2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  return {
+    x: a.x + b.x,
+    y: a.y + b.y
+  };
+}
+function addVectors3D(a, b) {
+  validateVector3D(a, "First vector");
+  validateVector3D(b, "Second vector");
+  return {
+    x: a.x + b.x,
+    y: a.y + b.y,
+    z: a.z + b.z
+  };
+}
+function addVectors4D(a, b) {
+  validateVector4D(a, "First vector");
+  validateVector4D(b, "Second vector");
+  return {
+    x: a.x + b.x,
+    y: a.y + b.y,
+    z: a.z + b.z,
+    w: a.w + b.w
+  };
+}
+function subtractVectors2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y
+  };
+}
+function subtractVectors3D(a, b) {
+  validateVector3D(a, "First vector");
+  validateVector3D(b, "Second vector");
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y,
+    z: a.z - b.z
+  };
+}
+function subtractVectors4D(a, b) {
+  validateVector4D(a, "First vector");
+  validateVector4D(b, "Second vector");
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y,
+    z: a.z - b.z,
+    w: a.w - b.w
+  };
+}
+function scaleVector2D(vector, scalar) {
+  validateVector2D(vector);
+  validateNumber(scalar, "scalar");
+  return {
+    x: vector.x * scalar,
+    y: vector.y * scalar
+  };
+}
+function scaleVector3D(vector, scalar) {
+  validateVector3D(vector);
+  validateNumber(scalar, "scalar");
+  return {
+    x: vector.x * scalar,
+    y: vector.y * scalar,
+    z: vector.z * scalar
+  };
+}
+function scaleVector4D(vector, scalar) {
+  validateVector4D(vector);
+  validateNumber(scalar, "scalar");
+  return {
+    x: vector.x * scalar,
+    y: vector.y * scalar,
+    z: vector.z * scalar,
+    w: vector.w * scalar
+  };
+}
+function angleBetween2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  const dot = dotProduct2D(a, b);
+  const magA = magnitude2D(a);
+  const magB = magnitude2D(b);
+  if (isApproximatelyZero(magA) || isApproximatelyZero(magB)) {
+    throw new Error("Cannot calculate angle with zero or near-zero vector");
+  }
+  const cosTheta = Math.max(-1, Math.min(1, dot / (magA * magB)));
+  return Math.acos(cosTheta);
+}
+function angleBetween3D(a, b) {
+  validateVector3D(a, "First vector");
+  validateVector3D(b, "Second vector");
+  const dot = dotProduct3D(a, b);
+  const magA = magnitude3D(a);
+  const magB = magnitude3D(b);
+  if (isApproximatelyZero(magA) || isApproximatelyZero(magB)) {
+    throw new Error("Cannot calculate angle with zero or near-zero vector");
+  }
+  const cosTheta = Math.max(-1, Math.min(1, dot / (magA * magB)));
+  return Math.acos(cosTheta);
+}
+function signedAngleBetween2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  const angle = angleBetween2D(a, b);
+  const cross = a.x * b.y - a.y * b.x;
+  return cross >= 0 ? angle : -angle;
+}
+function distance2D(a, b) {
+  validateVector2D(a, "First point");
+  validateVector2D(b, "Second point");
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  return isApproximatelyZero(distance) ? 0 : distance;
+}
+function distanceSquared2D(a, b) {
+  validateVector2D(a, "First point");
+  validateVector2D(b, "Second point");
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  return dx * dx + dy * dy;
+}
+function distance3D(a, b) {
+  validateVector3D(a, "First point");
+  validateVector3D(b, "Second point");
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const dz = b.z - a.z;
+  const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  return isApproximatelyZero(distance) ? 0 : distance;
+}
+function distanceSquared3D(a, b) {
+  validateVector3D(a, "First point");
+  validateVector3D(b, "Second point");
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const dz = b.z - a.z;
+  return dx * dx + dy * dy + dz * dz;
+}
+function distance4D(a, b) {
+  validateVector4D(a, "First point");
+  validateVector4D(b, "Second point");
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const dz = b.z - a.z;
+  const dw = b.w - a.w;
+  const distance = Math.sqrt(dx * dx + dy * dy + dz * dz + dw * dw);
+  return isApproximatelyZero(distance) ? 0 : distance;
+}
+function distanceSquared4D(a, b) {
+  validateVector4D(a, "First point");
+  validateVector4D(b, "Second point");
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const dz = b.z - a.z;
+  const dw = b.w - a.w;
+  return dx * dx + dy * dy + dz * dz + dw * dw;
+}
+function lerp2D(start, end, t) {
+  validateVector2D(start, "Start vector");
+  validateVector2D(end, "End vector");
+  validateNumber(t, "t");
+  return {
+    x: start.x + (end.x - start.x) * t,
+    y: start.y + (end.y - start.y) * t
+  };
+}
+function lerpClamped2D(start, end, t) {
+  validateVector2D(start, "Start vector");
+  validateVector2D(end, "End vector");
+  validateNumber(t, "t");
+  const clampedT = Math.max(0, Math.min(1, t));
+  return {
+    x: start.x + (end.x - start.x) * clampedT,
+    y: start.y + (end.y - start.y) * clampedT
+  };
+}
+function lerp3D(start, end, t) {
+  validateVector3D(start, "Start vector");
+  validateVector3D(end, "End vector");
+  validateNumber(t, "t");
+  return {
+    x: start.x + (end.x - start.x) * t,
+    y: start.y + (end.y - start.y) * t,
+    z: start.z + (end.z - start.z) * t
+  };
+}
+function lerpClamped3D(start, end, t) {
+  validateVector3D(start, "Start vector");
+  validateVector3D(end, "End vector");
+  validateNumber(t, "t");
+  const clampedT = Math.max(0, Math.min(1, t));
+  return {
+    x: start.x + (end.x - start.x) * clampedT,
+    y: start.y + (end.y - start.y) * clampedT,
+    z: start.z + (end.z - start.z) * clampedT
+  };
+}
+function lerp4D(start, end, t) {
+  validateVector4D(start, "Start vector");
+  validateVector4D(end, "End vector");
+  validateNumber(t, "t");
+  return {
+    x: start.x + (end.x - start.x) * t,
+    y: start.y + (end.y - start.y) * t,
+    z: start.z + (end.z - start.z) * t,
+    w: start.w + (end.w - start.w) * t
+  };
+}
+function lerpClamped4D(start, end, t) {
+  validateVector4D(start, "Start vector");
+  validateVector4D(end, "End vector");
+  validateNumber(t, "t");
+  const clampedT = Math.max(0, Math.min(1, t));
+  return {
+    x: start.x + (end.x - start.x) * clampedT,
+    y: start.y + (end.y - start.y) * clampedT,
+    z: start.z + (end.z - start.z) * clampedT,
+    w: start.w + (end.w - start.w) * clampedT
+  };
+}
+function slerp3D(start, end, t) {
+  validateVector3D(start, "Start vector");
+  validateVector3D(end, "End vector");
+  validateNumber(t, "t");
+  const startMag = magnitude3D(start);
+  const endMag = magnitude3D(end);
+  if (Math.abs(startMag - 1) > 1e-8 || Math.abs(endMag - 1) > 1e-8) {
+    throw new Error("SLERP requires unit vectors");
+  }
+  const clampedT = Math.max(0, Math.min(1, t));
+  const dot = dotProduct3D(start, end);
+  const clampedDot = Math.max(-1, Math.min(1, dot));
+  if (clampedDot > 0.9995) {
+    return normalize3D(lerp3D(start, end, clampedT));
+  }
+  const theta = Math.acos(clampedDot);
+  const sinTheta = Math.sin(theta);
+  const factor1 = Math.sin((1 - clampedT) * theta) / sinTheta;
+  const factor2 = Math.sin(clampedT * theta) / sinTheta;
+  return addVectors3D(
+    scaleVector3D(start, factor1),
+    scaleVector3D(end, factor2)
+  );
+}
+function smoothstep2D(start, end, t) {
+  validateVector2D(start, "Start vector");
+  validateVector2D(end, "End vector");
+  validateNumber(t, "t");
+  const smoothedT = t * t * (3 - 2 * t);
+  return {
+    x: start.x + (end.x - start.x) * smoothedT,
+    y: start.y + (end.y - start.y) * smoothedT
+  };
+}
+function smoothstepClamped2D(start, end, t) {
+  validateVector2D(start, "Start vector");
+  validateVector2D(end, "End vector");
+  validateNumber(t, "t");
+  const clampedT = Math.max(0, Math.min(1, t));
+  const smoothedT = clampedT * clampedT * (3 - 2 * clampedT);
+  return {
+    x: start.x + (end.x - start.x) * smoothedT,
+    y: start.y + (end.y - start.y) * smoothedT
+  };
+}
+function smootherstep2D(start, end, t) {
+  validateVector2D(start, "Start vector");
+  validateVector2D(end, "End vector");
+  validateNumber(t, "t");
+  const smootherT = t * t * t * (t * (t * 6 - 15) + 10);
+  return {
+    x: start.x + (end.x - start.x) * smootherT,
+    y: start.y + (end.y - start.y) * smootherT
+  };
+}
+function quadraticBezier2D(p0, p1, p2, t) {
+  validateVector2D(p0, "Start point");
+  validateVector2D(p1, "Control point");
+  validateVector2D(p2, "End point");
+  validateNumber(t, "t");
+  const oneMinusT = 1 - t;
+  const x = oneMinusT * oneMinusT * p0.x + 2 * oneMinusT * t * p1.x + t * t * p2.x;
+  const y = oneMinusT * oneMinusT * p0.y + 2 * oneMinusT * t * p1.y + t * t * p2.y;
+  return { x, y };
+}
+function cubicBezier2D(p0, p1, p2, p3, t) {
+  validateVector2D(p0, "Start point");
+  validateVector2D(p1, "First control point");
+  validateVector2D(p2, "Second control point");
+  validateVector2D(p3, "End point");
+  validateNumber(t, "t");
+  const oneMinusT = 1 - t;
+  const oneMinusT2 = oneMinusT * oneMinusT;
+  const oneMinusT3 = oneMinusT2 * oneMinusT;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const x = oneMinusT3 * p0.x + 3 * oneMinusT2 * t * p1.x + 3 * oneMinusT * t2 * p2.x + t3 * p3.x;
+  const y = oneMinusT3 * p0.y + 3 * oneMinusT2 * t * p1.y + 3 * oneMinusT * t2 * p2.y + t3 * p3.y;
+  return { x, y };
+}
+function mapRange(value, inMin, inMax, outMin, outMax) {
+  validateNumber(value, "value");
+  validateNumber(inMin, "inMin");
+  validateNumber(inMax, "inMax");
+  validateNumber(outMin, "outMin");
+  validateNumber(outMax, "outMax");
+  if (approximatelyEqual(inMin, inMax)) {
+    return outMin;
+  }
+  return outMin + (outMax - outMin) * (value - inMin) / (inMax - inMin);
+}
+function mapRangeClamped(value, inMin, inMax, outMin, outMax) {
+  validateNumber(value, "value");
+  validateNumber(inMin, "inMin");
+  validateNumber(inMax, "inMax");
+  validateNumber(outMin, "outMin");
+  validateNumber(outMax, "outMax");
+  if (approximatelyEqual(inMin, inMax)) {
+    return outMin;
+  }
+  const t = (value - inMin) / (inMax - inMin);
+  const clampedT = Math.max(0, Math.min(1, t));
+  return outMin + (outMax - outMin) * clampedT;
+}
+function rotate2D(vector, angle) {
+  validateVector2D(vector);
+  validateNumber(angle, "angle");
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  return {
+    x: vector.x * cos - vector.y * sin,
+    y: vector.x * sin + vector.y * cos
+  };
+}
+function rotate2DDegrees(vector, degrees) {
+  return rotate2D(vector, degrees * (Math.PI / 180));
+}
+function reflect2D(vector, normal) {
+  validateVector2D(vector, "Vector");
+  validateVector2D(normal, "Normal");
+  const normalMag = magnitude2D(normal);
+  if (Math.abs(normalMag - 1) > 1e-10) {
+    throw new Error("Normal vector must be unit length for reflection");
+  }
+  const dot = dotProduct2D(vector, normal);
+  return {
+    x: vector.x - 2 * dot * normal.x,
+    y: vector.y - 2 * dot * normal.y
+  };
+}
+function project2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  const bMagSquared = magnitudeSquared2D(b);
+  if (isApproximatelyZero(bMagSquared)) {
+    throw new Error("Cannot project onto zero or near-zero vector");
+  }
+  const scale = dotProduct2D(a, b) / bMagSquared;
+  return {
+    x: b.x * scale,
+    y: b.y * scale
+  };
+}
+function vectorsEqual2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  return approximatelyEqual(a.x, b.x) && approximatelyEqual(a.y, b.y);
+}
+function vectorsEqual3D(a, b) {
+  validateVector3D(a, "First vector");
+  validateVector3D(b, "Second vector");
+  return approximatelyEqual(a.x, b.x) && approximatelyEqual(a.y, b.y) && approximatelyEqual(a.z, b.z);
+}
+function vectorsEqual4D(a, b) {
+  validateVector4D(a, "First vector");
+  validateVector4D(b, "Second vector");
+  return approximatelyEqual(a.x, b.x) && approximatelyEqual(a.y, b.y) && approximatelyEqual(a.z, b.z) && approximatelyEqual(a.w, b.w);
+}
+function midpoint2D(a, b) {
+  validateVector2D(a, "First point");
+  validateVector2D(b, "Second point");
+  return {
+    x: (a.x + b.x) / 2,
+    y: (a.y + b.y) / 2
+  };
+}
+function centroid2D(points) {
+  if (!Array.isArray(points) || points.length === 0) {
+    throw new Error("Points array must not be empty");
+  }
+  let sumX = 0;
+  let sumY = 0;
+  for (let i = 0; i < points.length; i++) {
+    validateVector2D(points[i], `points[${i}]`);
+    sumX += points[i].x;
+    sumY += points[i].y;
+  }
+  return {
+    x: sumX / points.length,
+    y: sumY / points.length
+  };
+}
+function negateVector2D(vector) {
+  validateVector2D(vector);
+  return { x: -vector.x, y: -vector.y };
+}
+function negateVector3D(vector) {
+  validateVector3D(vector);
+  return { x: -vector.x, y: -vector.y, z: -vector.z };
+}
+function negateVector4D(vector) {
+  validateVector4D(vector);
+  return { x: -vector.x, y: -vector.y, z: -vector.z, w: -vector.w };
+}
+function perpendicular2D(vector, clockwise = true) {
+  validateVector2D(vector);
+  if (clockwise) {
+    return { x: vector.y, y: -vector.x };
+  } else {
+    return { x: -vector.y, y: vector.x };
+  }
+}
+function zeroVector2D() {
+  return { x: 0, y: 0 };
+}
+function zeroVector3D() {
+  return { x: 0, y: 0, z: 0 };
+}
+function zeroVector4D() {
+  return { x: 0, y: 0, z: 0, w: 0 };
+}
+function unitX2D() {
+  return { x: 1, y: 0 };
+}
+function unitY2D() {
+  return { x: 0, y: 1 };
+}
+function unitX3D() {
+  return { x: 1, y: 0, z: 0 };
+}
+function unitY3D() {
+  return { x: 0, y: 1, z: 0 };
+}
+function unitZ3D() {
+  return { x: 0, y: 0, z: 1 };
+}
+export {
+  addVectors2D,
+  addVectors3D,
+  addVectors4D,
+  angleBetween2D,
+  angleBetween3D,
+  centroid2D,
+  createVector2D,
+  createVector3D,
+  createVector4D,
+  crossProduct3D,
+  cubicBezier2D,
+  distance2D,
+  distance3D,
+  distance4D,
+  distanceSquared2D,
+  distanceSquared3D,
+  distanceSquared4D,
+  dotProduct2D,
+  dotProduct3D,
+  dotProduct4D,
+  lerp2D,
+  lerp3D,
+  lerp4D,
+  lerpClamped2D,
+  lerpClamped3D,
+  lerpClamped4D,
+  magnitude2D,
+  magnitude3D,
+  magnitude4D,
+  magnitudeSquared2D,
+  magnitudeSquared3D,
+  magnitudeSquared4D,
+  mapRange,
+  mapRangeClamped,
+  midpoint2D,
+  negateVector2D,
+  negateVector3D,
+  negateVector4D,
+  normalize2D,
+  normalize3D,
+  normalize4D,
+  perpendicular2D,
+  project2D,
+  quadraticBezier2D,
+  reflect2D,
+  rotate2D,
+  rotate2DDegrees,
+  safeNormalize2D,
+  safeNormalize3D,
+  safeNormalize4D,
+  scaleVector2D,
+  scaleVector3D,
+  scaleVector4D,
+  signedAngleBetween2D,
+  slerp3D,
+  smootherstep2D,
+  smoothstep2D,
+  smoothstepClamped2D,
+  subtractVectors2D,
+  subtractVectors3D,
+  subtractVectors4D,
+  unitX2D,
+  unitX3D,
+  unitY2D,
+  unitY3D,
+  unitZ3D,
+  vectorsEqual2D,
+  vectorsEqual3D,
+  vectorsEqual4D,
+  zeroVector2D,
+  zeroVector3D,
+  zeroVector4D
+};