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

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

@@ -1 +1,728 @@
-"use strict";var l=Object.defineProperty;var C=Object.getOwnPropertyDescriptor;var j=Object.getOwnPropertyNames;var B=Object.prototype.hasOwnProperty;var N=(r,t)=>{for(var e in t)l(r,e,{get:t[e],enumerable:!0})},P=(r,t,e,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of j(t))!B.call(r,n)&&n!==e&&l(r,n,{get:()=>t[n],enumerable:!(o=C(t,n))||o.enumerable});return r};var A=r=>P(l({},"__esModule",{value:!0}),r);var kr={};N(kr,{addVectors2D:()=>Q,addVectors3D:()=>b,addVectors4D:()=>U,angleBetween2D:()=>q,angleBetween3D:()=>er,centroid2D:()=>$r,createVector2D:()=>R,createVector3D:()=>X,createVector4D:()=>Y,crossProduct3D:()=>O,cubicBezier2D:()=>ar,distance2D:()=>nr,distance3D:()=>ur,distance4D:()=>Dr,distanceSquared2D:()=>cr,distanceSquared3D:()=>xr,distanceSquared4D:()=>ir,dotProduct2D:()=>w,dotProduct3D:()=>M,dotProduct4D:()=>K,lerp2D:()=>yr,lerp3D:()=>T,lerp4D:()=>sr,lerpClamped2D:()=>Vr,lerpClamped3D:()=>mr,lerpClamped4D:()=>pr,magnitude2D:()=>z,magnitude3D:()=>p,magnitude4D:()=>S,magnitudeSquared2D:()=>E,magnitudeSquared3D:()=>Z,magnitudeSquared4D:()=>I,mapRange:()=>lr,mapRangeClamped:()=>gr,midpoint2D:()=>Tr,negateVector2D:()=>Cr,negateVector3D:()=>jr,negateVector4D:()=>Br,normalize2D:()=>L,normalize3D:()=>F,normalize4D:()=>H,perpendicular2D:()=>Nr,project2D:()=>Er,quadraticBezier2D:()=>hr,reflect2D:()=>Mr,rotate2D:()=>$,rotate2DDegrees:()=>Sr,safeNormalize2D:()=>k,safeNormalize3D:()=>G,safeNormalize4D:()=>J,scaleVector2D:()=>rr,scaleVector3D:()=>g,scaleVector4D:()=>tr,signedAngleBetween2D:()=>or,slerp3D:()=>zr,smootherstep2D:()=>wr,smoothstep2D:()=>fr,smoothstepClamped2D:()=>dr,subtractVectors2D:()=>W,subtractVectors3D:()=>_,subtractVectors4D:()=>v,unitX2D:()=>Xr,unitX3D:()=>Zr,unitY2D:()=>Yr,unitY3D:()=>Ir,unitZ3D:()=>Lr,vectorsEqual2D:()=>Fr,vectorsEqual3D:()=>br,vectorsEqual4D:()=>qr,zeroVector2D:()=>Pr,zeroVector3D:()=>Ar,zeroVector4D:()=>Rr});module.exports=A(kr);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 c(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(r,t){return u(r,"x"),u(t,"y"),{x:r,y:t}}function X(r,t,e){return u(r,"x"),u(t,"y"),u(e,"z"),{x:r,y:t,z:e}}function Y(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 z(r){c(r);let t=Math.sqrt(r.x*r.x+r.y*r.y);return y(t)?0:t}function E(r){return c(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 Z(r){return x(r),r.x*r.x+r.y*r.y+r.z*r.z}function S(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 I(r){return i(r),r.x*r.x+r.y*r.y+r.z*r.z+r.w*r.w}function L(r){c(r);let t=z(r);if(y(t))throw new Error("Cannot normalize zero or near-zero vector");return{x:r.x/t,y:r.y/t}}function k(r){c(r);let t=z(r);return y(t)?{x:0,y:0}:{x:r.x/t,y:r.y/t}}function F(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 G(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 H(r){i(r);let t=S(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 J(r){i(r);let t=S(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 w(r,t){return c(r,"First vector"),c(t,"Second vector"),r.x*t.x+r.y*t.y}function M(r,t){return x(r,"First vector"),x(t,"Second vector"),r.x*t.x+r.y*t.y+r.z*t.z}function K(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 O(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 Q(r,t){return c(r,"First vector"),c(t,"Second vector"),{x:r.x+t.x,y:r.y+t.y}}function b(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 U(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 W(r,t){return c(r,"First vector"),c(t,"Second vector"),{x:r.x-t.x,y:r.y-t.y}}function _(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 v(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 rr(r,t){return c(r),u(t,"scalar"),{x:r.x*t,y:r.y*t}}function g(r,t){return x(r),u(t,"scalar"),{x:r.x*t,y:r.y*t,z:r.z*t}}function tr(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 q(r,t){c(r,"First vector"),c(t,"Second vector");let e=w(r,t),o=z(r),n=z(t);if(y(o)||y(n))throw new Error("Cannot calculate angle with zero or near-zero vector");let D=Math.max(-1,Math.min(1,e/(o*n)));return Math.acos(D)}function er(r,t){x(r,"First vector"),x(t,"Second vector");let e=M(r,t),o=p(r),n=p(t);if(y(o)||y(n))throw new Error("Cannot calculate angle with zero or near-zero vector");let D=Math.max(-1,Math.min(1,e/(o*n)));return Math.acos(D)}function or(r,t){c(r,"First vector"),c(t,"Second vector");let e=q(r,t);return r.x*t.y-r.y*t.x>=0?e:-e}function nr(r,t){c(r,"First point"),c(t,"Second point");let e=t.x-r.x,o=t.y-r.y,n=Math.sqrt(e*e+o*o);return y(n)?0:n}function cr(r,t){c(r,"First point"),c(t,"Second point");let e=t.x-r.x,o=t.y-r.y;return e*e+o*o}function ur(r,t){x(r,"First point"),x(t,"Second point");let e=t.x-r.x,o=t.y-r.y,n=t.z-r.z,D=Math.sqrt(e*e+o*o+n*n);return y(D)?0:D}function xr(r,t){x(r,"First point"),x(t,"Second point");let e=t.x-r.x,o=t.y-r.y,n=t.z-r.z;return e*e+o*o+n*n}function Dr(r,t){i(r,"First point"),i(t,"Second point");let e=t.x-r.x,o=t.y-r.y,n=t.z-r.z,D=t.w-r.w,V=Math.sqrt(e*e+o*o+n*n+D*D);return y(V)?0:V}function ir(r,t){i(r,"First point"),i(t,"Second point");let e=t.x-r.x,o=t.y-r.y,n=t.z-r.z,D=t.w-r.w;return e*e+o*o+n*n+D*D}function yr(r,t,e){return c(r,"Start vector"),c(t,"End vector"),u(e,"t"),{x:r.x+(t.x-r.x)*e,y:r.y+(t.y-r.y)*e}}function Vr(r,t,e){c(r,"Start vector"),c(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 T(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 mr(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 sr(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 pr(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 zr(r,t,e){x(r,"Start vector"),x(t,"End vector"),u(e,"t");let o=p(r),n=p(t);if(Math.abs(o-1)>1e-8||Math.abs(n-1)>1e-8)throw new Error("SLERP requires unit vectors");let D=Math.max(0,Math.min(1,e)),V=M(r,t),f=Math.max(-1,Math.min(1,V));if(f>.9995)return F(T(r,t,D));let s=Math.acos(f),d=Math.sin(s),h=Math.sin((1-D)*s)/d,a=Math.sin(D*s)/d;return b(g(r,h),g(t,a))}function fr(r,t,e){c(r,"Start vector"),c(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 dr(r,t,e){c(r,"Start vector"),c(t,"End vector"),u(e,"t");let o=Math.max(0,Math.min(1,e)),n=o*o*(3-2*o);return{x:r.x+(t.x-r.x)*n,y:r.y+(t.y-r.y)*n}}function wr(r,t,e){c(r,"Start vector"),c(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 hr(r,t,e,o){c(r,"Start point"),c(t,"Control point"),c(e,"End point"),u(o,"t");let n=1-o,D=n*n*r.x+2*n*o*t.x+o*o*e.x,V=n*n*r.y+2*n*o*t.y+o*o*e.y;return{x:D,y:V}}function ar(r,t,e,o,n){c(r,"Start point"),c(t,"First control point"),c(e,"Second control point"),c(o,"End point"),u(n,"t");let D=1-n,V=D*D,f=V*D,s=n*n,d=s*n,h=f*r.x+3*V*n*t.x+3*D*s*e.x+d*o.x,a=f*r.y+3*V*n*t.y+3*D*s*e.y+d*o.y;return{x:h,y:a}}function lr(r,t,e,o,n){return u(r,"value"),u(t,"inMin"),u(e,"inMax"),u(o,"outMin"),u(n,"outMax"),m(t,e)?o:o+(n-o)*(r-t)/(e-t)}function gr(r,t,e,o,n){if(u(r,"value"),u(t,"inMin"),u(e,"inMax"),u(o,"outMin"),u(n,"outMax"),m(t,e))return o;let D=(r-t)/(e-t),V=Math.max(0,Math.min(1,D));return o+(n-o)*V}function $(r,t){c(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 Sr(r,t){return $(r,t*(Math.PI/180))}function Mr(r,t){c(r,"Vector"),c(t,"Normal");let e=z(t);if(Math.abs(e-1)>1e-10)throw new Error("Normal vector must be unit length for reflection");let o=w(r,t);return{x:r.x-2*o*t.x,y:r.y-2*o*t.y}}function Er(r,t){c(r,"First vector"),c(t,"Second vector");let e=E(t);if(y(e))throw new Error("Cannot project onto zero or near-zero vector");let o=w(r,t)/e;return{x:t.x*o,y:t.y*o}}function Fr(r,t){return c(r,"First vector"),c(t,"Second vector"),m(r.x,t.x)&&m(r.y,t.y)}function br(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 qr(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 Tr(r,t){return c(r,"First point"),c(t,"Second point"),{x:(r.x+t.x)/2,y:(r.y+t.y)/2}}function $r(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++)c(r[o],`points[${o}]`),t+=r[o].x,e+=r[o].y;return{x:t/r.length,y:e/r.length}}function Cr(r){return c(r),{x:-r.x,y:-r.y}}function jr(r){return x(r),{x:-r.x,y:-r.y,z:-r.z}}function Br(r){return i(r),{x:-r.x,y:-r.y,z:-r.z,w:-r.w}}function Nr(r,t=!0){return c(r),t?{x:r.y,y:-r.x}:{x:-r.y,y:r.x}}function Pr(){return{x:0,y:0}}function Ar(){return{x:0,y:0,z:0}}function Rr(){return{x:0,y:0,z:0,w:0}}function Xr(){return{x:1,y:0}}function Yr(){return{x:0,y:1}}function Zr(){return{x:1,y:0,z:0}}function Ir(){return{x:0,y:1,z:0}}function Lr(){return{x:0,y:0,z:1}}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/maths/fn/vector.ts
+var vector_exports = {};
+__export(vector_exports, {
+  addVectors2D: () => addVectors2D,
+  addVectors3D: () => addVectors3D,
+  addVectors4D: () => addVectors4D,
+  angleBetween2D: () => angleBetween2D,
+  angleBetween3D: () => angleBetween3D,
+  centroid2D: () => centroid2D,
+  createVector2D: () => createVector2D,
+  createVector3D: () => createVector3D,
+  createVector4D: () => createVector4D,
+  crossProduct3D: () => crossProduct3D,
+  cubicBezier2D: () => cubicBezier2D,
+  distance2D: () => distance2D,
+  distance3D: () => distance3D,
+  distance4D: () => distance4D,
+  distanceSquared2D: () => distanceSquared2D,
+  distanceSquared3D: () => distanceSquared3D,
+  distanceSquared4D: () => distanceSquared4D,
+  dotProduct2D: () => dotProduct2D,
+  dotProduct3D: () => dotProduct3D,
+  dotProduct4D: () => dotProduct4D,
+  lerp2D: () => lerp2D,
+  lerp3D: () => lerp3D,
+  lerp4D: () => lerp4D,
+  lerpClamped2D: () => lerpClamped2D,
+  lerpClamped3D: () => lerpClamped3D,
+  lerpClamped4D: () => lerpClamped4D,
+  magnitude2D: () => magnitude2D,
+  magnitude3D: () => magnitude3D,
+  magnitude4D: () => magnitude4D,
+  magnitudeSquared2D: () => magnitudeSquared2D,
+  magnitudeSquared3D: () => magnitudeSquared3D,
+  magnitudeSquared4D: () => magnitudeSquared4D,
+  mapRange: () => mapRange,
+  mapRangeClamped: () => mapRangeClamped,
+  midpoint2D: () => midpoint2D,
+  negateVector2D: () => negateVector2D,
+  negateVector3D: () => negateVector3D,
+  negateVector4D: () => negateVector4D,
+  normalize2D: () => normalize2D,
+  normalize3D: () => normalize3D,
+  normalize4D: () => normalize4D,
+  perpendicular2D: () => perpendicular2D,
+  project2D: () => project2D,
+  quadraticBezier2D: () => quadraticBezier2D,
+  reflect2D: () => reflect2D,
+  rotate2D: () => rotate2D,
+  rotate2DDegrees: () => rotate2DDegrees,
+  safeNormalize2D: () => safeNormalize2D,
+  safeNormalize3D: () => safeNormalize3D,
+  safeNormalize4D: () => safeNormalize4D,
+  scaleVector2D: () => scaleVector2D,
+  scaleVector3D: () => scaleVector3D,
+  scaleVector4D: () => scaleVector4D,
+  signedAngleBetween2D: () => signedAngleBetween2D,
+  slerp3D: () => slerp3D,
+  smootherstep2D: () => smootherstep2D,
+  smoothstep2D: () => smoothstep2D,
+  smoothstepClamped2D: () => smoothstepClamped2D,
+  subtractVectors2D: () => subtractVectors2D,
+  subtractVectors3D: () => subtractVectors3D,
+  subtractVectors4D: () => subtractVectors4D,
+  unitX2D: () => unitX2D,
+  unitX3D: () => unitX3D,
+  unitY2D: () => unitY2D,
+  unitY3D: () => unitY3D,
+  unitZ3D: () => unitZ3D,
+  vectorsEqual2D: () => vectorsEqual2D,
+  vectorsEqual3D: () => vectorsEqual3D,
+  vectorsEqual4D: () => vectorsEqual4D,
+  zeroVector2D: () => zeroVector2D,
+  zeroVector3D: () => zeroVector3D,
+  zeroVector4D: () => zeroVector4D
+});
+module.exports = __toCommonJS(vector_exports);
+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 };
+}